In Go, arrays are a collection of elements of the same type. They are not as flexible as slices, but they provide a fixed-size list of elements with better performance characteristics because their size is determined at compile-time. Let's explore how to declare and initialize arrays in Go from basic to advanced levels.

Basic Array Declaration

To declare an array in Go, you use the syntax [n]Type, where n is the number of elements in the array, and Type is the data type of the elements. You can declare an uninitialized array that defaults to zero values.

package main

import "fmt"

func main() {
    var arr [5]int // declare an array of 5 integers
    fmt.Println(arr) // Output: [0 0 0 0 0]
}

Intermediate Array Initialization

You can also declare and initialize arrays at the same time using array literals. This method allows you to specify the array values within curly braces.

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5} // declare and initialize
    fmt.Println(arr) // Output: [1 2 3 4 5]

    arr2 := [...]int{10, 20, 30} // Compiler counts number of elements
    fmt.Println(arr2) // Output: [10 20 30]
}

Using Array with Different Data Types

Arrays in Go can contain types other than int, such as string or float.

package main

import "fmt"

func main() {
    var strArr [3]string
    strArr[0] = "Hello"
    strArr[1] = "World"
    strArr[2] = "Go"
    fmt.Println(strArr) // Output: [Hello World Go]

    floatArr := [2]float64{1.5, 2.5}
    fmt.Println(floatArr) // Output: [1.5 2.5]
}

Advanced Array Operations

As you gain more advanced expertise in Go, you may need to work with multidimensional arrays, commonly known as matrixes.

package main

import "fmt"

func main() {
    // Declare a 2x3 integer array
    var matrix [2][3]int
    matrix[0][0] = 1
    matrix[0][1] = 2
    matrix[0][2] = 3
    matrix[1][0] = 4
    matrix[1][1] = 5
    matrix[1][2] = 6
    fmt.Println(matrix) // Output: [[1 2 3] [4 5 6]]

    // Or directly with initialization
    initMatrix := [2][2]int{{1, 2}, {3, 4}}
    fmt.Println(initMatrix) // Output: [[1 2] [3 4]]
}

Remember, with arrays, the size is part of the type, so [3]int and [5]int are different types. Arrays have fixed sizes so once an array of length 5 is declared, it cannot be resized.

By understanding how arrays work in Go, you can effectively use them for fixed-size data structures while benefiting from Go's performance characteristics.