Slice creation in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a slice in Go?

A slice is a flexible and dynamic view into the elements of an array. It allows you to work with sequences of elements without fixed size.

beginner

How do you create a slice with predefined elements in Go?

You can create a slice by listing elements inside square brackets without specifying size, like: slice := []int{1, 2, 3}.

intermediate

What does the built-in function make do when creating a slice?

make creates a slice with a specified length and capacity, for example: make([]int, 3, 5) creates a slice of length 3 and capacity 5.

intermediate

What is the difference between length and capacity of a slice?

Length is the number of elements the slice currently holds. Capacity is the total number of elements the slice can hold before needing to grow.

beginner

How do you create an empty slice in Go?

You can create an empty slice by declaring it without elements: var s []int or with make([]int, 0).

Which of the following creates a slice with 5 integers initialized to zero?

A make([]int, 5)

B []int{5}

C make([]int, 0, 5)

D var s [5]int

make([]int, 5) creates a slice of length 5 with zero values. Option B creates a slice with one element '5'. Option C creates a slice of length 0 but capacity 5. Option D creates an array, not a slice.

What is the length of the slice created by make([]string, 3, 10)?

A 3

B 10

C 0

D 13

The first number is the length, so the slice length is 3.

How do you declare a slice with elements 10, 20, and 30?

A slice := [3]int{10, 20, 30}

B slice := []int{10, 20, 30}

C slice := make([]int, 3)

D slice := []int(10, 20, 30)

Option B correctly creates a slice with those elements. Option C creates a slice of length 3 but with zero values. Option A creates an array, not a slice. Option D is invalid syntax.

What happens if you append an element to a slice that has reached its capacity?

A The element is ignored.

B The program crashes.

C The slice automatically grows to accommodate the new element.

D You must manually increase the capacity before appending.

Go automatically allocates a new underlying array with more capacity and copies elements when needed.

Which of these is NOT a valid way to create an empty slice?

A var s []int

B s := []int{}

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

D s := make([]int, 5)

Option D creates a slice of length 5, not empty. The others create empty slices.

Explain how to create a slice in Go with a specific length and capacity using the make function.

Think about the parameters make takes for slices.

Describe the difference between a slice's length and capacity and why it matters.

Consider what happens when you add elements beyond the current capacity.

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