Arrays, Slices & Maps

An array has a fixed length that is part of its type: [3]int and [4]int are different types and cannot be assigned to each other. A new array is filled with zero values. Writing [...]int{2, 3, 5} lets the compiler count the elements for you.

The big surprise for people coming from other languages: an array is a value, not a reference. Assigning it to another variable or passing it to a function copies every element. Arrays of comparable elements can also be compared with ==.

package main

import "fmt"

func setFirst(a [3]int) {
	a[0] = 100 // changes the function's copy only
}

func main() {
	var scores [3]int // [0 0 0]
	scores[1] = 7
	fmt.Println(scores, len(scores))

	primes := [...]int{2, 3, 5, 7} // the compiler counts: [4]int
	fmt.Printf("%v %T\n", primes, primes)

	backup := scores // copies all 3 ints
	backup[0] = 1
	fmt.Println(scores, backup)

	setFirst(scores)
	fmt.Println(scores) // unchanged

	fmt.Println(scores == [3]int{0, 7, 0})
}

[0 7 0] 3
[2 3 5 7] [4]int
[0 7 0] [1 7 0]
[0 7 0]
true

package main

import "fmt"

func main() {
	var scores [3]int
	scores[5] = 10
	fmt.Println(scores)
}

# command-line-arguments
./main.go:7:9: invalid argument: index 5 out of bounds [0:3]

package main

import "fmt"

func main() {
	var scores [3]int
	scores[2] = 10
	fmt.Println(scores)
}

A slice is a window onto an array. Its type has no length — []int — and it is a small three-field value called the slice header: a pointer to the first element, a length (how many elements you can read, len(s)) and a capacity (how many fit before the array runs out, cap(s)).

append(s, x) returns a slice with x added. If there is spare capacity, it writes into the existing array. If not, it allocates a bigger array (roughly double for small slices), copies the old elements across and returns a header pointing at the new array. That is why you must always write s = append(s, x) — the result may be a different array.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30} // slice literal: no length in the brackets
	nums = append(nums, 40)
	fmt.Println(nums, len(nums), cap(nums))

	var s []int // nil slice: len 0, cap 0
	for i := range 5 {
		s = append(s, i)
		fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
	}

	s = append(s, 100, 200) // several values at once
	extra := []int{7, 8}
	s = append(s, extra...) // another slice, spread
	fmt.Println(s)
}

[10 20 30 40] 4 6
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=3 cap=4 [0 1 2]
len=4 cap=4 [0 1 2 3]
len=5 cap=8 [0 1 2 3 4]
[0 1 2 3 4 100 200 7 8]

package main

import "fmt"

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

# command-line-arguments
./main.go:7:2: append(nums, 4) (value of type []int) is not used

package main

import "fmt"

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

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	for i := 0; i <= len(nums); i++ {
		fmt.Println(nums[i])
	}
}

panic: runtime error: index out of range [3] with length 3

goroutine 1 [running]:
main.main()
	./main.go:8 +0x9c
exit status 2

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	for _, n := range nums {
		fmt.Println(n)
	}
}

s[low:high] makes a new slice header over elements low up to (not including) high. It does not copy anything: the new slice points into the same array. Its length is high-low, and its capacity runs to the end of the original array. So a write through one slice is visible through the other — and an append on the smaller slice can quietly overwrite the bigger one.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	window := base[1:3] // [2 3], but cap runs to the end of base
	fmt.Println(window, len(window), cap(window))

	window[0] = 99 // writes into base's array
	fmt.Println(base)

	window = append(window, 42) // spare capacity: overwrites base[3]!
	fmt.Println(base)

	safe := base[1:3:3]    // three-index slice: cap is limited to 3-1 = 2
	safe = append(safe, 7) // no room, so append copies to a new array
	fmt.Println(base, safe)
}

[2 3] 2 4
[1 99 3 4 5]
[1 99 3 42 5]
[1 99 3 42 5] [99 3 7]

When you need an independent copy, make one explicitly. copy(dst, src) copies min(len(dst), len(src)) elements and returns how many it copied; slices.Clone(s) does the allocate-and-copy in one call.

package main

import (
	"fmt"
	"slices"
)

func main() {
	base := []int{1, 2, 3}

	dst := make([]int, len(base))
	n := copy(dst, base)
	dst[0] = -1
	fmt.Println(n, base, dst)

	short := make([]int, 2)
	fmt.Println(copy(short, base), short) // copies only 2

	clone := slices.Clone(base)
	clone[2] = 30
	fmt.Println(base, clone)
}

3 [1 2 3] [-1 2 3]
2 [1 2]
[1 2 3] [1 2 30]

make([]T, len, cap) creates a slice of len zero values with room for cap. Use it when you know the size in advance so append never has to reallocate. A classic mistake is make([]int, 3) followed by append: the three zeros are already elements, and the new values go after them.

A slice declared with var s []int is nil. A nil slice has len 0 and cap 0, range over it does nothing and append works on it — so in most code nil and empty ([]int{}) behave the same. The difference shows up when you compare with nil and when you encode to JSON.

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	wrong := make([]int, 3)
	wrong = append(wrong, 7)
	fmt.Println(wrong) // the 7 lands after three zeros

	right := make([]int, 0, 3) // len 0, room for 3
	right = append(right, 7)
	fmt.Println(right, len(right), cap(right))

	var nilSlice []string
	empty := []string{}
	fmt.Println(nilSlice == nil, empty == nil, len(nilSlice), len(empty))

	a, _ := json.Marshal(nilSlice)
	b, _ := json.Marshal(empty)
	fmt.Println(string(a), string(b))
}

[0 0 0 7]
[7] 1 3
true false 0 0
null []

A 2-D slice is a slice of slices, [][]T. Allocate the outer slice, then each row — rows are independent slices and can even have different lengths. The slices package (Go 1.21+) covers the everyday operations: Contains, Index, Sort, Reverse, Equal, Max.

package main

import (
	"fmt"
	"slices"
)

func main() {
	rows, cols := 3, 4
	grid := make([][]rune, rows)
	for r := range grid {
		grid[r] = make([]rune, cols)
		for c := range grid[r] {
			grid[r][c] = '.'
		}
	}
	grid[1][2] = '#'
	for _, row := range grid {
		fmt.Println(string(row))
	}

	nums := []int{5, 2, 8, 2}
	fmt.Println(slices.Contains(nums, 8), slices.Index(nums, 2), slices.Max(nums))
	slices.Sort(nums)
	fmt.Println(nums, slices.Equal(nums, []int{2, 2, 5, 8}))
}

....
..#.
....
true 1 8
[2 2 5 8] true

package main

import "fmt"

func main() {
	a := []int{1, 2}
	b := []int{1, 2}
	fmt.Println(a == b)
}

# command-line-arguments
./main.go:8:14: invalid operation: a == b (slice can only be compared to nil)

package main

import (
	"fmt"
	"slices"
)

func main() {
	a := []int{1, 2}
	b := []int{1, 2}
	fmt.Println(slices.Equal(a, b))
}

A map stores key/value pairs with fast lookup: map[string]int maps strings to ints. Create one with a literal or make(map[K]V). Keys must be comparable (strings, numbers, booleans, arrays, structs of those — not slices, maps or functions).

• Reading a missing key returns the value type's zero value, not an error. ages["nobody"] is 0.
• Comma-ok tells a missing key from a stored zero: age, ok := ages["bo"] — ok is false when the key is absent.
• delete(m, k) removes a key; deleting a missing key is a no-op.
• Iteration order is random — deliberately, and different on every run. Sort the keys when output order matters. (fmt.Println(m) is the exception: it prints maps sorted by key.)

package main

import (
	"fmt"
	"maps"
	"slices"
)

func main() {
	ages := map[string]int{"ana": 31, "bo": 25}
	ages["cy"] = 40 // insert
	ages["bo"]++    // update in place
	fmt.Println(len(ages), ages["bo"])

	fmt.Println(ages["nobody"]) // missing key: zero value
	if _, ok := ages["nobody"]; !ok {
		fmt.Println("nobody is not in the map")
	}

	delete(ages, "ana")
	delete(ages, "ghost") // no-op, no error

	for _, name := range slices.Sorted(maps.Keys(ages)) {
		fmt.Println(name, ages[name])
	}
	fmt.Println(ages) // fmt sorts map keys when printing
}

3 26
0
nobody is not in the map
bo 26
cy 40
map[bo:26 cy:40]

package main

import "fmt"

func main() {
	var counts map[string]int
	fmt.Println(counts["go"]) // reading a nil map is fine
	counts["go"] = 1
}

panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
	./main.go:8 +0x88
exit status 2

package main

import "fmt"

func main() {
	counts := make(map[string]int)
	counts["go"] = 1
	fmt.Println(counts)
}

Three shapes cover most map code you will write. A counter (map[string]int) relies on missing keys reading as 0, so counts[w]++ just works. A grouping (map[string][]string) relies on a missing key reading as a nil slice, and append accepting nil. A set is a map whose value you ignore, usually map[string]struct{} (the empty struct takes no memory) or map[string]bool.

package main

import (
	"fmt"
	"maps"
	"slices"
	"strings"
)

func main() {
	text := "go is fun and go is fast and simple"
	words := strings.Fields(text)

	counts := map[string]int{}
	for _, w := range words {
		counts[w]++ // missing key reads as 0
	}

	byLetter := map[byte][]string{}
	seen := map[string]struct{}{}
	for _, w := range words {
		if _, dup := seen[w]; dup {
			continue
		}
		seen[w] = struct{}{}
		byLetter[w[0]] = append(byLetter[w[0]], w) // nil slice + append is fine
	}

	for _, w := range slices.Sorted(maps.Keys(counts)) {
		fmt.Printf("%s=%d ", w, counts[w])
	}
	fmt.Println()
	for _, letter := range slices.Sorted(maps.Keys(byLetter)) {
		fmt.Printf("%c: %v\n", letter, byLetter[letter])
	}
	fmt.Println(len(seen), "unique words")
}

and=2 fast=1 fun=1 go=2 is=2 simple=1 
a: [and]
f: [fun fast]
g: [go]
i: [is]
s: [simple]
6 unique words

A Go string is an immutable, read-only slice of bytes, usually UTF-8 text. len(s) counts bytes, and s[i] gives a byte (uint8). A rune is an int32 holding one Unicode code point. English letters take one byte, but é takes two and 世 takes three — which is why range over a string (Module 02) jumped indexes.

package main

import (
	"fmt"
	"strings"
	"unicode/utf8"
)

func main() {
	s := "héllo, 世界"
	fmt.Println(len(s), utf8.RuneCountInString(s)) // bytes vs characters

	fmt.Println(s[0], string(s[0])) // a byte: 104 is 'h'

	runes := []rune(s) // decode into code points
	fmt.Println(len(runes), string(runes[1]), string(runes[7:]))

	b := []byte("gopher") // a mutable copy of the bytes
	b[0] = 'G'
	fmt.Println(string(b))

	var sb strings.Builder // efficient string building
	for i := range 3 {
		fmt.Fprintf(&sb, "[%d]", i)
	}
	fmt.Println(sb.String())
}

14 9
104 h
9 é 世界
Gopher
[0][1][2]

package main

import "fmt"

func main() {
	s := "gopher"
	s[0] = 'G'
	fmt.Println(s)
}

# command-line-arguments
./main.go:7:2: cannot assign to s[0] (neither addressable nor a map index expression)

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "gopher"
	s = strings.ToUpper(s[:1]) + s[1:]
	fmt.Println(s)
}

Array

A fixed-length sequence whose length is part of its type ([3]int). Assigning or passing it copies every element.

Slice

A growable view onto an array: a header of pointer, length and capacity. Type []T.

Capacity

cap(s): how many elements fit in the backing array from the slice's start before append must allocate a new one.

Backing array

The array a slice points into. Slices made by slicing the same slice share it, so writes through one are visible through the others.

Three-index slice

s[low:high:max] — a slice whose capacity is limited to max-low, so a later append must copy instead of overwriting.

nil slice

A slice with no backing array (var s []int). len 0, safe to range over and append to; encodes to JSON as null.

Comma-ok

The two-value form v, ok := m[k] that reports whether the key was present.

rune

An alias for int32 holding one Unicode code point. range over a string yields runes.