Array Operations in Golang

Introduction

In modern software development, we often need to store a large amount of data.

Based on what we have learned, we can easily define numerous variables.

However, if we need to use variables to record the names of employees in a company, with data on a scale of hundreds or thousands, do we have to define them one by one?

Of course not. For data with similar attributes, we can use arrays to define and store them.

We can think of arrays as a collection of variables that come together like a train. And when we want to find a specific variable, we just need to know the train number (array name) and the seat number (index). Then we can find and manipulate the variable without knowing its name.

In this section, we will learn about various basic operations of arrays.

Knowledge Points:

• Array definition
• Array initialization
• Array traversal
• Characteristics of array elements

Skills Graph

Array Definition

How do we define an array?

Let's recall the situation when we learned about variables. How did we define an int variable?

var a int

That is:

var variable_name variable_type

Similarly, we can define an int array like this:

var a [10]int

That is:

var variable_name [number_of_elements]variable_type

In this way, we have defined a basic int array called a with a capacity of 10.

Initialization List

After understanding how to define an array, let's learn how to initialize an array.

When initializing an array, we can use an initialization list to set the initial values of the array elements.

Create an array.go file in the ~/project directory:

cd ~/project
touch array.go

Write the following code in array.go:

package main

import "fmt"

func main() {
    // Automatically initialized to the zero value of the element type
    var simpleArray [3]int
    // Initialize with specified initial values, and use the zero value to fill in the missing elements
    var numArray = [3]int{1, 2}
    // Initialize with specified initial values
    var cityArray = [2]string{"London", "Chengdu"}
    fmt.Println(simpleArray) // [0 0 0]
    fmt.Println(numArray)    // [1 2 0]
    fmt.Println(cityArray)   // [London Chengdu]
}

Run the code:

go run ~/project/array.go

Expected output:

[0 0 0]
[1 2 0]
[London Chengdu]

The above code demonstrates three ways to specify initial values using an initialization list:

• Without passing a list: Initialize to the zero value of the element type
• Passing a partial list: Initialize the specified elements with the specified values, and initialize the remaining elements to the zero value
• Passing a complete list: Initialize with the specified values

Note that if the length of the list passed in is greater than the number of elements in the array, the code will not compile.

Inferred Length Initialization

When initializing an array using an initialization list, you must ensure that the number of initial values provided is less than or equal to the number of elements.

In general, you can rely on the compiler to infer the array length based on the initial values.

Modify the array.go file as follows:

package main

import "fmt"

func main() {
    var simpleArray [3]int
    var numArray = [...]int{1, 2}
    var cityArray = [...]string{"London", "Chengdu"}
    fmt.Println(simpleArray)                      // [0 0 0]
    fmt.Println(numArray)                         // [1 2]
    fmt.Printf("The type of numArray is: %T\n", numArray)   // The type of numArray is: [2]int
    fmt.Println(cityArray)                        // [London Chengdu]
    fmt.Printf("The type of cityArray is: %T\n", cityArray) // The type of cityArray is: [2]string
}

Run the code:

go run ~/project/array.go

Expected output:

[0 0 0]
[1 2]
The type of numArray is: [2]int
[London Chengdu]
The type of cityArray is: [2]string

Initialization with Specified Indices

Sometimes, we may want to assign specific initial values to certain positions in an array, regardless of whether we use an initialization list or infer the length.

Modify the array.go file as follows:

package main

import "fmt"

func main() {
    a := [...]int{1: 1, 3: 5}
    fmt.Println(a)                  // [0 1 0 5]
    fmt.Printf("The type of array a is: %T\n", a) // The type of array a is: [4]int
}

Run the code:

go run ~/project/array.go

Expected output:

[0 1 0 5]
The type of array a is: [4]int

The above code specifies the initial values of the elements with indices 1 and 3 as 1 and 5, respectively. It also uses the inference of length initialization method, which you should learn.

Note: In computing, the index starts from 0.

Array Traversal

Sometimes, we need to access each element of an array and perform operations on them one by one.

Here, we introduce two ways to traverse arrays:

Write the following code in array.go:

package main

import "fmt"

func main() {
    a := [...]int{123, 321, 456, 777}
    // Method 1: range
    fmt.Println("Traversing the array using range")
    for index, value := range a {
        fmt.Println(index, " ", value)
    }
    // Method 2: using indices
    fmt.Println("\nTraversing the array using indices")
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])
    }
}

Run the code:

go run ~/project/array.go

Expected output:

Traversing the array using range
0 123
1 321
2 456
3 777

Traversing the array using indices
123
321
456
777

Both methods above can be used to traverse the entire array.

Accessing Array Elements

To access a specific element in an array, which is essentially a variable, we use the index.

Similar to most programming languages, the index of an array starts from 0, and the index of the last element is len-1.

If an index larger than this limit is used in the code, it will result in an out-of-bounds error.

To access the i-th element of the a array, you can use the following notation:

a[i]

That is:

array_name[index_of_element]

Value Type of Arrays

Arrays are value types; assigning an array or passing an array as a parameter will copy the entire array. In other words, you will modify the values of the copy, not the original array.

Write the following code in array.go:

package main

import "fmt"

func modifyArray(x [3]int) {
    x[0] = 100
}

func main() {
    a := [3]int{10, 20, 30}
    modifyArray(a) // The variable `x` in `modifyArray` is a copy of `a`
    fmt.Println(a) // [10 20 30]
}

Run the code:

go run ~/project/array.go

The output will be:

[10 20 30]

From the above code, it can be seen that when the a array is passed to the modifyArray function, only a copy of its original array is actually passed.

Changing the value of the array x in the function does not affect the original array a.

Summary

In this lab, we learned:

• How to define an array
• Three methods of array initialization
• Characteristics of arrays and how to access their elements

Arrays are not commonly used in actual development, but they are the foundation for learning commonly used data structures in Go.

I hope that all Gophers will practice diligently and learn to apply what they have learned.