Slice

A slice in Go is a dynamically-sized reference type that provides a view into a contiguous segment of an underlying array. Unlike arrays, which have a fixed size determined at compile time, slices act as references to an underlying array, managing a pointer, length, and capacity at runtime.

Internal Structure

At runtime, a slice is represented as a struct with three fields. While historically represented by reflect.SliceHeader, this type was deprecated in Go 1.20 in favor of unsafe.Slice and unsafe.SliceData. Conceptually, the internal struct operates as follows:

1. Pointer (Data): A memory address pointing to the first element of the underlying array accessible through the slice. This is not necessarily the first element of the array itself.
2. Length (Len): The number of elements currently accessible in the slice.
3. Capacity (Cap): The total number of elements in the underlying array, counting from the Data pointer to the end of the array.

// Conceptual representation of a slice at runtime
type Slice struct {
    Data unsafe.Pointer
    Len  int
    Cap  int
}

Declaration and Initialization

Slices can be initialized using slice literals, the make built-in function, or by slicing an existing array or slice.

// 1. Nil slice (Data=nil, Len=0, Cap=0)
var s1 []int

// 2. Slice literal (allocates an underlying array of size 3)
s2 := []int{10, 20, 30}

// 3. Using make (Type, Length, Capacity)
s3 := make([]int, 5, 10) // Len=5, Cap=10
s4 := make([]int, 5)     // Len=5, Cap=5 (Capacity defaults to Length)

Slicing Operations

You can create a slice from an existing array or slice using the half-open range syntax [low:high]. Go also supports a full slice expression [low:high:max] to explicitly control the resulting slice’s capacity.

arr := [5]int{0, 1, 2, 3, 4} // Underlying array

// Standard slice expression: arr[low:high]
// Length = high - low
// Capacity = len(arr) - low
s := arr[1:4] // Elements: [1, 2, 3], Len: 3, Cap: 4

// Full slice expression: arr[low:high:max]
// Length = high - low
// Capacity = max - low
sFull := arr[1:3:3] // Elements: [1, 2], Len: 2, Cap: 2

Memory Sharing and Mutation

Because a slice contains a pointer to an underlying array, mutating the elements of a slice directly mutates the underlying array. Any other slices sharing that same underlying array will reflect those changes.

arr := [3]int{1, 2, 3}
s1 := arr[0:2] // [1, 2]
s2 := arr[1:3] // [2, 3]

s1[1] = 99     // Modifies arr[1]
// arr is now [1, 99, 3]
// s2 is now [99, 3]

Memory Management Caveat: Creating a small slice from a large array (or another large slice) prevents the entire original underlying array from being garbage collected. Because the new slice’s Data pointer still references the original array, the garbage collector cannot reclaim the unused memory, which can lead to severe memory leaks.

Copying Slices (copy)

To safely duplicate data and decouple a slice from a shared underlying array (preventing both unintended mutations and memory leaks), use the built-in copy function. copy transfers elements from a source slice to a destination slice, returning the number of elements copied. The destination slice must be pre-allocated with sufficient length.

largeSlice := make([]int, 10000)
// ... populate largeSlice ...

// To extract a small portion without leaking the 10000-element array:
smallSlice := make([]int, 5)
copy(smallSlice, largeSlice[10:15]) 
// smallSlice is now backed by its own 5-element array.
// largeSlice can be garbage collected if no longer referenced.

Growth Mechanics (append)

The append built-in function adds elements to the end of a slice. If the slice’s underlying array has sufficient capacity to accommodate the new elements (Len + len(newElements) <= Cap), append places the new elements in the existing array and returns a new slice header with an incremented Len.

If the required length exceeds the current capacity, Go triggers an automatic reallocation:

1. A new, larger underlying array is allocated in memory.
2. Existing elements are copied from the old array to the new array.
3. The new elements are appended.
4. A new slice header pointing to the new array is returned.

s := make([]int, 0, 2) // Len: 0, Cap: 2
s = append(s, 1)       // Len: 1, Cap: 2 (Same underlying array)
s = append(s, 2)       // Len: 2, Cap: 2 (Same underlying array)

// Capacity exceeded. Go allocates a new array, copies [1, 2], and appends 3, 4.
s = append(s, 3, 4)    // Len: 4, Cap: 4 (New underlying array)

Function Arguments (Pass-by-Value Semantics)

While slices are classified as reference types, Go passes all arguments by value. When a slice is passed to a function, Go passes a copy of the slice header struct (containing the Data pointer, Len, and Cap).

Because the copied slice header points to the same underlying array, modifying the elements at specific indices inside the function will mutate the caller’s data. However, modifying the slice’s length or capacity (e.g., via append) only updates the function’s local copy of the slice header. To reflect structural changes in the caller’s scope, the function must return the modified slice and the caller must reassign it.

func modifyElements(s []int) {
    s[0] = 99 // Mutates the underlying array; visible to caller
}

func appendElement(s []int) []int {
    s = append(s, 4) // Modifies local slice header; NOT visible to caller
    return s         // Must return the new header
}

func main() {
    mySlice := []int{1, 2, 3}
    
    modifyElements(mySlice)
    // mySlice is now [99, 2, 3]
    
    mySlice = appendElement(mySlice) // Reassignment required
    // mySlice is now [99, 2, 3, 4]
}

Master Go with Deep Grasping Methodology!

Learn More