Slices: length, capacity, append and aliasing

Two appends to one slice can overwrite each other: when dirs holds 3 names with room for 4, append(dirs, "draft.txt") and append(dirs, "final.txt") both come back ending in final.txt. A sliceslice: A view of part of an array, written []T: a pointer to its first element, a length and a capacity. Copying a slice copies only those three fields, so two slices can share elements. owns no elements of its own; it describes part of an array, and append writes into that array whenever it has room.

You will read the three parts of a slice, predict when append shares an array and when it copies, and keep slices apart with a full slice expression. All the output on this page was printed by the programs as they ran with Go 1.27.1.

A slice is a pointer, a length and a capacity

Slicing an array gives a view of some of its elements, and writing through the view writes the array:

// window.go: a slice describes part of an array with a pointer, a length and a capacity.
package main

import "fmt"

func main() {
	arr := [6]int{10, 20, 30, 40, 50, 60}
	s := arr[1:4] // elements 1, 2 and 3 of arr
	fmt.Println(s, "len", len(s), "cap", cap(s))

	s[0] = 99 // s has no elements of its own: this writes arr[1]
	fmt.Println(arr)

	t := s[:cap(s)] // a slice of s may reach as far as its capacity
	fmt.Println(t, "len", len(t), "cap", cap(t))
}

[20 30 40] len 3 cap 5
[10 99 30 40 50 60]
[99 30 40 50 60] len 5 cap 5

arr[1:4] reached three elements, but cap said 5. The specification says a slice value holds a length, a capacity and a reference to its underlying array, the backing arraybacking array: The array that holds a slice's elements. Slices taken from one another share it, so a write through one slice is seen by every slice that reaches the same element.. The length counts the elements the slice can index now; the capacitycapacity: The number of elements from a slice's first element to the end of its backing array, reported by cap. append writes into that room before it needs a new array. counts every element from its first one to the end of the array. Step through the program and watch what each slice reaches:

s[0] = 99 changed arr[1], because a slice has no elements to change except the array’s. And s[:cap(s)] reached two elements that s itself could not index: a slice can be resliced up to its capacity, never past it, so s[:6] would stop the program with the panic slice bounds out of range [:6] with capacity 5. Nothing in the program copied an element; three variables used one array of six ints.

append writes into the array while there is room, then copies

append(s, x) returns a new slice header. If the length of s plus the new elements still fits its capacity, the specification says append re-uses the underlying array: it writes the new elements just past the length and returns a longer view of the same array. Only when they do not fit does it allocate a new, larger array and copy the old elements into it. That is the whole story of the two paths in the opening:

// two_appends.go: two appends to one slice with spare room, and the full slice expression that keeps them apart.
package main

import "fmt"

func main() {
	dirs := make([]string, 0, 4)
	dirs = append(dirs, "home", "asha", "notes") // length 3, room for 4
	draft := append(dirs, "draft.txt")
	final := append(dirs, "final.txt")
	fmt.Println(draft)
	fmt.Println(final)

	safe := dirs[:3:3] // the same elements, capacity 3: no spare room
	draft = append(safe, "draft.txt")
	final = append(safe, "final.txt")
	fmt.Println(draft)
	fmt.Println(final)
	fmt.Println("caps:", cap(dirs), cap(safe), cap(draft))
}

[home asha notes final.txt]
[home asha notes final.txt]
[home asha notes draft.txt]
[home asha notes final.txt]
caps: 4 3 6

Step through both halves of the run:

dirs had length 3 and capacity 4, so both appends wrote into its element 3, and the second write replaced the first: draft and final both printed final.txt. The fix, dirs[:3:3], is a full slice expressionfull slice expression: A slice expression with three indexes, s[low:high:max]. The third index sets the capacity of the result to max - low, so a later append cannot write past high into shared elements.: its third index sets the capacity to max - low, here 3, so nothing is left to share and each append copied into an array of its own. slices.Clip(dirs) returns the same dirs[:len(dirs):len(dirs)].

Assigning the result is also what keeps a slice growing in a loop: each append may hand back a header over a new array, and only the assignment carries it into the next pass.

Sharing a backing array is what makes slicing cheap, and forgetting that two slices share one is what causes aliasing bugs. Three more tools decide how slices share: make([]T, 0, n) makes room for n elements in advance, copy fills an existing slice from another, and slices.Clone gives a slice an array of its own. A nil slice, the zero value of a slice type, has no array at all until the first append makes one.

Growth, preallocation and nil slices, measured Pro: opens with a Pro, Premium or Ultimate pass

Aliasing failures reproduced, and the copies that fix them Pro: opens with a Pro, Premium or Ultimate pass

Practise

Practice covers the two ideas above, the parts of a slice and what append shares, beginning with the one your earlier answers left weaker. A wrong choice tells you what it misses, and a right one why it holds:

Interview questions

Warm-up (fresher): What does a slice value hold?

Three things: a pointer to an element of a backing array, a length and a capacity. The elements themselves are in the array, so copying a slice copies only these three fields, and two slices can share the same elements. len reports the length and cap the capacity.

Three longer questions of the module bank build on this lesson:

Key takeaways

• A slice is a pointer into a backing array with a length and a capacity; slicing copies no elements, and a write through any slice of the array changes the array.
• The capacity counts from the slice’s first element to the end of the array, and a slice can be resliced up to its capacity.
• append writes into the backing array while the capacity allows and copies to a new array only when it does not, so two appends to one base can overwrite each other.
• A full slice expression, s[low:high:max], or slices.Clip, removes the spare capacity, so the next append copies.