Go: What is the difference between slice and array?

Array — fixed-length, value-type container where the length is part of the type. Slice — a lightweight, dynamic view over a contiguous block of memory.

Arrays are assigned by value — the entire array is copied. This makes them safe to use without worrying about shared state but expensive for large sizes. Arrays are comparable and can be used as map keys.

1arr := [3]int{1, 2, 3}
2copy := arr     // full copy
3copy[0] = 99
4fmt.Println(arr[0])  // 1 — original unchanged
5
6// Arrays can be map keys
7lookup := map[[32]byte]string{
8    sha256.Sum256([]byte("hello")): "greeting",
9}

Slices are three words in memory: a pointer, length, and capacity. When you slice an existing array or slice, the new slice shares the backing memory. This makes slicing efficient but means mutations can affect the original.

1original := []int{1, 2, 3}
2sub := original[:2]   // shares backing array
3sub[0] = 100
4fmt.Println(original[0])  // 100 — original changed!
5original = append(original, 4)  // may reallocate

When to use:

• Array — small fixed buffers, map keys, cryptographic constants, protocol-level data.
• Slice — default for dynamic sequences; use in function params, returns, and data processing.

Common mistakes:

• Not capturing the return of append — append(s, elem) returns a new slice header.
• Unexpected mutations through shared backing arrays when slicing.
• Passing large arrays to functions (copies everything).
• Comparing slices with == — only valid against nil; use slices.Equal otherwise.