Go Academy · Lesson

Arrays: Fixed-Length Collections

Array literals, indexing, and length

Arrays: Fixed-Length Collections is a free Go Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Go Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What Is an Array?

An array in Go is a fixed-length sequence of elements of the same type. The length is part of the type: [3]int and [4]int are different types.

Arrays are value types — assigning copies the entire array
Length is always known at compile time
Rarely used directly; slices are preferred for most tasks

Array Literals

Declare and initialize arrays with a literal:

package main

func main() {
    primes := [5]int{2, 3, 5, 7, 11}
    names  := [3]string{"Alice", "Bob", "Carol"}
    flags  := [4]bool{true, false, true, false}
    _ = primes; _ = names; _ = flags
}

Array Length and Indexing

Use len() for the length and zero-based indexing to read/write elements:

package main
import "fmt"

func main() {
    scores := [3]int{90, 85, 92}
    fmt.Println(len(scores)) // 3
    fmt.Println(scores[0])   // 90
    scores[1] = 100
    fmt.Println(scores)      // [90 100 92]
}

Ellipsis in Array Literals

Use [...] to let the compiler count the elements for you:

package main
import "fmt"

func main() {
    days := [...]string{"Mon","Tue","Wed","Thu","Fri"}
    fmt.Println(len(days)) // 5
}

Arrays Are Value Types

When you assign or pass an array, Go copies the whole thing. Modifying the copy does not affect the original:

package main
import "fmt"

func main() {
    a := [3]int{1, 2, 3}
    b := a     // full copy
    b[0] = 99
    fmt.Println(a) // [1 2 3] — unchanged
    fmt.Println(b) // [99 2 3]
}

Comparing Arrays

Arrays of the same type and length can be compared with == and !=:

package main
import "fmt"

func main() {
    x := [3]int{1, 2, 3}
    y := [3]int{1, 2, 3}
    z := [3]int{1, 2, 4}
    fmt.Println(x == y) // true
    fmt.Println(x == z) // false
}

2D Arrays

Arrays can be nested to form grids or matrices:

package main
import "fmt"

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

Iterating an Array

Use a classic for loop or range to iterate:

package main
import "fmt"

func main() {
    nums := [4]int{10, 20, 30, 40}
    for i, v := range nums {
        fmt.Printf("[%d] = %d\n", i, v)
    }
}

Arrays vs Slices

The key differences:

Array: fixed size, value type, size is part of type
Slice: dynamic size, reference type, backed by an array
In practice, use slices unless you need a fixed compile-time size (e.g., SHA-256 hash [32]byte)

Common Pitfalls

Watch out for:

Index out of range — Go panics at runtime if i >= len(arr)
Passing large arrays to functions causes expensive copies — use pointers or slices instead
Forgetting that [3]int and [4]int are incompatible types

Quick Check

What is the length of [...]string{"a","b","c"}?

Recap: Arrays

Key takeaways:

Arrays have a fixed, compile-time length that is part of the type
They are value types — assignment copies all elements
Use len() and zero-based indexing
Prefer slices for most collection needs

Practice Prompt

Declare an array of 5 integers, assign the value 100 to the third element, then print the array using range.

Frequently asked questions

Is the “Arrays: Fixed-Length Collections” lesson free?

Yes — the full text of “Arrays: Fixed-Length Collections” is free to read here on the web, and the Go Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Go Academy course, upgrade to CoddyKit PRO.

What will I learn in “Arrays: Fixed-Length Collections”?

Array literals, indexing, and length You practise Go Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Go Academy?

No prior experience is required. Go Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Arrays: Fixed-Length Collections” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Go Academy lesson?

Yes. Every Go Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Go Academy