Files & Error Handling

Code

Refactor main.go — data survives a restart

The third milestone: your list survives a restart. Everything from lesson 9 stays — we wrap saving and loading around it, and give the fields names on disk.

1. Name the fields on disk — JSON tags:

type Item struct {
	Title     string `json:"title"`
	Pages     int    `json:"pages"`
	PagesRead int    `json:"pagesRead"`
	Read      bool   `json:"read"`
	Category  string `json:"category"`
}

2. Two new functions — save and load:

func saveItems(items []Item) error {
	data, err := json.MarshalIndent(items, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(saveFile, data, 0o644)
}

func loadItems() ([]Item, error) {
	data, err := os.ReadFile(saveFile)
	if errors.Is(err, fs.ErrNotExist) {
		return []Item{}, nil // first run — no file yet, not an error
	}
	if err != nil {
		return nil, err
	}
	var items []Item
	if err := json.Unmarshal(data, &items); err != nil {
		return nil, err
	}
	return items, nil
}

The key line is errors.Is(err, fs.ErrNotExist): a missing file is a normal first run, not a failure — it picks that one case out of every other possible error.

3. Load at startup, save on quit. main opens with items, err := loadItems() (and starts empty if it fails, without crashing); the q branch calls saveItems before "Saved. Bye!":

	items, err := loadItems()
	if err != nil {
		fmt.Println("could not load saved items:", err)
		items = []Item{}
	}

		case "q":
			if err := saveItems(items); err != nil {
				fmt.Println("save failed:", err)
			}
			fmt.Println("Saved. Bye!")
			return

(Add "encoding/json", "errors", "io/fs" to the imports, and const saveFile = "items.json".)

Verify — add a book, quit, then run again and list:

# Run 1: add Dune / 412 / sci-fi, then q
Added: Dune
Saved. Bye!

# Run 2 (fresh start — the list is loaded from disk):
> 2
 1. Dune                             0/412  [reading]

The data survived the restart — open items.json and you'll see your shelf as readable text.

Tip. The capstone (lesson 14) moves saveItems and loadItems into their own storage.go file — you already have them, identical. Splitting a growing program across files is the capstone's job.

main.go MODIFY 46 lines changed

Edit this file in ./

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"strconv"
	"strings"
	"unicode/utf8"
)

const appName = "Book list"

const saveFile = "items.json"

// Item is one record of the list. The json tags name the fields on disk.
type Item struct {
	Title     string `json:"title"`
	Pages     int    `json:"pages"`
	PagesRead int    `json:"pagesRead"`
	Read      bool   `json:"read"`
	Category  string `json:"category"`
}

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

func main() {
	items, err := loadItems() // load whatever we saved last time
	if err != nil {
		fmt.Println("could not load saved items:", err)
		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":
			if err := saveItems(items); err != nil {
				fmt.Println("save failed:", err)
			}
			fmt.Println("Saved. 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
}

// saveItems writes the whole list to disk as readable JSON.
func saveItems(items []Item) error {
	data, err := json.MarshalIndent(items, "", "  ")
	if err != nil {
		return err
	}
	return os.WriteFile(saveFile, data, 0o644)
}

// loadItems reads the list back; a missing file is a normal first run, not an
// error — errors.Is picks out that one case from every other failure.
func loadItems() ([]Item, error) {
	data, err := os.ReadFile(saveFile)
	if errors.Is(err, fs.ErrNotExist) {
		return []Item{}, nil
	}
	if err != nil {
		return nil, err
	}
	var items []Item
	if err := json.Unmarshal(data, &items); err != nil {
		return nil, err
	}
	return items, nil
}