Common slice operations in Go

Introduction

Slices let you work with lists of items easily. Common slice operations help you add, remove, or change items in these lists.

You want to add a new item to a list of names.

You need to remove an item from a list of numbers.

You want to get a part of a list, like the first three items.

You want to find how many items are in a list.

You want to change an item in a list.

Syntax

Go

var s []Type

// Add item
s = append(s, item)

// Remove item at index i
s = append(s[:i], s[i+1:]...)

// Get slice from index start to end-1
sub := s[start:end]

// Length of slice
length := len(s)

append adds items to the end of a slice.

Removing an item uses append to join parts before and after the item.

Examples

Adds 4 to the end of the numbers slice.

Go

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

Removes the item at index 2 ("c") from letters.

Go

letters := []string{"a", "b", "c", "d"}
letters = append(letters[:2], letters[3:]...)

Gets a new slice with items from index 1 to 2 ("banana", "cherry").

Go

items := []string{"apple", "banana", "cherry", "date"}
sub := items[1:3]

Finds how many items are in the slice.

Go

count := len(items)

Sample Program

This program shows how to add, remove, slice, and count items in a slice of fruits.

Go

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry"}
    fmt.Println("Original slice:", fruits)

    // Add a fruit
    fruits = append(fruits, "date")
    fmt.Println("After append:", fruits)

    // Remove the second fruit (index 1)
    fruits = append(fruits[:1], fruits[2:]...)
    fmt.Println("After removal:", fruits)

    // Get a slice of first two fruits
    firstTwo := fruits[:2]
    fmt.Println("First two fruits:", firstTwo)

    // Length of slice
    fmt.Println("Number of fruits:", len(fruits))
}

Important Notes

Remember slices are like windows to arrays; changing a slice can affect the underlying array.

Use append carefully to avoid unexpected results when removing items.

Summary

Slices hold lists of items you can change easily.

Use append to add or remove items.

You can get parts of slices using slicing syntax [start:end].

Practice

1. What does the slice expression mySlice[2:5] do in Go?

easy

A. It returns a new slice containing elements from index 2 up to, but not including, index 5.

B. It returns elements from index 2 to index 5, including index 5.

C. It removes elements from index 2 to 5 from the original slice.

D. It appends elements from index 2 to 5 to the original slice.

Solution

1. Step 1: Understand slice syntax

   The slice expression mySlice[2:5] extracts elements starting at index 2 up to, but not including, index 5. Go slices use half-open intervals, so the element at index 5 is not included in the new slice.

2. Final Answer:

   It returns a new slice containing elements from index 2 up to, but not including, index 5. -> Option A

3. Quick Check:

   Slice[start:end] excludes end index [OK]

Hint: Remember slice end index is excluded in Go slices [OK]

Common Mistakes:

• Including the end index element in the slice
• Thinking slice removes elements from original
• Confusing append with slicing

2. Which of the following is the correct way to append an element 5 to a slice nums in Go?

easy

A. append(nums, 5)

B. nums += 5

C. nums.append(5)

D. nums = append(nums, 5)

Solution

1. Step 1: Recall append function usage

   In Go, append returns a new slice with the element added, so you must assign it back. nums = append(nums, 5) correctly assigns the result back to nums. append(nums, 5) ignores the returned slice. nums.append(5) uses invalid method syntax. nums += 5 is invalid for slices.

2. Final Answer:

   nums = append(nums, 5) -> Option D

3. Quick Check:

   append returns new slice, assign it [OK]

Hint: Always assign append result back to slice variable [OK]

Common Mistakes:

• Not assigning append result back
• Using method syntax like nums.append()
• Trying to add with += operator

3. What is the output of this Go code?

nums := []int{1, 2, 3, 4, 5}
slice := nums[1:4]
slice[0] = 10
fmt.Println(nums)

medium

A. [1 10 3 4 5]

B. [1 2 10 4 5]

C. [10 2 3 4 5]

D. [1 2 3 4 5]

Solution

1. Step 1: Understand slice referencing

   The slice slice := nums[1:4] references the original array elements at indexes 1, 2, and 3. Changing slice[0] to 10 changes nums[1] because slices share the underlying array. Output: [1 10 3 4 5]

2. Final Answer:

   [1 10 3 4 5] -> Option A

3. Quick Check:

   Slices share array, modifying slice changes original [OK]

Hint: Changing slice elements changes original array too [OK]

Common Mistakes:

• Thinking slice is a copy, not a reference
• Modifying wrong index in slice
• Confusing slice length with capacity

4. Identify the error in this Go code snippet:

nums := []int{1, 2, 3}
newSlice := nums[1:4]
fmt.Println(newSlice)

medium

A. Cannot print a slice directly with fmt.Println.

B. Syntax error in slice declaration.

C. Slicing beyond the slice length causes a runtime panic.

D. Missing import for fmt package.

Solution

1. Step 1: Check slice bounds

   The original slice nums has length 3, so valid indices are 0 to 2. Attempting nums[1:4] tries to access index 3 which is out of range, causing a runtime panic.

2. Final Answer:

   Slicing beyond the slice length causes a runtime panic. -> Option C

3. Quick Check:

   Slice end index must be ≤ length [OK]

Hint: Slice end index cannot exceed slice length [OK]

Common Mistakes:

• Assuming slice auto-expands
• Confusing compile error with runtime panic
• Ignoring slice length when slicing

5. Given a slice data := []int{2, 4, 6, 8, 10, 12}, how can you create a new slice containing only the even numbers greater than 6 using slicing and append?

hard

A. newSlice := data[2:5]

B. newSlice := append([]int{}, data[3:]...)

C. newSlice := append(data[:3], data[4:]...)

D. newSlice := data[3:len(data)]

Solution

1. Step 1: Identify elements > 6

   Elements greater than 6 are 8, 10, 12 at indexes 3, 4, 5. Using data[3:] gets these elements. To create a new slice (not referencing original), append to empty slice: newSlice := append([]int{}, data[3:]...).

2. Final Answer:

   newSlice := append([]int{}, data[3:]...) -> Option B

3. Quick Check:

   Slice and append to copy subset [OK]

Hint: Use append to copy slice subset safely [OK]

Common Mistakes:

• Using slice without append copies reference
• Incorrect slice indexes for desired elements
• Trying to remove elements by slicing incorrectly