Arrays in Go

Array lay out foundation for slice in Go. Array is a list of fixed size of similar kind of elements that stores in contiguous locations in memory. Go's arrays share some similarity with C but Go adds some extra layers to prevent misuse of an array like we cannot do pointer arithmetic in idiomatic Go.

To create an array of type T, the syntax looks something like this.

1var arrayName [size]T

The zero value of array is the zero value of the T. So, every element of an array is set to whatever the zero value of T is.

Below snippet creates an array of integer with size 3. Because zero value of int is 0, Go initializes every element to 0.

1var nums [3]int // [0, 0, 0]

The size of an array must be known by the compiler, so as long as compiler can figure out the size, we can use it. For example, we can use any constant expression like this.

1const totalSlots = 1 << 7
2var slots [totalSlots]int

We cannot use var here, because a variable created with var is mutable, so in below case Go is not happy with it.

1var totalSlots = 1 << 7
2var slots [totalSlots]int

Compiler will give invalid array length totalSlots.

As always, we can use subscript notation to access elements of an array and can update them as well.

1nums[0] = 10
2nums[2] = 30
3fmt.Printf("%d\n", nums[1])

Go's compiler can catch error for out-of-bounds access as long as it can statically analyze them. So in below case compiler will throw an error invalid argument: index 256 out of bounds [0:128].

1slots[1 << 8] = 200

But we can screw it up at runtime like this.

1var i int = 1 << 8
2slots[i] = 200

This will give us panic: runtime error: index out of range [256] with length 128.

Go is a type-safe language, meaning it has no undefined behavior like C has. So, Go adds some extra safety checks behind the scenes. In the following innocent program, Go is still checking for out of bound access and prevents the program from accessing the memory location that does not belong to it.

1package main
2
3import "fmt"
4
5const totalUsers = 5
6
7func main() {
8	var users [totalUsers]int
9	i := 0
10	for i <= totalUsers {
11		fmt.Printf("%d\n", users[i])
12		i++
13	}
14}

Above code will prints five zeros and then panic with error message panic: runtime error: index out of range [5] with length 5.

Array Literal

There are many ways to create and initialize an array. Here are the all possible ways to do it.

1// Initialize to zero value
2var arrayName [size]T = [size]T{}
3var arrayName = [size]T{}
4arrayName := [size]T{}
5
6// With some values
7var arrayName [size]T = [size]T{v1, v2, v3, ...}
8var arrayName = [size]T{v1, v2, v3, ...}
9arrayName := [size]T{v1, v2, v3, ...}
10
11// Let the compiler infer the size of an array
12var arrayName = [...]T{v1, v2, v3, ...}
13arrayName := [...]T{v1, v2, v3, ...}
14
15// Sparse index
16var arrayName = [...]T{v1, v2, v3, [index]: v4, ...}
17arrayName := [...]T{v1, v2, v3, [index]: v4, ...}

Here are the examples of above syntax.

1package main
2
3import "fmt"
4
5const totalUsers = 5
6const maxBooking = 3
7const totalMsg = 3
8
9func main() {
10	// Initialize to zero value
11	var users [totalUsers]string = [totalUsers]string{}
12	var bookings = [maxBooking]int{}
13	cartItems := [4]int{}
14
15	// With some values
16	var messages [totalMsg]string = [totalMsg]string{"Hello John!", "What's up man"}
17	var displayNames = [2]string{"Kachara Seth", "Jeetulal"}
18	validationMsgs := [2]string{"First name is required", "Phone no is required"}
19
20	// Let the compiler infer the size of an array
21	var posts = [...]string{"What a nice day!", "I got a new laptop."}
22	tweets := [...]string{"Tweet 1", "Tweet 2"}
23
24	// Sparse index
25	var settings = [...]string{"Preference", "Profile", "Notifications", 10: "Labels", "Status", "Team"}
26	tenants := [...]string{"Henry Avery", "Nathan Drake", "Chloe Frazer", 4: "Samuel Drake", "Victor Sullivan", 3: "Elena Fisher"}
27}

A few things to remember when using sparse index syntax.

Any subsequent values after index:value pair are going to placed after index. So, for example in settings array, after 10: Labels the Status and Team will be placed at 11 and 12 index corresponding.

On the other hand in tenants array, after 4th index the Victor Sullivan goes to 5th index but then we add value for 3rd index. This is allowed because 3rd index is not specified before. If we change it to 2 then the compiler will complain about duplicate index 2 in array or slice literal. So, compiler is helping us to prevent any accidental modification to existing index.

Comparison

In Go, we can directly compare two array variables if their sizes are the same and element's type is comparable. Remember, size of an array is part of its type.

1a1 := [3]int{1,2,3}
2a2 := [3]int{1,2,3}
3isSame := a1 == a2 // true

In above example, both arrays have the same size and same element type. So, it is legal to compare them. If the sizes were different, the comparison would produce an error. Here, Go eliminates comparing two arrays of different size at compile time.

1a1 := [3]int{1,2,3}
2a2 := [4]int{1,2,3}
3isSame := a1 == a2

Here we will get compilation error invalid operation: a1 == a2 (mismatched types [3]int and [4]int)

Arrays Are Values

One more thing about arrays in Go is that they are values rather than a pointer to first element like in C and C++. So when we assign an array to a new variable or pass it as a function argument, Go creates a copy of that array and uses it. So, like a normal value, assignment creates a copy.

This is different then C because in C, array decay into pointers so when we pass array into function, an address to the first element is actually passing rather than copy.

1package main
2
3import "fmt"
4
5func incrementByOne(a [3]int) {
6	fmt.Printf("incrementByOne: %p, %p\n", &a, &a[0])
7	for i := 0; i < 3; i++ {
8		a[i] += 1
9	}
10}
11
12func main() {
13	a := [3]int{1, 2, 3}
14	b := a
15	b[0] = 10
16
17	fmt.Println(a)
18	fmt.Println(b)
19
20	fmt.Printf("%p, %p\n", &b, &b[0])
21	incrementByOne(b)
22	fmt.Println(b)
23}
24

In above code, a and b are two different arrays in memory. So, mutating one does not affect other. Similarly, when b is passed to incrementByOne, it receives a new copy of b so any changes the function made do not affect the original array.

Pointers and Arrays

Because arrays are values, passing a large array to a function is costly because it needs to create a new array and copy all the elements from original. We can use pointer for this scenario and Go makes it easy to work with pointers.

1package main
2
3import "fmt"
4
5func incrementByOne(a *[3]int) {
6	for i := 0; i < 3; i++ {
7		a[i] += 1
8	}
9}
10
11func main() {
12	a := [3]int{1, 2, 3}
13	fmt.Println(a)
14	incrementByOne(&a)
15	fmt.Println(a)
16}

Here the interesting part is a[i] in incrementByOne. a is actually a pointer but Go simplifies the syntax to work with pointers. It is just syntactic sugar over (*a)[i].

One more thing here is that the zero value of a pointer is nil. So, when working with pointers we need to make sure we don't dereference a nil pointer which causes a runtime panic.

1var b *[3]int
2b[0] = 1 // Dereferencing a nil pointer

Go does not allow pointer arithmetic directly on an array. This code will fail to compile with an error: invalid operation: pa + 1 (mismatched types *[3]int and untyped int)

1package main
2
3func main() {
4	a := [3]int{1, 2, 3}
5	pa := &a
6	pa = pa + 1
7}

Although there are dark magic like this.

1package main
2
3import (
4	"fmt"
5	"unsafe"
6)
7
8func main() {
9	a := [3]int{1, 2, 3}
10	fmt.Printf("%p, %p, %p\n", &a[0], &a[1], &a[2])
11
12	p := uintptr(unsafe.Pointer(&a))
13	for i := 0; i < 3; i++ {
14		val := *(*int)(unsafe.Pointer(p))
15		fmt.Printf("%x, %d\n", p, val)
16		p = p + unsafe.Sizeof(a[0])
17	}
18}
19

Let me explain this scary looking thing.

p := uintptr(unsafe.Pointer(&a)) this takes the address of a which is address of first element's first location. Then, we convert that address to unsafe.Pointer because in type safe Go, it does not allow any kind of pointer arithmetic. Then we convert Pointer into uintptr, which produces the memory address as an integer. uintptr belongs to the integer family, and it bypasses all the type safety that Go provides.

One thing to note here, uintptr is an integer and not a reference. So it does not have any pointer semantics which means we cannot dereference the variable p, even if it contains a valid memory address. Also, the garbage collector is not happy to track uintptr variables. So, idiomatic Go does not allow uintptr or unsafe package at all.

val := *(*int)(unsafe.Pointer(p)) in this statement, we convert p, which is uintptr, back to Pointer; so we can dereference it. To read value correctly we tell compiler to treat that pointer as *int because a is holding int type elements. At this point the type becomes a pointer to an integer(*int), because we are interested in value we just dereference it and store the value in val variable.

p = p + unsafe.Sizeof(a[0]), here we are adding offset to p. We cannot do p + 1, otherwise it adds only a 1 byte offset. We want to move to next location in array so we need to move by the size of integer which we can get by using unsafe.Sizeof and here we pass first element as expression.

Len and Cap

The built-in len and cap functions return the size of the array.

1a := [3]int{1, 2, 3}
2fmt.Println(len(a)) // 3
3fmt.Println(cap(a)) // 3

Limitations of Array

Array has one major limitation, its size. We cannot write a program like this.

1var size int
2fmt.Scanf("%d\n", &size)
3
4var users [size]string

It will fail to compile with an error invalid array length size. Because in its definition, size is a required parameter which must be known by compiler at compile time.

To address this limitation, Go provides an abstraction over array in form of slice which is Go's way to do dynamic array.

Footnotes

From the book Programming Rust - FAST, SAFE SYSTEMS DEVELOPMENT by Jim Blandy & Jason Orendorff, they answer the question: What do we mean by type safety?. So it all starts from the definition of undefined behavior from 1999 C standard call C99.

It means the program can do anything.

Go is type safe language. Go puts checks like out of bound index access for example that prevent the program from exhibiting to do any undefined behavior.