7. Slice of Slices

Slices can hold other slices, effectively creating a matrix, or a 2D slice.

rows := [][]int{}
rows = append(rows, []int{1, 2, 3})
rows = append(rows, []int{4, 5, 6})
fmt.Println(rows)
// [[1 2 3] [4 5 6]]

Assignment

We support various visualization dashboards on Textio that display message analytics to our users. The UI for our graphs and charts is built on top of a grid system. Let's build some grid logic.

Complete the createMatrix function. It takes a number of rows and columns and returns a 2D slice of integers. The value of each cell is i * j where i and j are the indexes of the row and column respectively. Basically, we're building a multiplication chart.

For example, a 5x10 matrix, produced from calling createMatrix(5, 10), would look like this:

[0  0  0  0  0  0  0  0  0  0]
[0  1  2  3  4  5  6  7  8  9]
[0  2  4  6  8 10 12 14 16 18]
[0  3  6  9 12 15 18 21 24 27]
[0  4  8 12 16 20 24 28 32 36]

Solution

Concept

A slice of slices is Go's way of creating a 2D array or matrix. It's a slice where each element is itself another slice.

[][]int  // Type: slice of slices of integers

Visual Structure

Think of it like a table or spreadsheet:

         Col 0  Col 1  Col 2  Col 3
Row 0  [   0      0      0      0  ]
Row 1  [   0      1      2      3  ]
Row 2  [   0      2      4      6  ]

Creating a 2D Slice

Basic Syntax

// Method 1: Literal declaration
matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}

// Method 2: Start empty and build
matrix := [][]int{}
matrix = append(matrix, []int{1, 2, 3})  // Add first row
matrix = append(matrix, []int{4, 5, 6})  // Add second row

Building a Matrix with Loops

The key pattern is build from inside out:

1

Create the outer matrix container

Start with an empty outer slice that will hold rows.

matrix := [][]int{}

2

Loop through rows

Iterate from 0 to rows-1. Each iteration handles one row.

for i := 0; i < rows; i++ {
    // ...
}

3

For each row, create a new slice

Create an empty slice to hold the columns for the current row.

row := []int{}

4

Loop through columns to fill that row

Iterate columns and append computed values to the current row.

for j := 0; j < cols; j++ {
    row = append(row, i*j)
}

5

Append the completed row to the matrix

After filling the row, append it to the outer matrix.

matrix = append(matrix, row)

6

Return the matrix

Once all rows are processed, return the result.

return matrix

Example: Multiplication Table

func createMatrix(rows, cols int) [][]int {
    // Step 1: Create empty matrix to hold all rows
    matrix := [][]int{}
    
    // Step 2: Loop through each row (i = row index)
    for i := 0; i < rows; i++ {
        // Step 3: Create a new empty row
        row := []int{}
        
        // Step 4: Loop through columns (j = column index)
        for j := 0; j < cols; j++ {
            // Step 5: Calculate value and add to current row
            row = append(row, i*j)
        }
        
        // Step 6: Append completed row to matrix
        matrix = append(matrix, row)
    }
    
    // Step 7: Return the finished matrix
    return matrix
}

Output for createMatrix(3, 4):

[0 0 0 0]    // i=0: 0*0, 0*1, 0*2, 0*3
[0 1 2 3]    // i=1: 1*0, 1*1, 1*2, 1*3
[0 2 4 6]    // i=2: 2*0, 2*1, 2*2, 2*3

Key Pattern: Two-Phase Append

This is the most important concept:

for i := 0; i < rows; i++ {
    row := []int{}                    // 1. Create new row
    for j := 0; j < cols; j++ {
        row = append(row, value)      // 2. Append TO ROW
    }
    matrix = append(matrix, row)      // 3. Append row TO MATRIX
}

Common mistake:

// ❌ Wrong: trying to append directly to matrix at specific position
matrix = append(matrix[i][j], value)

// ✓ Correct: append to row, then append row to matrix
row = append(row, value)
matrix = append(matrix, row)

Accessing Elements

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
}

// Syntax: matrix[row][column]
value := matrix[0][0]  // 1 (first row, first column)
value := matrix[1][2]  // 6 (second row, third column)

Iterating Through a 2D Slice

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}

// Using range
for i, row := range matrix {
    for j, value := range row {
        fmt.Printf("matrix[%d][%d] = %d\n", i, j, value)
    }
}

// Output:
// matrix[0][0] = 1
// matrix[0][1] = 2
// matrix[0][2] = 3
// matrix[1][0] = 4
// ...

Loop Types in Go

Standard For Loop (Counting)

Use when you need the index and know the range:

for i := 0; i < rows; i++ {
    // i is 0, 1, 2, ..., rows-1
}

Range Loop

Use when iterating over a slice:

for i, value := range slice {
    // i = index, value = element
}

for _, value := range slice {
    // Ignore index with underscore
}

Important: You cannot use range with a number like range rows. Range only works with slices, arrays, maps, strings, or channels.

Mental Model: Packing Boxes

Think of building a 2D slice like packing boxes on shelves:

1

Get a box

Create an empty row:

row := []int{}

2

Fill the box

Append items to the row:

row = append(row, value)

3

Put box on shelf

Append the completed row to the matrix:

matrix = append(matrix, row)

4

Repeat

Repeat for each row.

You must complete one box before putting it on the shelf. You can't put individual items directly on the shelf without a box!

Common Use Cases

• Grids and game boards

• Tables and spreadsheets

• Matrices for mathematical operations

• Pixel data for images

• Graphs and charts data structures

Performance Note

If you know the size ahead of time, you can pre-allocate for better performance:

func createMatrixOptimized(rows, cols int) [][]int {
    matrix := make([][]int, rows)      // Pre-allocate rows
    for i := 0; i < rows; i++ {
        matrix[i] = make([]int, cols)  // Pre-allocate each row
        for j := 0; j < cols; j++ {
            matrix[i][j] = i * j       // Direct assignment
        }
    }
    return matrix
}

This avoids multiple append operations and slice reallocations.