Slice length and capacity in Go

Introduction

Slices in Go let you work with parts of arrays easily. Knowing their length and capacity helps you manage how much data they hold and how much space they can grow into.

When you want to know how many items are currently in a slice.

When you want to check how much more you can add to a slice without making a new array.

When you want to avoid unexpected slowdowns by pre-allocating enough space.

When you want to understand how slicing affects the underlying array.

When debugging or optimizing memory use in your program.

Syntax

Go

len(slice)  // returns the number of elements in the slice
cap(slice)  // returns the capacity of the slice (size of underlying array from start of slice)

len(slice) gives how many elements are currently in the slice.

cap(slice) shows how many elements the slice can hold before needing a new array.

Examples

This slice has 5 elements and capacity 5 because it uses the whole array.

Go

s := []int{1, 2, 3, 4, 5}
fmt.Println(len(s))  // 5
fmt.Println(cap(s))  // 5

The new slice s2 has length 2 (elements 2 and 3) but capacity 4 because it can grow up to the end of the original array.

Go

s := []int{1, 2, 3, 4, 5}
s2 := s[1:3]
fmt.Println(len(s2))  // 2
fmt.Println(cap(s2))  // 4

This slice is created with length 3 but capacity 10, so it has space to add more elements without resizing.

Go

s := make([]int, 3, 10)
fmt.Println(len(s))  // 3
fmt.Println(cap(s))  // 10

Sample Program

This program shows the length and capacity of an original slice, a slice made from it, and a new slice created with make. It helps see how length and capacity change.

Go

package main

import "fmt"

func main() {
    s := []int{10, 20, 30, 40, 50}
    fmt.Printf("Original slice: %v\n", s)
    fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s))

    s2 := s[1:4]
    fmt.Printf("Sliced slice: %v\n", s2)
    fmt.Printf("Length: %d, Capacity: %d\n", len(s2), cap(s2))

    s3 := make([]int, 2, 5)
    fmt.Printf("New slice with make: %v\n", s3)
    fmt.Printf("Length: %d, Capacity: %d\n", len(s3), cap(s3))
}

Important Notes

Length is how many elements you can use right now.

Capacity is how many elements you can add before Go needs to create a new bigger array.

Slicing a slice can reduce length but capacity depends on how much space is left in the original array.

Summary

Length tells how many items are in the slice.

Capacity tells how many items the slice can hold before growing.

Understanding length and capacity helps you write efficient Go programs.

Practice

1. In Go, what does the len() function return when used on a slice?

easy

A. The maximum number of elements the slice can hold

B. The total memory size of the slice in bytes

C. The index of the last element in the slice

D. The number of elements currently in the slice

Solution

1. Step 1: Understand the purpose of len() on slices

   The len() function returns how many elements are currently stored in the slice.

2. Step 2: Differentiate from capacity

   Capacity is about how many elements the slice can hold before resizing, not the current count.

3. Final Answer:

   The number of elements currently in the slice -> Option D

4. Quick Check:

   len(slice) = current element count [OK]

Hint: Remember: len = current items, cap = max before grow [OK]

Common Mistakes:

• Confusing length with capacity
• Thinking len returns memory size
• Assuming len gives last index

2. Which of the following is the correct way to create a slice with length 3 and capacity 5 in Go?

easy

A. make([]int, 5, 3)

B. make([]int, 3, 5)

C. []int{3, 5}

D. make([]int, 3)

Solution

1. Step 1: Recall the make function signature for slices

   make([]T, length, capacity) creates a slice with given length and capacity.

2. Step 2: Match length and capacity values

   To get length 3 and capacity 5, use make([]int, 3, 5).

3. Final Answer:

   make([]int, 3, 5) -> Option B

4. Quick Check:

   make([]int, length, capacity) [OK]

Hint: make([]T, len, cap) sets length then capacity [OK]

Common Mistakes:

• Swapping length and capacity arguments
• Using slice literal instead of make
• Omitting capacity when needed

3. What will be the output of this Go code?

nums := make([]int, 2, 4)
nums[0] = 10
nums[1] = 20
fmt.Println(len(nums), cap(nums))

medium

A. 2 2

B. 0 4

C. 2 4

D. 4 4

Solution

1. Step 1: Analyze slice creation

   make([]int, 2, 4) creates a slice with length 2 and capacity 4.

2. Step 2: Check length and capacity after assignments

   Assigning values to existing indices does not change length or capacity.

3. Final Answer:

   2 4 -> Option C

4. Quick Check:

   len = 2, cap = 4 [OK]

Hint: Length stays same unless you append beyond capacity [OK]

Common Mistakes:

• Confusing length with capacity
• Assuming capacity equals length after assignment
• Thinking length changes when assigning values

4. Consider this code snippet:

arr := []int{1, 2, 3, 4, 5}
slice := arr[1:3]
fmt.Println(len(slice), cap(slice))

What is the correct output?

medium

A. 2 4

B. 2 2

C. 3 4

D. 3 5

Solution

1. Step 1: Determine length of the slice

   The slice is from index 1 to 3 (exclusive), so length = 3 - 1 = 2.

2. Step 2: Calculate capacity of the slice

   Capacity is from start index to end of original array: 5 - 1 = 4.

3. Final Answer:

   2 4 -> Option A

4. Quick Check:

   len = 2, cap = 4 from slice indices [OK]

Hint: Capacity = original array length - slice start index [OK]

Common Mistakes:

• Using slice length as capacity
• Confusing slice end index with capacity
• Assuming capacity equals original array length

5. You have a slice s := make([]int, 3, 5). You append two elements to it. What will be the length and capacity of s after these appends?

hard

A. Length 5, Capacity 5

B. Length 5, Capacity 10

C. Length 3, Capacity 5

D. Length 5, Capacity 6

Solution

1. Step 1: Understand initial slice size

   Slice s starts with length 3 and capacity 5.

2. Step 2: Append two elements within capacity

   Appending two elements increases length to 5, capacity remains 5 because it is not exceeded.

3. Final Answer:

   Length 5, Capacity 5 -> Option A

4. Quick Check:

   Appending within capacity keeps capacity same [OK]

Hint: Capacity grows only when length exceeds capacity [OK]

Common Mistakes:

• Assuming capacity doubles immediately after append
• Confusing length with capacity after append
• Thinking capacity increases by 1 per append