Introduction to Slices

A slice is a flexible view of a sequence of elements. Unlike an array, its length is not part of its type, and a slice can grow using append.

A slice type uses empty brackets: []int. A literal such as []int{2, 4, 6} creates a slice containing three integers. Internally, a slice value describes a portion of an underlying array: a reference to its elements, a length and a capacity.

Assigning one slice to another copies the descriptor, not all its elements. Until an operation reallocates storage, the two slices can refer to the same underlying elements. That distinction is central to correct Go code.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func main() {
	values := []int{2, 4, 6}
	alias := values
	alias[0] = 20
	fmt.Println("Values:", values)
	fmt.Println("Alias:", alias)
	fmt.Println("Length:", len(values))
}

Output

Values: [20 4 6]
Alias: [20 4 6]
Length: 3

Both variables initially describe the same underlying elements. Assigning 20 through alias[0] also changes the first element observed through values. The length remains three.

• A slice assignment does not independently copy all elements.
• A slice is not an array with a secret fixed length; len and cap are separate concepts.

Create a slice of three names and assign it to another variable. Change one element through the second variable and inspect both.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Introduction to Slices in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.