Creating and Manipulating Slices in Go: A Beginner's Guide

Welcome to our session on Go slices! Slices, which are flexible data sequences in Go, are crucial for managing dynamic data sets. This lesson lays the groundwork for creating and manipulating slices in Go.

Slices in Go are dynamic sequences of elements that provide the functionality and flexibility that arrays lack. While both slices and arrays allow for the collection of elements under a single name, their capabilities differ significantly. Arrays have a fixed size, defined at compile time, making them less optimal for sequences of elements whose size might change. Slices, on the other hand, are built on top of arrays to offer dynamic sizing. They can grow and shrink as needed, making them the go-to choice for dealing with sequences of data that require flexibility.

A slice has three key properties: a pointer to an array (the underlying array where the elements of the slice are actually stored), a length, and a capacity. The len() function returns the number of elements in the slice, while the cap() function returns the maximum number of elements the slice can hold before needing to allocate a larger underlying array.

var numbers []int // nil slice
fmt.Println(len(numbers))  // Output: 0  
fmt.Println(cap(numbers))  // Output: 0  

To create a slice, you can either define it directly with elements, use the make function, or slice an existing slice or array. The make function creates a slice with a predetermined length and capacity, making it immediately ready for use without specifying initial elements.

numbers := make([]int, 5)  // A slice of five integers
fmt.Println(numbers)       // Output: [0 0 0 0 0]

numbers := []int{1, 2, 3, 4, 5}  // Directly initializing a slice with elements
fmt.Println(numbers)             // Output: [1 2 3 4 5]

subSlice := numbers[1:4]         // Creating a sub-slice, slicing from 1 to 3 index
fmt.Println(subSlice)            // Output: [2 3 4]

The append() function adds new elements to the end of a slice. If the underlying array of the slice has enough capacity to fit the new elements, append() will use it; otherwise, it will allocate a new array, copy the existing elements, and add the new ones. This automatic handling of array resizing is what makes slices so versatile.

numbers = append(numbers, 6, 7) // Appending new elements
fmt.Println(numbers)            // Output: [1 2 3 4 5 6 7]