Pertvarkyk main.go — skaičiavimas ir paieška

Dvi naujos galios TAVO programai, abi paremtos map. Item įgauna Category lauką (Add dabar jo klausia), o meniu — 4) Stats by category ir 5) Find by title. Add / List / Mark read lieka.

Išplėsk struktūrą ir Add veiksmą:

type Item struct {
	Title     string
	Pages     int
	PagesRead int
	Read      bool
	Category  string // NAUJA
}

			fmt.Print("Category: ")
			category := readLine()
			items = append(items, Item{Title: title, Pages: pages, Category: category})

Skaičiavimas pagal kategoriją — m[k]++ šablonas. Vienas pagalbininkas suglaudžia slice į kategorija → kiekis map:

func countByCategory(items []Item) map[string]int {
	counts := make(map[string]int)
	for _, it := range items {
		counts[it.Category]++ // nesamas raktas prasideda nuo 0, tada +1
	}
	return counts
}

Jokio „ar jau mačiau šią kategoriją?" tikrinimo — nesamas raktas skaitosi kaip 0, tad ++ tiesiog veikia. showStats (meniu 4) pereina per skaičius ir juos atspausdina. Prisimink 2 žingsnį: ta tvarka atsitiktinė.

Paieška pagal pavadinimą — comma-ok su map[string]Item. Kartą pasidaryk paieškos lentelę, tada skaityk ją comma-ok idioma (meniu 5):

func indexByTitle(items []Item) map[string]Item {
	index := make(map[string]Item, len(items))
	for _, it := range items {
		index[it.Title] = it
	}
	return index
}

		case "5":
			fmt.Print("Exact title: ")
			index := indexByTitle(items)
			if it, ok := index[readLine()]; ok {
				fmt.Printf("Found: %s — %d pages, %s\n", it.Title, it.Pages, it.Category)
			} else {
				fmt.Println("Not found.")
			}

Būtent ok daro tai saugu: nesamas pavadinimas duoda nulinį Item{} su ok == false, tad spausdini „Not found.", o ne tuščią įrašą.

Patikrink — pridėk tris knygas dviejose kategorijose, tada statistiką ir paiešką:

> 1
Title: Dune
Pages: 412
Category: sci-fi
Added: Dune
... (taip pat pridėk War and Peace / history, Hyperion / sci-fi)

> 4
sci-fi       2
history      1

> 5
Exact title: Dune
Found: Dune — 412 pages, sci-fi

> 5
Exact title: Unknown Book
Not found.

Spąstai (atsitiktinė map tvarka). Paleisk 4 du kartus — dvi kategorijų eilutės gali sukeisti vietas. Go sąmoningai atsitiktinai maišo range per map, kad niekas nesiremtų tvarka, kurios niekada nebuvo žadėta. Nekovok su tuo; map skirtas paieškai ir skaičiavimui, ne tvarkai.

main.go MODIFIKUOTI 47 eilutės pakeistos

Redaguok šį failą kataloge ./

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
	"unicode/utf8"
)

const appName = "Book list"

// Item is one record of the list.
type Item struct {
	Title     string
	Pages     int
	PagesRead int
	Read      bool
	Category  string
}

// scanner is the ONE place the program reads keyboard input.
var scanner = bufio.NewScanner(os.Stdin)

func main() {
	var items []Item

	printHeader()

	for {
		fmt.Println("\n1) Add  2) List  3) Mark read  4) Stats by category  5) Find by title  q) Quit")
		fmt.Print("> ")

		switch readLine() {
		case "1":
			fmt.Print("Title: ")
			title := readLine()
			if msg := validateTitle(title); msg != "" {
				fmt.Println(msg)
				continue
			}
			pages := readInt("Pages: ")
			if pages <= 0 {
				fmt.Println("Pages must be a positive number.")
				continue
			}
			fmt.Print("Category: ")
			category := readLine()
			items = append(items, Item{Title: title, Pages: pages, Category: category})
			fmt.Println("Added:", title)
		case "2":
			listItems(items)
		case "3":
			n := readInt("Item number: ")
			if n < 1 || n > len(items) {
				fmt.Println("No item with that number.")
				continue
			}
			items[n-1].Read = true // index form — changes the REAL element
			fmt.Println("Marked as read:", items[n-1].Title)
		case "4":
			showStats(items)
		case "5":
			fmt.Print("Exact title: ")
			index := indexByTitle(items)
			if it, ok := index[readLine()]; ok { // comma-ok: found?
				fmt.Printf("Found: %s — %d pages, %s\n", it.Title, it.Pages, it.Category)
			} else {
				fmt.Println("Not found.")
			}
		case "q":
			fmt.Println("Bye!")
			return
		default:
			fmt.Println("Unknown choice — try again.")
		}
	}
}

// validateTitle checks the title's REAL length in characters (runes), not bytes.
// len("ąžuolas") is 9 (bytes) but utf8.RuneCountInString is 7 (characters) — a
// Lithuanian title must not be rejected for the wrong length.
func validateTitle(title string) string {
	title = strings.TrimSpace(title)
	n := utf8.RuneCountInString(title)
	if n == 0 {
		return "Title cannot be empty."
	}
	if n > 60 {
		return fmt.Sprintf("Title is too long: %d characters (max 60).", n)
	}
	return ""
}

// readLine reads ONE whole line of input (spaces included) and trims it.
// Unlike fmt.Scanln, which stops at the first space, this reads a full title
// like "Buy milk" instead of just "Buy".
func readLine() string {
	scanner.Scan()
	return strings.TrimSpace(scanner.Text())
}

// readInt keeps asking until the user types a whole number — the retry loop.
func readInt(prompt string) int {
	for {
		fmt.Print(prompt)
		n, err := strconv.Atoi(readLine())
		if err == nil {
			return n
		}
		fmt.Println("Please enter a whole number.")
	}
}

// printHeader prints the app title line (from lesson 3).
func printHeader() {
	fmt.Println("App:", appName)
}

// formatItem builds a clean, ALIGNED one-line summary. %-30s left-aligns the
// title in a 30-column field so a list of items lines up.
func formatItem(it Item) string {
	status := "reading"
	if it.Read {
		status = "done"
	}
	return fmt.Sprintf("%-30s %3d/%-3d  [%s]", it.Title, it.PagesRead, it.Pages, status)
}

// listItems prints every item on the shelf, numbered.
func listItems(items []Item) {
	if len(items) == 0 {
		fmt.Println("No items yet.")
		return
	}
	for i, it := range items {
		fmt.Printf("%2d. %s\n", i+1, formatItem(it))
	}
}

// countByCategory tallies how many items fall in each category.
func countByCategory(items []Item) map[string]int {
	counts := make(map[string]int)
	for _, it := range items {
		counts[it.Category]++ // missing key starts at 0, then +1
	}
	return counts
}

// showStats prints the per-category counts.
func showStats(items []Item) {
	counts := countByCategory(items)
	if len(counts) == 0 {
		fmt.Println("No items yet.")
		return
	}
	// Note: map order is random — the lines may appear in any order.
	for category, n := range counts {
		fmt.Printf("%-12s %d\n", category, n)
	}
}

// indexByTitle builds a title -> Item lookup for an instant find.
func indexByTitle(items []Item) map[string]Item {
	index := make(map[string]Item, len(items))
	for _, it := range items {
		index[it.Title] = it
	}
	return index
}