Go Arrays

Welcome to The Coding College! Arrays are a fundamental data structure in Go (Golang), allowing you to store multiple values of the same type in a fixed-size collection. They are widely used for organizing data efficiently and are an essential building block for mastering Go programming.

This guide explores the concept of arrays in Go, covering their properties, syntax, and practical examples.

What Is an Array?

An array is a collection of elements of the same type, stored in contiguous memory locations. In Go:

  • Arrays have a fixed length that cannot be changed once declared.
  • All elements of the array must be of the same type.

Declaring an Array

  • Explicit Declaration 
var arr [5]int // Array of 5 integers
  • Initialize with Values 
var arr = [5]int{1, 2, 3, 4, 5}
  • Implicit Length
    Let Go infer the length based on the number of elements. 
arr := [...]int{1, 2, 3}
  • Default Values
    Uninitialized elements in an array are set to their zero value:
    • 0 for numeric types.false for booleans."" (empty string) for strings.
var arr [3]int
fmt.Println(arr) // Output: [0 0 0]

Accessing Array Elements

Use an index to access or modify elements.

  • Indexing starts at 0.
  • Accessing an out-of-bounds index results in a runtime error.
package main

import "fmt"

func main() {
    arr := [3]int{10, 20, 30}
    fmt.Println(arr[0]) // Output: 10
    arr[1] = 25          // Modify the second element
    fmt.Println(arr)     // Output: [10 25 30]
}

Looping Through Arrays

  • Using a Standard for Loop 
arr := [3]string{"Go", "is", "fun"}
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}
  • Using a for...range Loop
    The range keyword simplifies iteration by providing both the index and the value. 
for index, value := range arr {
    fmt.Printf("Index: %d, Value: %s\n", index, value)
}

Array Operations

1. Length of an Array

Use the len() function to get the number of elements in an array.

arr := [5]int{1, 2, 3, 4, 5}
fmt.Println(len(arr)) // Output: 5

2. Copying Arrays

Assigning one array to another creates a copy, not a reference.

arr1 := [3]int{1, 2, 3}
arr2 := arr1
arr2[0] = 10
fmt.Println(arr1) // Output: [1 2 3]
fmt.Println(arr2) // Output: [10 2 3]

3. Comparing Arrays

Arrays can be compared using the == and != operators if they are of the same type and size.

arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
fmt.Println(arr1 == arr2) // Output: true

Multi-Dimensional Arrays

Go supports multi-dimensional arrays, such as 2D arrays.

Declaration:

var matrix [2][3]int // 2 rows, 3 columns

Initialization:

matrix := [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

Accessing Elements:

fmt.Println(matrix[1][2]) // Output: 6

Iterating Over a 2D Array:

for i := 0; i < len(matrix); i++ {
    for j := 0; j < len(matrix[i]); j++ {
        fmt.Printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j])
    }
}

Practical Examples

Example 1: Find Maximum in an Array

package main

import "fmt"

func main() {
    arr := [5]int{10, 20, 5, 30, 25}
    max := arr[0]
    for _, value := range arr {
        if value > max {
            max = value
        }
    }
    fmt.Println("Maximum:", max) // Output: 30
}

Example 2: Sum of Array Elements

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    sum := 0
    for _, value := range arr {
        sum += value
    }
    fmt.Println("Sum:", sum) // Output: 15
}

Example 3: Transpose a Matrix

package main

import "fmt"

func main() {
    matrix := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }

    var transpose [3][2]int
    for i := 0; i < len(matrix); i++ {
        for j := 0; j < len(matrix[0]); j++ {
            transpose[j][i] = matrix[i][j]
        }
    }

    fmt.Println("Transpose:")
    for _, row := range transpose {
        fmt.Println(row)
    }
}

Best Practices for Arrays

  1. Fixed Size
    • Use arrays only when the size is fixed and known at compile time.
    • For dynamic sizes, consider using slices instead.
  2. Zero Values
    • Remember that Go initializes array elements to their zero values.
  3. Avoid Hardcoding Sizes
    • Use len() to determine array sizes dynamically instead of hardcoding values.
  4. Consider Performance
    • Arrays in Go are copied when assigned or passed to functions, so be mindful of memory usage with large arrays.

Conclusion

Arrays in Go are a simple yet powerful tool for managing collections of data. By understanding their properties and limitations, you can use them effectively in your programs.

Leave a Comment