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.

Practice

1.

Why are slices preferred over arrays in Go?

easy

A. Because arrays cannot store multiple values

B. Because slices use less memory than arrays

C. Because slices can change size dynamically while arrays have fixed size

D. Because slices are slower but more secure

Solution

1. Step 1: Understand array size behavior

   Arrays in Go have a fixed size defined at creation and cannot grow or shrink.

2. Step 2: Understand slice flexibility

   Slices are built on arrays but can dynamically change size, making them more flexible for varying data.

3. Final Answer:

   Because slices can change size dynamically while arrays have fixed size -> Option C

4. Quick Check:

   Slice size flexibility = A [OK]

Hint: Remember: slices grow, arrays don't [OK]

Common Mistakes:

• Thinking arrays can resize dynamically
• Confusing memory usage between slices and arrays
• Believing slices are slower than arrays

2.

Which of the following is the correct way to declare a slice of integers in Go?

var s _____

easy

A. []int

B. [5]int

C. int[]

D. slice int

Solution

1. Step 1: Recall slice syntax

   In Go, slices are declared with square brackets and no size: []type.

2. Step 2: Identify correct option

   []int uses []int which is the correct syntax for a slice of integers.

3. Final Answer:

   []int -> Option A

4. Quick Check:

   Slice declaration = []int [OK]

Hint: Slices use []type without size [OK]

Common Mistakes:

• Using fixed size like [5]int for slices
• Writing type after brackets like int[]
• Using invalid keywords like 'slice int'

3.

What will be the output of this Go code?

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

medium

A. [1 2 4]

B. [1 2 3 4]

C. [1 2 3]

D. Runtime error

Solution

1. Step 1: Understand slice and array relation

   The slice references the first two elements of arr: [1, 2], with length 2 and capacity 3.

2. Step 2: Append behavior on slice

   Appending 4 to slice: since current length 2 < capacity 3, it appends in place to the underlying array, setting arr[2] = 4. Thus, arr becomes [1 2 4].

3. Final Answer:

   [1 2 4] -> Option A

4. Quick Check:

   Append within capacity modifies underlying array = B [OK]

Hint: Append within capacity modifies shared array [OK]

Common Mistakes:

• Thinking append always reallocates a new array
• Expecting arr to grow to 4 elements
• Thinking append causes runtime error

4.

Identify the error in this Go code snippet:

var s []int
s[0] = 10
fmt.Println(s)

medium

A. Syntax error: slice declaration is incorrect

B. Slice s is nil and has no elements, so s[0] assignment causes runtime panic

C. No error, code prints [10]

D. Compile error: cannot assign to slice element

Solution

1. Step 1: Check slice initialization

   Variable s is declared but not initialized; it is nil with length 0.

2. Step 2: Understand assignment to s[0]

   Assigning to s[0] causes runtime panic because no elements exist yet.

3. Final Answer:

   Slice s is nil and has no elements, so s[0] assignment causes runtime panic -> Option B

4. Quick Check:

   Assigning to nil slice index = runtime panic [OK]

Hint: Initialize slice before assigning elements [OK]

Common Mistakes:

• Assuming slice auto-expands on index assignment
• Thinking code compiles with no error
• Confusing compile error with runtime panic

5.

You want to collect an unknown number of user scores efficiently. Which approach best uses slices?

1. Use a fixed-size array
2. Use a slice and append scores as they come
3. Use a map with indexes
4. Use a string to store scores

hard

A. Use a fixed-size array

B. Use a string to store scores

C. Use a map with indexes

D. Use a slice and append scores as they come

Solution

1. Step 1: Consider data size flexibility

   User scores count is unknown, so fixed-size array is not suitable.

2. Step 2: Evaluate slice usage

   Slices can grow dynamically and efficiently handle unknown data sizes by appending.

3. Step 3: Exclude other options

   Maps add overhead and strings are not suitable for numeric data storage.

4. Final Answer:

   Use a slice and append scores as they come -> Option D

5. Quick Check:

   Dynamic data collection = slice append [OK]

Hint: Use slices to grow lists dynamically [OK]

Common Mistakes:

• Choosing fixed arrays for unknown sizes
• Using strings for numeric data
• Overcomplicating with maps when slices suffice