Slice creation in Go - Step-by-Step Execution

Concept Flow - Slice creation

Declare slice variable

↓

Allocate underlying array

↓

Set slice length and capacity

↓

Slice ready to use

↓

Access or modify elements

Creating a slice involves declaring it, allocating an underlying array, setting its length and capacity, then using it to access or modify elements.

Execution Sample

Go

package main
import "fmt"
func main() {
  s := make([]int, 3, 5)
  fmt.Println(s)
}

This code creates a slice of integers with length 3 and capacity 5, then prints it.

Execution Table

Step	Action	Slice Length	Slice Capacity	Underlying Array Size	Output
1	Declare slice variable s	0	0	0
2	Call make([]int, 3, 5)	3	5	5
3	Slice s created with length 3, capacity 5	3	5	5
4	Print slice s	3	5	5	[0 0 0]

💡 Slice s is created with length 3 and capacity 5; printing shows default zero values.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
s	nil	slice with len=3 cap=5	slice with len=3 cap=5	slice with len=3 cap=5

Key Moments - 2 Insights

Why does the slice print show three zeros instead of five?

Because the slice length is 3, only the first 3 elements are accessible and printed, even though capacity is 5 (see execution_table step 4).

What is the difference between slice length and capacity?

Length is how many elements the slice currently holds (step 3), capacity is the total space allocated in the underlying array (step 2).

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the capacity of slice s?

A 0

B 3

C 5

D nil

💡 Hint

Check the 'Slice Capacity' column at step 2 in execution_table.

At which step does the slice s get its length set to 3?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Slice Length' column in execution_table to see when length changes from 0 to 3.

If we change make([]int, 3, 5) to make([]int, 5, 5), what will be the output at step 4?

A [0 0 0]

B [0 0 0 0 0]

C []

D nil

💡 Hint

The output shows elements equal to the slice length; see how length affects output in execution_table step 4.

Concept Snapshot

Slice creation in Go:
- Use make([]Type, length, capacity)
- Length = accessible elements
- Capacity = underlying array size
- Default values are zero
- Printing shows elements up to length

Full Transcript

In Go, creating a slice involves declaring a slice variable and using the make function to allocate an underlying array with a specified length and capacity. The length determines how many elements are accessible and printed, while the capacity is the total allocated space. For example, make([]int, 3, 5) creates a slice with length 3 and capacity 5. When printed, only the first 3 elements show, initialized to zero. Understanding the difference between length and capacity helps manage slices effectively.

Practice

1. What is a slice in Go programming?

easy

A. A flexible, dynamically-sized list of elements.

B. A fixed-size array that cannot change length.

C. A function that slices strings.

D. A type of map with keys and values.

Solution

1. Step 1: Understand slice definition

   A slice in Go is a data structure that holds a list of elements and can grow or shrink in size.

2. Step 2: Compare with other types

   Unlike arrays, slices are dynamic and flexible, unlike maps or functions.

3. Final Answer:

   A flexible, dynamically-sized list of elements. -> Option A

4. Quick Check:

   Slice = dynamic list [OK]

Hint: Remember: slices can grow, arrays cannot [OK]

Common Mistakes:

• Confusing slices with fixed-size arrays
• Thinking slices are functions
• Mixing slices with maps

2. Which of the following is the correct way to create an empty slice of integers in Go?

easy

A. var s []int

B. s := []int{}

C. s := make([]int, 0)

D. All of the above

Solution

1. Step 1: Review slice creation methods

   In Go, you can create an empty slice by declaring a nil slice, using a slice literal with no elements, or using make with length zero.

2. Step 2: Confirm all options are valid

   All three options create an empty slice of integers correctly.

3. Final Answer:

   All of the above -> Option D

4. Quick Check:

   Empty slice creation = D [OK]

Hint: Empty slices can be made in multiple valid ways [OK]

Common Mistakes:

• Using make with negative length
• Confusing array and slice syntax
• Forgetting to initialize slice before use

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

package main
import "fmt"
func main() {
  s := []int{1, 2, 3}
  s = append(s, 4)
  fmt.Println(s)
}

medium

A. [1 2 3]

B. [1 2 3 4]

C. [4]

D. Compilation error

Solution

1. Step 1: Understand initial slice and append

   The slice s starts with elements 1, 2, 3. The append function adds 4 to the end.

2. Step 2: Print the updated slice

   After append, s contains [1 2 3 4], which is printed.

3. Final Answer:

   [1 2 3 4] -> Option B

4. Quick Check:

   append adds element to slice [OK]

Hint: append adds elements to the end of a slice [OK]

Common Mistakes:

• Expecting append to replace elements
• Thinking append returns a new slice without assignment
• Confusing slice with array syntax

4. Identify the error in this Go code snippet:

package main
func main() {
  s := make([]int, 3)
  s[3] = 10
}

medium

A. Slice s is nil

B. Syntax error in make function

C. Index out of range error at s[3]

D. No error, code runs fine

Solution

1. Step 1: Analyze slice length and indexing

   make([]int, 3) creates a slice with length 3, valid indices are 0, 1, 2.

2. Step 2: Check index used in assignment

   Accessing s[3] is out of range and causes a runtime panic.

3. Final Answer:

   Index out of range error at s[3] -> Option C

4. Quick Check:

   Slice indices start at 0, max index = length-1 [OK]

Hint: Slice indices go from 0 to length-1 only [OK]

Common Mistakes:

• Using index equal to slice length
• Confusing slice length and capacity
• Assuming make creates larger slice than specified

5. Given the code below, what will be the length and capacity of slice s after execution?

package main
import "fmt"
func main() {
  s := make([]int, 2, 5)
  s = append(s, 3, 4, 5)
  fmt.Println(len(s), cap(s))
}

hard

A. 5 5

B. 5 10

C. 7 10

D. 3 5

Solution

1. Step 1: Understand make parameters

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

2. Step 2: Append three elements

   Appending 3 elements increases length from 2 to 5, capacity remains 5 as it is enough.

3. Final Answer:

   5 5 -> Option A

4. Quick Check:

   Length grows with append, capacity stays if enough [OK]

Hint: Capacity grows only if append exceeds current capacity [OK]

Common Mistakes:

• Assuming capacity doubles automatically
• Confusing length and capacity
• Forgetting append increases length