Slicing operations in Go

Introduction

Slicing lets you take a part of a list or array to work with just that piece. It helps you focus on smaller parts without changing the original whole.

You want to get the first few items from a list, like the first 3 names in a list of friends.

You need to skip some items at the start and work with the rest, like ignoring the first 2 days of data.

You want to get a middle section of a list, like days 3 to 5 from a week's data.

You want to copy part of a list to a new list to change it without touching the original.

You want to check or print only a part of a list for easier reading.

Syntax

Go

slice[low:high]
slice[low:]
slice[:high]
slice[:]

low is the start index (included), high is the end index (excluded).

If low is missing, it starts from 0; if high is missing, it goes to the end.

Examples

Gets items from index 1 up to but not including 4 (20, 30, 40).

Go

numbers := []int{10, 20, 30, 40, 50}
part := numbers[1:4]
fmt.Println(part)

Gets items from index 2 to the end ("c", "d").

Go

letters := []string{"a", "b", "c", "d"}
start := letters[2:]
fmt.Println(start)

Gets items from start up to but not including index 2 ("x", "y").

Go

chars := []string{"x", "y", "z"}
end := chars[:2]
fmt.Println(end)

Gets all items, a copy of the whole slice.

Go

all := chars[:]
fmt.Println(all)

Sample Program

This program shows different ways to slice a list of fruits. It prints the first two, a middle part, the last part, and the whole list.

Go

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry", "date", "fig"}

    firstTwo := fruits[:2]
    middle := fruits[1:4]
    last := fruits[3:]
    all := fruits[:]

    fmt.Println("First two fruits:", firstTwo)
    fmt.Println("Middle fruits:", middle)
    fmt.Println("Last fruits:", last)
    fmt.Println("All fruits:", all)
}

Important Notes

Slicing does not copy the data; it creates a view on the original array.

Changing a slice changes the original array if they share the same underlying data.

Be careful with slice bounds to avoid runtime errors (index out of range).

Summary

Slicing extracts parts of a list using start and end indexes.

Start index is included; end index is excluded.

You can omit start or end to slice from the beginning or to the end.

Practice

1. In Go, what does the slice expression arr[2:5] do?

easy

A. Extracts elements from index 2 up to and including index 5

B. Extracts elements from index 2 up to but not including index 5

C. Extracts elements from index 3 to 5

D. Extracts elements from index 0 to 5

Solution

1. Step 1: Understand slice indexing in Go

   Go slices include the start index but exclude the end index.

2. Step 2: Apply to arr[2:5]

   This means elements at indexes 2, 3, and 4 are included, but not index 5.

3. Final Answer:

   Extracts elements from index 2 up to but not including index 5 -> Option B

4. Quick Check:

   Slice = arr[2:5] includes indexes 2,3,4 [OK]

Hint: Remember: start included, end excluded in slices [OK]

Common Mistakes:

• Including the end index element
• Confusing start and end indexes
• Thinking slice includes elements before start

2. Which of the following is the correct syntax to slice a Go slice arr from the beginning up to index 4 (excluding 4), omitting the start index?

easy

A. arr[:4]

B. arr[0:4]

C. arr[1:4]

D. arr[4:]

Solution

1. Step 1: Recall slice syntax for start omitted

   Omitting the start index means slicing from the beginning (index 0).

2. Step 2: Check the options

   arr[:4] omits the start index (defaults to 0), slicing up to but excluding index 4. arr[0:4] explicitly includes the start index.

3. Final Answer:

   arr[:4] -> Option A

4. Quick Check:

   Start omitted means from 0 [OK]

Hint: Omit start to slice from beginning: arr[:end] [OK]

Common Mistakes:

• Using arr[1:4] which skips the first element
• Using arr[4:] which slices from index 4 to end
• Confusing start and end indexes

3. What is the output of the following Go code?

arr := []int{10, 20, 30, 40, 50}
slice := arr[1:4]
fmt.Println(slice)

medium

A. [20 30 40 50]

B. [10 20 30 40]

C. [30 40 50]

D. [20 30 40]

Solution

1. Step 1: Identify slice indexes

   The slice arr[1:4] includes elements at indexes 1, 2, and 3.

2. Step 2: Extract elements from arr

   arr[1] = 20, arr[2] = 30, arr[3] = 40, so the slice is [20 30 40].

3. Final Answer:

   [20 30 40] -> Option D

4. Quick Check:

   Slice arr[1:4] = [20 30 40] [OK]

Hint: Slice excludes end index, so last element is arr[3] here [OK]

Common Mistakes:

• Including arr[4] which is 50
• Starting slice at index 0 instead of 1
• Printing the whole array instead of slice

4. Consider this Go code snippet:

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

What is the issue here?

medium

A. The slice will be empty but no error occurs

B. The slice syntax is invalid and causes a compile error

C. The start index is greater than the end index, causing a runtime panic

D. The slice will include elements from index 2 to 3

Solution

1. Step 1: Check slice indexes

   The slice arr[3:2] has start index 3 and end index 2.

2. Step 2: Understand Go slice rules

   In Go, the start index must be less than or equal to the end index; otherwise, it causes a runtime panic.

3. Final Answer:

   The start index is greater than the end index, causing a runtime panic -> Option C

4. Quick Check:

   Start > end in slice causes panic [OK]

Hint: Start index must not exceed end index in slices [OK]

Common Mistakes:

• Assuming slice is empty without error
• Thinking slice syntax is invalid at compile time
• Confusing start and end indexes

5. Given the slice nums := []int{5, 10, 15, 20, 25, 30}, which expression produces a new slice containing only the last three elements?

hard

A. nums[3:]

B. nums[:3]

C. nums[2:5]

D. nums[4:]

Solution

1. Step 1: Identify last three elements indexes

   The last three elements are at indexes 3, 4, and 5 (20, 25, 30).

2. Step 2: Use slice syntax to get from index 3 to end

   Using nums[3:] slices from index 3 to the end, giving [20 25 30].

3. Final Answer:

   nums[3:] -> Option A

4. Quick Check:

   nums[3:] = last three elements [OK]

Hint: Use nums[start:] to slice from start index to end [OK]

Common Mistakes:

• Using nums[:3] which gives first three elements
• Using nums[2:5] which excludes last element
• Using nums[4:] which gives only last two elements