Golang Arrays And Slices Complete Guide

Arrays

Example 1: Declaring and Initializing an Array

package main

import "fmt"

func main() {
    // Step 1: Declare an array of integers with length 5
    var a [5]int

    // Step 2: Initialize the array with values
    a = [5]int{10, 20, 30, 40, 50}

    // Step 3: Print the array
    fmt.Println("Array:", a)

    // Step 4: Access an element
    fmt.Println("First element:", a[0])

    // Step 5: Change an element
    a[1] = 25
    fmt.Println("Updated Array:", a)
}

Explanation:

1. Declare an Array: We declare an integer array named a with a fixed length of 5.
2. Initialize the Array: We initialize the array a with integer values {10, 20, 30, 40, 50}.
3. Print the Array: The complete array is printed using fmt.Println.
4. Access an Element: We access the first element of the array using zero-based indexing a[0].
5. Change an Element: We modify the second element of the array (a[1]) to 25.

Example 2: Short Variable Declaration of an Array

package main

import "fmt"

func main() {
    // Step 1: Use short variable declaration to create and initialize an array
    b := [3]string{"apple", "banana", "cherry"}

    // Step 2: Print the array
    fmt.Println("Fruit Array:", b)

    // Step 3: Loop through the array elements
    for i, fruit := range b {
        fmt.Printf("Index %d: %s\n", i, fruit)
    }
}

Explanation:

1. Short Variable Declaration: We use the short variable declaration := to create and initialize a string array b of length 3.
2. Print the Array: The array b is printed, showing all its elements.
3. Loop Through Elements: Using a for loop with the range keyword, we iterate over all elements in the array b. i is the index, and fruit is the value at that index.

Slices

Example 1: Creating a Slice from an Array

package main

import "fmt"

func main() {
    // Step 1: Create an array
    arr := [5]int{10, 20, 30, 40, 50}

    // Step 2: Create a slice from the array
    s := arr[1:4] // Slice contains {20, 30, 40}

    // Step 3: Print the slice
    fmt.Println("Slice:", s)
}

Explanation:

1. Create Array: An integer array arr with values {10, 20, 30, 40, 50} is created.
2. Create Slice: A slice s is created that includes only the elements from index 1 to 3 (i.e., {20, 30, 40}) of the array arr.
3. Print Slice: We print the slice s.

Example 2: Declaring and Initializing a Slice Directly

package main

import "fmt"

func main() {
    // Step 1: Declare and initialize a slice directly
    fruits := []string{"apple", "banana", "cherry"}

    // Step 2: Print the slice
    fmt.Println("Fruits Slice:", fruits)

    // Step 3: Add an element to the slice using append()
    fruits = append(fruits, "date")
    fmt.Println("Updated Fruits Slice:", fruits)

    // Step 4: Loop through the slice elements
    for i, fruit := range fruits {
        fmt.Printf("Index %d: %s\n", i, fruit)
    }
}

Explanation:

1. Declare and Initialize Slice: Instead of specifying a length, we make a slice of strings fruits containing {"apple", "banana", "cherry"}.
2. Print Slice: We print the initial fruits slice.
3. Add Element: We add another element "date" to the fruits slice using append(). Note that you must assign the result back to fruits because slices are reference types.
4. Loop Through Elements: Using a for loop, we iterate over all elements in the updated fruits slice.

Example 3: Making a New Slice with make() Function

package main

import (
    "fmt"
)

func main() {
    // Step 1: Make a new integer slice of length 6 and capacity 8
    scores := make([]int, 6, 8)

    // Step 2: Print the slice and its length & capacity
    fmt.Println("Scores Slice:", scores)
    fmt.Println("Length:", len(scores))
    fmt.Println("Capacity:", cap(scores))

    // Step 3: Access and change an element
    scores[1] = 90
    fmt.Println("Updated Scores Slice:", scores)

    // Step 4: Append several elements
    scores = append(scores, 70, 80)
    fmt.Println("Updated Scores Slice after Append:", scores)
    fmt.Println("New Length:", len(scores))
    fmt.Println("New Capacity:", cap(scores))
}

Explanation:

1. Make a Slice: We use the built-in make() function to create an integer slice named scores. It starts with a length of 6 and a capacity of 8.
2. Print Slice Details: We print the slice, and also its current length and capacity using len() and cap() functions respectively.
3. Modify Element: We modify an element in the slice, specifically changing the second element to 90.
4. Append Elements: Multiple elements 70 and 80 are appended to the original scores slice. This increases both its length and possibly its capacity as well if necessary.