Arrays, Slices & Maps

Arrays: fixed size

var nums [3]int              // [0, 0, 0]
letters := [3]string{"a", "b", "c"}

The size is part of the type — [3]int and [4]int are different types. In practice, you’ll rarely use arrays directly; almost everything uses slices instead.

Slices: the workhorse

A slice is a view into an underlying array: a pointer, a length, and a capacity. It grows automatically.

nums := []int{1, 2, 3}
nums = append(nums, 4) // [1 2 3 4]

// pre-size for performance when you know the length
buf := make([]byte, 0, 1024)

package main

import "fmt"

func main() {
nums := []int{1, 2, 3}
nums = append(nums, 4, 5)
fmt.Println(nums, "len:", len(nums), "cap:", cap(nums))

// slicing: [start:end), end exclusive
fmt.Println(nums[1:3])
}

Slicing shares the underlying array by default — mutating a slice can mutate the one it was sliced from. Use copy() when you need an independent copy:

dst := make([]int, len(src))
copy(dst, src)

Maps

ages := map[string]int{
  "alice": 30,
  "bob":   25,
}

ages["carol"] = 40         // insert
age, ok := ages["dave"]    // ok is false if the key is missing
delete(ages, "bob")

package main

import "fmt"

func main() {
ages := map[string]int{"alice": 30, "bob": 25}
ages["carol"] = 40

if age, ok := ages["dave"]; ok {
	fmt.Println("dave is", age)
} else {
	fmt.Println("no entry for dave")
}

for name, age := range ages {
	fmt.Println(name, age)
}
}

Map iteration order is intentionally randomized by the Go runtime — never rely on it. Sort the keys yourself if you need a deterministic order.

De-duplicating a list is a one-liner using a map as a set (map[T]struct{} uses zero bytes per value):

seen := make(map[string]struct{})
var unique []string
for _, item := range items {
  if _, ok := seen[item]; !ok {
    seen[item] = struct{}{}
    unique = append(unique, item)
  }
}

This pattern shows up constantly in data-processing pipelines — deduping URLs, user IDs, log lines, and so on.