Core packages

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

var ErrNoStock = errors.New("out of stock")

in := bufio.NewReader(os.Stdin)
out := bufio.NewWriter(os.Stdout)
defer out.Flush() // forgetting this prints nothing
 
var n int
fmt.Fscan(in, &n)

package main
 
import (
	"bufio"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
)
 
func main() {
	dir, err := os.MkdirTemp("", "golesson-")
	if err != nil {
		panic(err)
	}
	defer os.RemoveAll(dir) // clean up everything at the end
 
	// Whole-file write and read.
	notes := filepath.Join(dir, "notes.txt")
	if err := os.WriteFile(notes, []byte("line one\nline two\nline three\n"), 0o644); err != nil {
		panic(err)
	}
	data, _ := os.ReadFile(notes)
	fmt.Printf("read %d bytes\n", len(data))
 
	// Line by line with a Scanner.
	f, _ := os.Open(notes)
	sc := bufio.NewScanner(f)
	for n := 1; sc.Scan(); n++ {
		fmt.Printf("%d: %s\n", n, sc.Text())
	}
	f.Close()
 
	// Build a small tree, then walk it.
	os.MkdirAll(filepath.Join(dir, "src", "util"), 0o755)
	for _, name := range []string{"src/main.go", "src/util/strings.go", "src/util/README.md"} {
		os.WriteFile(filepath.Join(dir, name), []byte("x"), 0o644)
	}
	filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		rel, _ := filepath.Rel(dir, path)
		if strings.HasSuffix(path, ".go") {
			fmt.Println("go file:", filepath.ToSlash(rel))
		}
		return nil
	})
 
	// A missing file is an error you can test for.
	_, err = os.ReadFile(filepath.Join(dir, "missing.txt"))
	fmt.Println("missing file is fs.ErrNotExist:", errors.Is(err, fs.ErrNotExist))
}

read 29 bytes
1: line one
2: line two
3: line three
go file: src/main.go
go file: src/util/strings.go
missing file is fs.ErrNotExist: true

package main
 
import (
	"cmp"
	"fmt"
	"slices"
	"sort"
)
 
type Person struct {
	Name string
	Age  int
}
 
// ByName implements sort.Interface, the pre-generics way.
type ByName []Person
 
func (p ByName) Len() int           { return len(p) }
func (p ByName) Less(i, j int) bool { return p[i].Name < p[j].Name }
func (p ByName) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
func main() {
	kids := []Person{{"Jill", 9}, {"Jack", 10}, {"Ana", 9}}
 
	sort.Sort(ByName(kids))
	fmt.Println("by name (sort.Sort):", kids)
 
	slices.SortStableFunc(kids, func(a, b Person) int { return cmp.Compare(a.Age, b.Age) })
	fmt.Println("by age, stable:     ", kids) // Ana before Jill: their name order is kept
 
	i, found := slices.BinarySearchFunc(kids, 10, func(p Person, age int) int { return cmp.Compare(p.Age, age) })
	fmt.Println("first age-10 kid:", kids[i].Name, found)
}

by name (sort.Sort): [{Ana 9} {Jack 10} {Jill 9}]
by age, stable:      [{Ana 9} {Jill 9} {Jack 10}]
first age-10 kid: Jack true

package main
 
import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"hash/crc32"
	"io"
	"strings"
)
 
func checksum(r io.Reader) uint32 {
	h := crc32.NewIEEE()
	io.Copy(h, r) // a hash is an io.Writer: stream data into it
	return h.Sum32()
}
 
func main() {
	a := checksum(strings.NewReader("hello world"))
	b := checksum(strings.NewReader("hello world"))
	c := checksum(strings.NewReader("hello World"))
	fmt.Println("same content, same crc:", a == b, " one letter changed:", a == c)
 
	sum := sha256.Sum256([]byte("password123"))
	fmt.Println("sha256:", hex.EncodeToString(sum[:])[:16]+"…")
	fmt.Println("digest size:", len(sum), "bytes")
}

same content, same crc: true  one letter changed: false
sha256: ef92b778bafe771e…
digest size: 32 bytes

package main
 
import (
	"bufio"
	"bytes"
	"container/list"
	"crypto/sha256"
	"errors"
	"fmt"
	"hash/crc32"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"slices"
	"strconv"
	"strings"
)
 
var ErrNoStock = errors.New("out of stock")
 
// countWords works with any Reader: files, network or strings.
func countWords(r io.Reader) (map[string]int, error) {
	counts := map[string]int{}
	sc := bufio.NewScanner(r)
	sc.Split(bufio.ScanWords)
	for sc.Scan() {
		counts[strings.ToLower(sc.Text())]++
	}
	return counts, sc.Err()
}
 
func main() {
	// strings and strconv
	fmt.Println(strings.Fields(" go  is fun "), strings.Split("a,b,c", ","),
		strings.Repeat("ab", 3), strings.Index("gopher", "ph"))
	var sb strings.Builder
	for i := range 3 {
		sb.WriteString(strconv.Itoa(i))
	}
	fmt.Println(sb.String())
 
	// io
	var buf bytes.Buffer
	io.Copy(&buf, strings.NewReader("Go go GO stop"))
	counts, _ := countWords(&buf)
	fmt.Println(counts["go"], counts["stop"])
 
	// files and folders
	dir, _ := os.MkdirTemp("", "demo")
	defer os.RemoveAll(dir)
	path := filepath.Join(dir, "notes.txt")
	if err := os.WriteFile(path, []byte("line 1\nline 2\n"), 0o644); err != nil {
		fmt.Println(err)
		return
	}
	f, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	lines := bufio.NewScanner(f)
	for lines.Scan() {
		fmt.Println("read:", lines.Text())
	}
	filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
		if err == nil && !d.IsDir() {
			info, _ := d.Info()
			fmt.Println("file:", d.Name(), info.Size(), "bytes")
		}
		return nil
	})
	_, err = os.ReadFile(filepath.Join(dir, "missing.txt"))
	fmt.Println("missing file is an error:", err != nil)
 
	// errors
	fmt.Println(ErrNoStock)
 
	// containers and sorting
	l := list.New()
	l.PushBack("b")
	l.PushFront("a")
	l.PushBack("c")
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value, " ")
	}
	fmt.Println()
	nums := []int{5, 2, 9, 1}
	slices.Sort(nums)
	fmt.Println(nums)
 
	// hashes
	fmt.Println(crc32.ChecksumIEEE([]byte("gopher")))
	fmt.Printf("%x\n", sha256.Sum256([]byte("gopher")))
}

[go is fun] [a b c] ababab 2
012
3 1
read: line 1
read: line 2
file: notes.txt 14 bytes
missing file is an error: true
out of stock
a b c 
[1 2 5 9]
875285291
9cc1ee455a3363ffc504f40006f70d0c8276648a5d3eb3f9524e94d1b7a83aef