Why slices are used in Go - Visual Breakdown

Concept Flow - Why slices are used

Start with array

↓

Create slice pointing to array

↓

Use slice to access/modify elements

↓

Slice can grow or shrink logically

↓

Efficient memory use and flexibility

↓

End

Slices let you work with parts of arrays flexibly and efficiently without copying data.

Execution Sample

Go

package main

import "fmt"

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

This code creates an array and a slice from it, modifies the slice, and shows how the array changes too.

Execution Table

Step	Action	Array arr	Slice slice	Output
1	Create array arr	[10 20 30 40 50]	N/A	N/A
2	Create slice slice = arr[1:4]	[10 20 30 40 50]	[20 30 40]	N/A
3	Modify slice[0] = 25	[10 25 30 40 50]	[25 30 40]	N/A
4	Print arr	[10 25 30 40 50]	[25 30 40]	[10 25 30 40 50]
5	Print slice	[10 25 30 40 50]	[25 30 40]	[25 30 40]

💡 All steps complete; slice changes reflect in original array because slice points to array data.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
arr	[10 20 30 40 50]	[10 20 30 40 50]	[10 25 30 40 50]	[10 25 30 40 50]
slice	N/A	[20 30 40]	[25 30 40]	[25 30 40]

Key Moments - 2 Insights

Why does changing slice[0] also change arr[1]?

Because the slice points to the same underlying array data, so modifying the slice changes the array too, as shown in step 3 of the execution_table.

Why use slices instead of arrays directly?

Slices let you work with parts of arrays without copying data and can grow or shrink logically, making code more flexible and memory efficient, as the concept_flow shows.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of arr after modifying slice[0]?

A [25 30 40 40 50]

B [10 20 30 40 50]

C [10 25 30 40 50]

D [25 20 30 40 50]

💡 Hint

Check the 'Array arr' column at step 3 in the execution_table.

At which step does the slice get created from the array?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column in the execution_table to find when slice is assigned.

If we changed slice[1] instead of slice[0], which array element would change?

A arr[2]

B arr[0]

C arr[1]

D arr[3]

💡 Hint

Recall slice = arr[1:4], so slice[1] corresponds to arr[2].

Concept Snapshot

Slices in Go:
- Slices point to arrays, no data copy
- Syntax: slice := arr[start:end]
- Modifying slice changes array
- Slices can grow/shrink logically
- Efficient and flexible for data handling

Full Transcript

This visual trace shows why slices are used in Go. We start with an array of 5 integers. Then we create a slice that points to a part of this array. When we change an element in the slice, the original array changes too because the slice shares the same data. This makes slices efficient and flexible, letting us work with parts of arrays without copying. The execution table walks through each step, showing how variables change and what outputs are printed. Key moments clarify why slice changes affect the array and why slices are preferred over arrays for flexible data handling.