Arrays

Arrays are the fixed-size foundation that slices (your next lesson) are built on. You'll learn to declare them, index them, and — crucially — understand that Go arrays are values : copying or passing one copies every element. That single fact explains a lot of Go behaviour.

Learn Arrays in our free Go course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick recall.

Part of the free Go course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

1️⃣ Declaring & Indexing

An array's length is part of its type : [5]int and [3]int are different types that can't be mixed. Declared without values, every element starts at the element type's zero value. You index with square brackets, starting at 0 , and len() tells you the length (which never changes).

2️⃣ The [...] Form & Iterating

Typing the count by hand is error-prone, so Go lets you write [...] and it counts the literal for you. You can also set elements by index inside a literal (handy for sparse data), and you iterate exactly like any collection — with range .

3️⃣ Arrays Are Values

This is the single most important thing about Go arrays. Assigning an array to another variable, or passing it to a function, copies every element . The original is untouched by changes to the copy. (Slices, next lesson, behave differently — they share underlying storage.) Because they're plain values, two arrays of the same type can be compared with == .

Your turn — declare a three-string array and fill the podium.

These lines declare an array and set three slots, but they're scrambled. Put them in order so the program prints [10 50 99] (assume a func main wraps them).

Why: the array must exist ( var a [3]int ) before any index can be assigned. The three assignments fill positions 0, 1 and 2 — they can be in any order among themselves, but all must precede the Println . The result is [10 50 99] .

Predict the output before you reveal the answer.

[0 0 0] — a fresh array fills with the element type's zero value, which is 0 for int.

{'a := [2]int ; b := a; b[0] = 9; fmt.Println(a[0])'}

1 — b := a copies the whole array, so changing b[0] leaves a untouched.

3 — [...] tells Go to count the three literal elements, so the length is 3.

Slices, almost always — they're flexible and resizable. Use a true array only when the length is genuinely fixed and known at compile time, or when you need value semantics and comparability.

Arrays are copied when passed, so the function edited a copy. Pass a slice of the array ( arr[:] ) or a pointer ( *[N]T ) to mutate the original.

No — an array's length is fixed forever. If you need to add elements, that's exactly what a slice is for (next lesson).

Loop through the readings and track the largest value you've seen. Start max at the first element. Write it yourself and match the example output.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary