Pointers & Dynamic Data — Final Project

Code

Build the project — four files

Your app has finally outgrown one file. The capstone splits it into four — use the tabs above the code to move between them. Build them top to bottom; each depends on the one before.

item.go — the record type. A struct bundles the fields your list needs (here a title, a priority, a status). The json:"..." tags name the fields on disk, so saving works.

storage.go — save and load. Data must survive a restart, so it lives in a file. saveItems turns the whole []Item into readable JSON and writes items.json; loadItems reads it back at startup — and treats a missing file as a normal first run, not an error, via errors.Is(err, fs.ErrNotExist).

actions.go — the operations. All the logic lives in small functions with clear jobs (the checklist wants at least four; here there are six): addItem (append), listItems, markDone (takes a pointer *Item — the only way to change the original, not a copy), searchItems (case-insensitive filter), indexByTitle (the map from lesson 9, for exact lookup), and summary (the "X of Y done" stat).

main.go — the menu loop. It loads the data, then spins in for + switch until q. Every branch checks the Atoi error and the bounds, prints a message and continues — the program never crashes. On quit, the list is saved.

Verify — go run ., add items, quit, run again: your data comes back. Before submitting, gofmt -l . must print nothing and go vet ./... must be silent.

Tip. Your project has different fields (a movie's Year int, Rating float64…) — what matters is the shape: a record type, storage, actions, and a menu, split into four files that each do one job. This is the one place a multi-file split is earned — the program is genuinely too big for a single file now.

item.go CREATE

Create this file in ./

package main

// Item is one tracked task — the record type every other feature works on.
// A struct with three fields covers the checklist minimum.
type Item struct {
	Title    string `json:"title"`
	Priority int    `json:"priority"` // 1 = low, 2 = normal, 3 = high
	Done     bool   `json:"done"`
}

storage.go CREATE

Create this file in ./

package main

import (
	"encoding/json"
	"errors"
	"io/fs"
	"os"
)

const saveFile = "items.json"

// 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.
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
}

actions.go CREATE

Create this file in ./

package main

import (
	"fmt"
	"strings"
)

// addItem appends a new item built from user input.
func addItem(items []Item, title string, priority int) []Item {
	return append(items, Item{Title: title, Priority: priority})
}

// listItems prints every item, numbered, with a done checkbox.
func listItems(items []Item) {
	if len(items) == 0 {
		fmt.Println("No items yet.")
		return
	}
	for i, it := range items {
		status := " "
		if it.Done {
			status = "x"
		}
		fmt.Printf("%2d. [%s] %s (priority %d)\n", i+1, status, it.Title, it.Priority)
	}
}

// markDone flips one item in place — it needs a POINTER so it changes the
// original item, not a copy.
func markDone(it *Item) {
	it.Done = true
}

// searchItems returns the items whose title contains the keyword
// (case-insensitive).
func searchItems(items []Item, keyword string) []Item {
	var found []Item
	for _, it := range items {
		if strings.Contains(strings.ToLower(it.Title), strings.ToLower(keyword)) {
			found = append(found, it)
		}
	}
	return found
}

// indexByTitle builds a map for direct lookup of an item by its exact title.
func indexByTitle(items []Item) map[string]Item {
	m := make(map[string]Item, len(items))
	for _, it := range items {
		m[it.Title] = it
	}
	return m
}

// summary prints the "X of Y done" stat plus the high-priority count.
func summary(items []Item) {
	done, high := 0, 0
	for _, it := range items {
		if it.Done {
			done++
		}
		if it.Priority == 3 {
			high++
		}
	}
	fmt.Printf("%d of %d done, %d high-priority\n", done, len(items), high)
}

main.go CREATE

Create this file in ./

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

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

	// The menu loop: repeats until "q". Every branch validates its input
	// and continues instead of crashing.
	for {
		fmt.Println("\n1) Add  2) List  3) Mark done  4) Search  5) Lookup  6) Summary  q) Quit")
		fmt.Print("> ")
		switch readLine() {
		case "1":
			fmt.Print("Title: ")
			title := readLine()
			fmt.Print("Priority (1-3): ")
			p, err := strconv.Atoi(readLine())
			if err != nil || p < 1 || p > 3 {
				fmt.Println("Priority must be 1, 2 or 3.")
				continue
			}
			items = addItem(items, title, p)
		case "2":
			listItems(items)
		case "3":
			fmt.Print("Item number: ")
			n, err := strconv.Atoi(readLine())
			if err != nil || n < 1 || n > len(items) {
				fmt.Println("No item with that number.")
				continue
			}
			markDone(&items[n-1])
			fmt.Println("Done:", items[n-1].Title)
		case "4":
			fmt.Print("Keyword: ")
			listItems(searchItems(items, readLine()))
		case "5":
			fmt.Print("Exact title: ")
			if it, ok := indexByTitle(items)[readLine()]; ok {
				fmt.Printf("Found: %s (priority %d, done %v)\n", it.Title, it.Priority, it.Done)
			} else {
				fmt.Println("Not found.")
			}
		case "6":
			summary(items)
		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.")
		}
	}
}

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

// readLine reads one whole trimmed line of user input.
func readLine() string {
	scanner.Scan()
	return strings.TrimSpace(scanner.Text())
}