Arrays are used to store data of the same type inside a single variable. To define an array, we specify its size and the data type of its items.

var x [3]int

In the example above, we defined a variable named x. This variable's type is a numeric (int) array with a length of 3. Because we didn't specify any initial value for the array, the array's values are set to int's initial value, zero (0). So arrays don't need explicit initialization; an array's zero value is a ready-to-use array whose items themselves hold the zero value.

To access the array's values, we can do the following:

package main

import "log"

func main() {
    var x [3]int
    
    x[0] = 5
    x[1] = 10
    x[2] = 13

    log.Println(x[0], x[1], x[2])
}

// in the example above, we first put the values 5, 10, and 13 into the array, and finally displayed them in the output

In Go, we can access the values inside an array using its index. The index starts at zero (0) and goes up to one less than the array's size. For example, if the array's size is 3, you'll have three indexes: 0, 1, and 2.

In the example above, with indexes 0, 1, and 2, we can access the values inside the array. We can write a value at any index, or read the current value at any index.

If we want to specify an array's initial values when we define it, we can use an array literal, as follows:

var x = [3]int{2, 4, 6}

If you want to define an array and assign values to only some of its indexes, you can do the following:

var x = [12]int{1, 5: 4, 6, 10: 100, 15}

log.Println(x[0])  // 1
log.Println(x[1])  // 0
log.Println(x[2])  // 0
log.Println(x[3])  // 0
log.Println(x[4])  // 0
log.Println(x[5])  // 4
log.Println(x[6])  // 6
log.Println(x[7])  // 0
log.Println(x[8])  // 0
log.Println(x[9])  // 0
log.Println(x[10]) // 100
log.Println(x[11]) // 15
log.Println(x[12]) // 0

In the example above, we only assigned values to the indexes we needed. You can use a colon (:) to specify the index you want. The index goes on the left, and the value you want goes on the right.

If you're using an array literal to set an array's values, you can also specify the array's size as follows:

var x = [...]int{10, 20, 30}

To compare two arrays, we can use the == or != operators. Two arrays are equal if they have the same size and the same values.

var x = [...]int{1, 2, 3}
var y = [3]int{1, 2, 3}
fmt.Println(x == y) // prints true

 In Go, multi-dimensional arrays can also be simulated as follows:

var x [2][3]float32

In the example above, the variable x is an array of length 2, whose elements are each an array holding 3 32-bit floating-point numbers (float32)!

We can't use negative numbers to read from or write to arrays! If we use negative numbers, the program compiles, but it fails at runtime.

And as a final note, whenever you need to get an array's length, you can use the len function. This function takes an array as input and returns its length.

package main

import "fmt"

func main() {
    var x [5]float64
    fmt.Println(len(x)) // 5

    fmt.Println(len([...]int{4, 10, 8: 22, 40, 43})) // 11
}

Arrays should only be used when we know the array's length in advance.

In Go, because of the limitations they have, arrays are used very rarely:

• An array's size and item type are part of the array's data type, meaning an array defined as [3]int has a different data type than an array defined as [5]int. This means you can't use arrays with different sizes or item types in place of one another.

• An array's size must be specified when the array is defined, and it can't be changed after that. Also, a variable can't be used to define an array's size. If we try that, we'll get a compiler error.

• Type conversion can't be used to turn an array into an array with a different length.

• Arrays are usable right after they're declared, and every index of the array will hold its own zero value if no initial value was assigned to it.

We'll talk more about arrays' limitations in later parts. Here, we just touched on it, and you don't need to fully understand it yet! This was just so you're aware of it.

In Go, arrays are value types. When we assign an array to a variable, a copy of the array's contents is placed in that variable. Changing the array held in that variable has no effect on the original array!

package main

import "log"

func main() {
    var a [4]int
    
    a[0] = 1
    b := a
    b[0] = 5
    
    log.Println("a items:", a)
    log.Println("b items:", b)
}

Summary

In this part, you got familiar with the array data type and how to define and use it. You saw that you can pass an array to the len function and get its length. In later parts, you'll get a much more complete look at arrays' limitations and see more array examples.

Previous part: Variables and Data Types | Golang basics

Next part: The slice Data Type | Golang basics