07 — Arrays, Slices & Strings

// benchmark_test.go
func BenchmarkAppendNoPrealloc(b *testing.B) {
    b.ReportAllocs()
    for n := 0; n < b.N; n++ {
        s := []int{}            // starts nil, grows via append
        for i := 0; i < 1000; i++ {
            s = append(s, i)
        }
    }
}
// Result: ~1000 allocs/op (one per reallocation cycle)
//         ~8000 B/op

func BenchmarkAppendPrealloc(b *testing.B) {
    b.ReportAllocs()
    for n := 0; n < b.N; n++ {
        s := make([]int, 0, 1000)  // one allocation, capacity for all
        for i := 0; i < 1000; i++ {
            s = append(s, i)  // stays within cap — zero reallocations
        }
    }
}
// Result: 1 alloc/op (the initial make)
//         ~8000 B/op
// ~10x fewer allocations, same memory — the allocation overhead is the win

💡 Tips & Tricks

• Performance: make([]T, 0, capacity) when you know the eventual size — pre-allocating avoids repeated reallocations. The zero in make([]T, 0, n) means "don't pre-fill with zero values I'll overwrite"; the n means "reserve space for n elements."
• Safety: use the full-slice expression s[low:high:max] when you need to prevent aliasing — s[:2:2] forces append to allocate a new array, so the caller's underlying array is never modified.
• Idiom: slices.Clone(s) (Go 1.21+) is the clear way to make an independent copy — make([]T, len(s)); copy(...) is verbose. slices.Clone allocates a new array and copies all elements.
• Performance: strings.Builder.Grow(total) before writing — estimate the total size and pre-grow. Without Grow, the builder doubles its buffer, causing log(n) reallocations. One Grow call can eliminate all of them.
• Idiom: bytes.Equal(a, b) is faster than string(a) == string(b) — it compares bytes directly without allocating string conversions. Same for bytes.Compare vs strings.Compare.
• Debug: the slice aliasing trap — t := s; t = append(t, x) may modify s's underlying array if t's append stays within cap(s). If you need t independent, use slices.Clone(s) or the full-slice expression s[:len(s):len(s)].

⚠️ Edge Cases & Gotchas

• nil slice vs empty slice: var s []int (nil, s == nil true) vs s := []int{} (non-nil, empty). json.Marshal(nil) → null; json.Marshal([]int{}) → []. APIs may treat these differently.
• append to nil slice works: var s []int; s = append(s, 1) → [1]. No need to make first.
• Always reassign append's result: append(s, x) returns a new header (possibly pointing to a new array). If you don't reassign, the growth is lost and the new array is leaked.
• range captures len at start: for i, v := range s evaluates s once; appending to s inside the loop doesn't extend iteration.
• Removing while ranging forward skips elements: indices shift after removal. Build a new slice, iterate backwards, or use slices.DeleteFunc.
• make([]T, n) vs make([]T, 0, n): first gives len n (n zeros); second gives len 0, cap n (empty, ready for n appends). Use the second for "collect n items."
• strings.Builder.String() doesn't copy: returns the internal buffer directly (zero-copy, safe because strings are immutable). Don't call Write after String() — it panics.
• copy returns min(len(dst), len(src)): useful when dst is smaller than src — you know exactly how many elements were copied.
• append with multiple slices: s = append(s, other...) spreads other into s. If cap(s) - len(s) < len(other), append reallocates once. Pre-grow: s = slices.Grow(s, len(other)) then append.

🧠 Quick Quiz

func grow(s []int) []int {
    s = append(s, 1)
    s = append(s, 2)
    s = append(s, 3)
    return s
}

func main() {
    s := make([]int, 0, 2)
    t := grow(s)
    fmt.Println(s, t)
    fmt.Println(cap(s), cap(t))
}