Arrays and Slices in Go

Arrays and slices are fundamental data structures in Go used for storing and manipulating ordered sequences of elements. While they share similarities, they have key differences in size and flexibility.

Arrays

Definition and Declaration

Arrays have a fixed size defined at declaration. They are declared using [size]type{values}:

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

This creates an array numbers of size 5, initialized with values 1 to 5.

Accessing Elements

Elements are accessed using their index within square brackets:

firstNumber := numbers[0] // firstNumber will be 1
thirdNumber := numbers[2] // thirdNumber will be 3

Index starts from 0, and accessing an out-of-bounds index leads to a panic.

Modifying Elements

Elements can be modified using the same syntax:

numbers[2] = 10 // Change third element to 10

Length and Capacity

• len(array) returns the number of elements in the array (always equal to the declared size).
• Arrays don’t have a separate capacity concept.

Slices

Definition and Creation

Slices are dynamically-sized, flexible references to underlying arrays. They are created using:

• []type: Empty slice of a specific type.
• make([]type, length, capacity): Allocate a slice with specified length and capacity.
• Slicing an existing array or slice: slice := array[low:high].

// Empty slice
emptySlice := []string{}

// Slice with length and capacity
numbersSlice := make([]int, 3, 5) // Length 3, capacity 5

// Slicing an array
myArray := [5]int{1, 2, 3, 4, 5}
subSlice := myArray[1:4] // Subslice from index 1 to 4 (excluding 4)

Accessing and Modifying Elements

Similar to arrays, elements are accessed and modified using their index:

firstElement := numbersSlice[0] // firstElement will be 0

subSlice[1] = 20 // Change second element of subSlice

Length and Capacity

• len(slice) returns the number of elements in the slice.
• cap(slice) returns the capacity (maximum number of elements) of the underlying array.

Slicing a Slice

Slices can be sliced to create new sub-slices:

subSubSlice := subSlice[0:2] // Subslice of subSlice from index 0 to 2 (excluding 2)

Appending Elements

The append function adds elements to the end of a slice and returns a new slice with the updated elements:

newSlice := append(numbersSlice, 10, 20) // Creates a new slice with numbersSlice + 10 and 20

Built-in functions

• append: Adds elements to the end of a slice.
• copy: Copies elements from one slice to another.
• cap: Returns the capacity of a slice.
• make: Creates a slice with specified length and capacity.

These are just some of the essential aspects of arrays and slices in Go. Remember to explore the documentation and experiment with code for a deeper understanding.

Multidimensional Arrays

Declaration and Access

Multidimensional arrays are arrays of arrays. They are declared like:

grid := [3][4]int{
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12},
}

Elements are accessed using multiple indices:

firstElement := grid[0][0] // firstElement will be 1
thirdRow := grid[2] // thirdRow is a 1D array {9, 10, 11, 12}

Slicing Multidimensional Arrays

Slices can be used with multidimensional arrays:

subGrid := grid[1:3] // Subgrid is a 2D slice containing second and third rows
subRow := grid[0][1:3] // Subrow is a slice of second and third elements in the first row

Pointers and Slices

Passing Slices by Reference

Slices are passed by reference to functions, meaning changes within the function modify the original slice.

func modifySlice(s []int) {
  s[0] = 100
}

numbers := []int{1, 2, 3}
modifySlice(numbers)
fmt.Println(numbers) // Output: [100 2 3]

Modifying Slices within Functions

• Use append to add elements to a slice within a function.
• Be cautious when modifying the underlying array directly, as it can lead to unexpected behavior.

func appendToSlice(s []int, value int) {
  s = append(s, value)
}

numbers := []int{1, 2, 3}
appendToSlice(numbers, 4)
fmt.Println(numbers) // Output: [1 2 3 4]

Remember, these are just brief introductions to each subtopic. For deeper understanding, explore the Go documentation and experiment with code examples.