Slice creation in Go

Introduction

Slices let you work with lists of items that can grow or shrink. They are easy to use and flexible.

When you want to store a list of names that can change size.

When you need to collect user inputs one by one.

When you want to pass a group of numbers to a function.

When you want to create a dynamic list instead of a fixed array.

When you want to easily add or remove items from a list.

Syntax

Go

var s []Type
s := []Type{value1, value2, value3}
s := make([]Type, length, capacity)

Type is the kind of data you want to store, like int or string.

make creates a slice with a set length and optional capacity.

Examples

This creates an empty slice of integers. It has no items yet.

Go

var numbers []int

This creates a slice with three fruit names already inside.

Go

fruits := []string{"apple", "banana", "cherry"}

This creates a slice of strings with length 3, all empty strings initially.

Go

letters := make([]string, 3)

This creates a slice of integers with length 2 and capacity 5, meaning it can grow up to 5 items without needing new memory.

Go

data := make([]int, 2, 5)

Sample Program

This program shows different ways to create slices and how to add items to an empty slice.

Go

package main

import "fmt"

func main() {
    // Create an empty slice of strings
    var colors []string
    fmt.Println("Empty slice:", colors)

    // Create a slice with initial values
    fruits := []string{"apple", "banana", "cherry"}
    fmt.Println("Fruits slice:", fruits)

    // Create a slice with make
    numbers := make([]int, 3)
    fmt.Println("Numbers slice with length 3:", numbers)

    // Add items to the empty slice
    colors = append(colors, "red", "green")
    fmt.Println("Colors after append:", colors)
}

Important Notes

Slices are like windows to arrays; they point to underlying data.

Appending to a slice may create a new underlying array if capacity is exceeded.

Zero value of a slice is nil, which behaves like an empty slice.

Summary

Slices hold lists of items that can change size.

You can create slices empty, with values, or with make.

Use append to add items to slices.

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