Slices in Go: A Deep Dive with Examples

When writing Go programs, you’ll find that arrays are often too rigid to be practical. That’s where slices come into play. Slices are Go’s built-in abstraction over arrays that offer flexibility, power, and performance.

In this blog, we’ll explore:

• What slices are
• How they work internally
• How to create and use them
• Common pitfalls
• Best practices with examples

📌 What is a Slice?

A slice is a dynamically-sized, flexible view into the elements of an array. It doesn't store data itself — it points to an underlying array.

Slice Structure (Internally)

A slice in Go is a small struct with 3 fields:

type slice struct {
    ptr *T   // pointer to the underlying array
    len int  // number of elements in the slice
    cap int  // total capacity (from ptr to end of array)
}

✅ Creating Slices

1. From an Array

arr := [5]int{10, 20, 30, 40, 50}
slice := arr[1:4] // [20 30 40]

Here:

• slice references the array arr from index 1 to 3 (excluding index 4).
• len(slice) = 3
• cap(slice) = 4 (from index 1 to end of the array)

2. Using Slice Literal

numbers := []int{1, 2, 3}

This creates both a slice and its underlying array.

3. Using make()

s := make([]int, 3)        // [0 0 0]
s := make([]int, 3, 5)     // len=3, cap=5

🔁 Slicing a Slice

data := []int{100, 200, 300, 400}
sub := data[1:3] // [200 300]

This sub-slice shares memory with the original slice. Changing sub affects data:

sub[0] = 999
fmt.Println(data) // [100 999 300 400]

➕ Appending Elements

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

If the slice’s capacity is full, Go automatically allocates a new underlying array.

⚠️ Shared Memory Behavior

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

s1[1] = 999
fmt.Println(arr) // [1 999 3 4]
fmt.Println(s2)  // [999 3]

Tip:

To avoid this, use copy():

original := []int{1, 2, 3}
clone := make([]int, len(original))
copy(clone, original)

📈 Capacity Growth with append()

Go typically doubles the capacity when appending exceeds the current capacity.

s := make([]int, 0, 2)
s = append(s, 1, 2, 3)

fmt.Println(s) // [1 2 3]

If the capacity is exceeded, a new array is allocated behind the scenes.

📦 Built-in Functions

🧪 Complete Example

func main() {
    original := []int{10, 20, 30, 40, 50}

    slice1 := original[1:4]
    fmt.Println("Slice1:", slice1) // [20 30 40]

    slice2 := append(slice1, 99)
    fmt.Println("Original:", original)
    fmt.Println("Slice2:", slice2)

    slice1[0] = 777
    fmt.Println("Modified Slice1:", slice1)
    fmt.Println("Modified Original:", original)
}

Output (May vary based on capacity reuse):

Slice1: [20 30 40]
Original: [10 20 30 40 99]
Slice2: [20 30 40 99]
Modified Slice1: [777 30 40]
Modified Original: [10 777 30 40 99]

❗ Common Mistakes

🔹 Assuming slices are independent:

a := []int{1, 2, 3}
b := a
b[0] = 999
fmt.Println(a) // [999 2 3]

Use copy() to truly clone a slice.

🔹 Forgetting that append() might create a new array

Always check whether your slice is still pointing to the original memory if you rely on shared behavior.

✅ Best Practices

• Use slices for most collections — they’re more idiomatic and dynamic than arrays.
• Use copy() when independence is needed.
• Avoid unnecessary slicing inside performance-critical loops.
• Use make([]T, len, cap) if you know the size ahead of time.

🧠 Summary

🔚 Final Thoughts

Slices are a cornerstone of Go’s design, combining performance with flexibility. Understanding how slices share memory with arrays, grow, and interact with built-in functions is essential for writing idiomatic and safe Go code.

Once you master slices, you’ll write cleaner, more efficient programs — and avoid some tricky bugs!