Array length in Go - Deep Dive

Overview - Array length

What is it?

An array in Go is a fixed-size collection of elements of the same type. The array length is the number of elements it can hold, which is set when the array is created and cannot change. Knowing the length helps you understand how many items the array contains and how to safely access them.

Why it matters

Without knowing the length of an array, you risk accessing elements outside its bounds, causing errors or crashes. The fixed length ensures predictable memory use and performance. If arrays had no length, programs would be unstable and unreliable.

Where it fits

Before learning array length, you should understand what arrays are and how to declare them in Go. After mastering array length, you can learn about slices, which are more flexible and built on arrays but allow dynamic sizing.

Mental Model

Core Idea

The array length is the fixed number of elements an array can hold, known at compile time and unchangeable during runtime.

Think of it like...

Think of an array like an egg carton that holds exactly 12 eggs. The length is the number of egg slots in the carton, fixed and known before you put any eggs in.

Array: [ element0 | element1 | element2 | ... | elementN-1 ]
Length: N (fixed size, known upfront)

Build-Up - 6 Steps

1

Foundation

What is an array in Go

Concept: Introduce the basic idea of arrays as fixed-size collections.

In Go, an array holds a fixed number of elements of the same type. For example, var a [5]int creates an array of 5 integers. The number 5 is the length, meaning it can hold exactly 5 integers.

Result

You have a container that can store 5 integers, indexed from 0 to 4.

Understanding that arrays have a fixed size helps you avoid errors from trying to add more elements than the array can hold.

2

Foundation

How to get array length in Go

Concept: Learn the built-in way to find the length of an array.

Use the built-in len() function to get the length of an array. For example, len(a) returns 5 if a is [5]int. This works because the length is part of the array's type.

Result

len(a) returns the number 5, the fixed size of the array.

Knowing len() returns the array size lets you write loops and access elements safely without guessing the length.

3

Intermediate

Array length is part of the type

🤔Before reading on: do you think arrays with different lengths have the same type or different types? Commit to your answer.

Concept: In Go, the length of an array is part of its type, making arrays with different lengths different types.

For example, [3]int and [5]int are different types. You cannot assign one to the other without conversion. This is because the length is fixed and known at compile time, so it is embedded in the type.

Result

Trying to assign [3]int to [5]int causes a compile-time error.

Understanding that length is part of the type explains why arrays of different sizes are incompatible and helps prevent type errors.

4

Intermediate

Using length in loops safely

🤔Before reading on: do you think using a fixed number or len() is safer for looping over an array? Commit to your answer.

Concept: Use len() in loops to avoid hardcoding the array length and prevent out-of-bounds errors.

Instead of for i := 0; i < 5; i++ { ... }, use for i := 0; i < len(a); i++ { ... }. This way, if the array size changes in code, the loop still works correctly.

Result

Loops run exactly as many times as the array length, preventing errors.

Using len() makes your code more flexible and less error-prone when working with arrays.

5

Advanced

Array length vs slice length

🤔Before reading on: do you think array length and slice length behave the same way? Commit to your answer.

Concept: Arrays have fixed length, but slices are dynamic views over arrays with their own length and capacity.

An array's length is fixed at compile time. A slice points to an array segment and has a length that can change at runtime. len() works on both but means different things: fixed size for arrays, dynamic size for slices.

Result

len() on an array returns a constant; on a slice, it can vary during execution.

Knowing the difference helps you choose between arrays and slices and understand how len() behaves in each case.

6

Expert

Why array length is compile-time constant

🤔Before reading on: do you think Go stores array length at runtime or only at compile time? Commit to your answer.

Concept: Array length is part of the type and known at compile time for performance and safety reasons.

Because the length is fixed and part of the type, Go can allocate memory efficiently and check bounds at runtime. This design avoids runtime overhead and bugs from changing sizes.

Result

Arrays are fast and safe but inflexible, unlike slices which add runtime flexibility.

Understanding this design choice explains Go's balance between safety, performance, and flexibility.

Under the Hood

In Go, arrays are stored as contiguous blocks of memory with a fixed size determined at compile time. The length is encoded in the array's type, so the compiler knows exactly how much memory to allocate. The len() function retrieves this fixed size without runtime calculation. This allows the compiler to perform bounds checking on array accesses, preventing out-of-range errors before the program runs.

Why designed this way?

Go was designed for simplicity, safety, and performance. Making array length part of the type ensures fixed memory layout and efficient access. This avoids runtime overhead and bugs common in languages with dynamic arrays. Alternatives like dynamic arrays exist (slices), but arrays provide a predictable, low-level building block.

┌───────────────┐
│   Array Type  │
│ [5]int       │
└──────┬────────┘
       │ length = 5 (fixed)
       ▼
┌───────────────────────────┐
│ Contiguous memory block    │
│ [elem0][elem1][elem2][elem3][elem4] │
└───────────────────────────┘
len() returns 5 directly from type info

Myth Busters - 3 Common Misconceptions

Quick: Does len() on an array ever change during program execution? Commit to yes or no.

Common Belief: len() on an array can change if you add or remove elements.

Reality: len() on an array is fixed and cannot change because arrays have fixed size in Go.

Why it matters: Believing len() changes can lead to unsafe code that tries to resize arrays, causing compile errors or runtime panics.

Quick: Can you assign an array of length 3 to a variable of array type length 5? Commit to yes or no.

Common Belief: Arrays of different lengths are interchangeable because they hold the same element type.

Reality: Arrays with different lengths are different types and cannot be assigned to each other without conversion.

Why it matters: Ignoring this causes confusing compile-time errors and misunderstandings about Go's type system.

Quick: Does len() return the number of elements currently stored or the capacity of the array? Commit to your answer.

Common Belief: len() returns how many elements are currently stored or used in the array.

Reality: len() returns the fixed size of the array, not how many elements are 'used' or meaningful.

Why it matters: This misconception can cause logic errors when programmers assume len() reflects dynamic content rather than fixed capacity.

Expert Zone

1

Arrays with the same element type but different lengths are distinct types, affecting function signatures and method receivers.

2

The fixed length allows the compiler to optimize memory layout and inline array operations for performance.

3

When passing arrays to functions, Go copies the entire array, which can be costly for large arrays; slices are preferred for efficiency.

When NOT to use

Avoid using arrays when you need dynamic sizing or efficient passing to functions. Use slices instead, which provide flexible length and capacity management with less copying.

Production Patterns

In production Go code, arrays are mostly used for fixed-size data like buffers or embedded data structures. Slices are the common choice for collections due to their flexibility. Understanding array length helps when interfacing with low-level code or optimizing performance-critical sections.

Connections

Slices in Go

Builds-on

Knowing array length clarifies how slices use arrays underneath and manage dynamic length and capacity.

Static arrays in C

Similar pattern

Understanding fixed-length arrays in Go helps grasp static arrays in C, which also have fixed size known at compile time.

Memory allocation in operating systems

Underlying principle

Fixed array length relates to how OS allocates contiguous memory blocks, ensuring efficient access and safety.

Common Pitfalls

#1 Accessing array elements beyond its length causes runtime panic.

Wrong approach:

var a [3]int
fmt.Println(a[3]) // Trying to access index 3 which is out of bounds

Correct approach:

var a [3]int
fmt.Println(a[2]) // Accessing last valid index

Root cause:

Misunderstanding that array indices start at 0 and go up to length-1.

#2 Trying to assign arrays of different lengths directly.

Wrong approach:

var a [3]int
var b [5]int
b = a // Compile error: cannot use a (type [3]int) as type [5]int

Correct approach:

var a [3]int
var b [5]int
// Copy elements manually or use slices for flexible assignment

Root cause:

Not realizing array length is part of the type, making different lengths incompatible.

#3 Hardcoding array length in loops instead of using len().

Wrong approach:

for i := 0; i < 5; i++ {
fmt.Println(a[i])
}

Correct approach:

for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}

Root cause:

Not using len() leads to errors if array size changes or is different than expected.

Key Takeaways

In Go, arrays have a fixed length that is part of their type and known at compile time.

The built-in len() function returns this fixed length, which never changes during program execution.

Arrays of different lengths are different types and cannot be assigned to each other directly.

Using len() in loops ensures safe and flexible access to array elements without hardcoding sizes.

Understanding array length helps you write safer, more efficient Go programs and prepares you to work with slices.