🧱 Go – Arrays Explained with Syntax, Examples, and Use Cases (2025 Guide)

🧲 Introduction – What Are Arrays in Go?

In Go, an array is a fixed-size collection of elements of the same type. Unlike slices, arrays are not resizable, making them ideal for static data structures, fixed buffers, and low-level memory-safe operations. Each array has a known size and indexed elements starting from 0.

🎯 In this section, you’ll learn:

• How to declare, initialize, and access arrays
• Array indexing and iteration techniques
• Difference between arrays and slices
• Common use cases and limitations

✅ Basic Syntax – Declare and Initialize Arrays

var a [3]int
a[0] = 10
a[1] = 20
a[2] = 30

fmt.Println(a)

📤 Output:

[10 20 30]

✅ a is an array of 3 integers with values assigned using indices.

🔁 Short Declaration and Initialization

b := [3]string{"Go", "Java", "Rust"}
fmt.Println(b)

📤 Output:

[Go Java Rust]

✅ You can also let Go infer the size:

c := [...]float64{3.14, 1.61, 2.71}
fmt.Println(len(c))  // Output: 3

🔢 Accessing Elements by Index

names := [3]string{"Alice", "Bob", "Charlie"}
fmt.Println(names[1]) // Output: Bob

✅ Index starts at 0 and ends at length - 1.

🔄 Iterating Over Arrays – for Loop

arr := [4]int{10, 20, 30, 40}
for i := 0; i < len(arr); i++ {
    fmt.Println("Index", i, "=", arr[i])
}

✅ Classic for loop with index access.

🔁 Iterating with range

arr := [3]int{5, 10, 15}
for i, v := range arr {
    fmt.Println("Index:", i, "Value:", v)
}

✅ range provides both index and value.

⚖️ Arrays vs Slices in Go

⚠️ Arrays Are Value Types

When you assign an array to another variable, Go makes a copy, not a reference:

a := [3]int{1, 2, 3}
b := a
b[0] = 100
fmt.Println(a) // [1 2 3]
fmt.Println(b) // [100 2 3]

✅ Use slices if you want reference-like behavior.

🧠 Best Practices

• ✅ Use arrays for fixed-size collections (e.g., days of the week, RGB values)
• ❌ Don’t use arrays for dynamic lists—prefer slices
• ✅ Use [...]Type{} for inferred-size declarations
• ✅ Iterate with range for readability and performance

📌 Summary – Recap & Next Steps

Arrays in Go are efficient and predictable, ideal for situations where size doesn’t change. While they’re less flexible than slices, arrays give you better control and memory safety.

🔍 Key Takeaways:

• Arrays are fixed-length, same-type data containers
• Use index-based or range-based access
• Arrays are value types—assignments are copied
• Prefer slices for flexible, real-world data lists

⚙️ Next: Learn about Go Slices, which are dynamic views into arrays and more commonly used in modern Go code.

❓ FAQs – Go Arrays

❓ Can I change the size of an array in Go?
❌ No. Arrays are fixed-size. Use slices for dynamic resizing.

❓ Are arrays in Go value or reference types?
✅ Arrays are value types. Assigning one array to another copies the data.

❓ How do I get the length of an array in Go?
✅ Use len(array).

❓ What is the zero value of an array?
✅ All elements are initialized to the zero value of their type (e.g., 0 for int, "" for string).

❓ Can I loop through arrays with range?
✅ Yes. range gives index and value on each iteration.