Slicing operations in Go - Step-by-Step Execution

Concept Flow - Slicing operations

Start with an array or slice

↓

Specify slice indices: low:high

↓

Check indices within bounds

Yes↓

Create new slice from original

↓

Use or print the new slice

↓

End

Slicing in Go extracts a portion of an array or slice by specifying start and end indices, creating a new slice referencing the original data.

Execution Sample

Go

package main

import "fmt"

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

Creates a slice from index 1 to 3 of the array and prints it.

Execution Table

Step	Action	Indices	Resulting Slice	Explanation
1	Define array	-	[10 20 30 40 50]	Original array with 5 elements
2	Slice operation	1:4	[20 30 40]	Slice includes elements at indices 1,2,3
3	Print slice	-	[20 30 40]	Output the new slice
4	End	-	-	Slicing complete

💡 Slicing stops after creating and printing the new slice.

Variable Tracker

Variable	Start	After Step 2	Final
arr	[10 20 30 40 50]	[10 20 30 40 50]	[10 20 30 40 50]
slice	nil	[20 30 40]	[20 30 40]

Key Moments - 2 Insights

Why does the slice arr[1:4] include elements at indices 1, 2, and 3 but not 4?

In Go slicing, the start index is inclusive and the end index is exclusive. So arr[1:4] includes elements from index 1 up to but not including index 4, as shown in execution_table row 2.

Does slicing create a new copy of the array elements?

No, slicing creates a new slice header that references the original array's underlying data. Changes to the slice affect the original array, as the slice shares the same data, explained in the concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what elements does the slice contain?

A [20 30 40]

B [30 40 50]

C [10 20 30]

D [10 20 30 40]

💡 Hint

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

At which step is the slice variable assigned a value?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'Variable' changes in variable_tracker after step 2.

If we change the slice indices to arr[2:5], what would the resulting slice be?

A [20 30 40]

B [30 40 50]

C [10 20 30]

D [40 50]

💡 Hint

Recall slicing includes start index but excludes end index; check original array values in variable_tracker.

Concept Snapshot

Go slicing syntax: slice := array[low:high]
Includes elements from low (inclusive) to high (exclusive).
Creates a new slice referencing original data.
Indices must be within array bounds.
Useful for extracting parts of arrays or slices.

Full Transcript

This visual execution trace shows how slicing works in Go. We start with an array of integers. Then we create a slice using arr[1:4], which includes elements at indices 1, 2, and 3. The slice does not include the element at index 4 because the end index is exclusive. The slice variable now references this part of the array. When we print the slice, it outputs [20 30 40]. The original array remains unchanged, but the slice shares the same underlying data. This means changes to the slice affect the original array. The trace also clarifies common confusions about inclusive and exclusive indices and the fact that slicing does not copy data but creates a new view. The quiz questions help reinforce understanding by asking about slice contents and variable assignments.

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