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.

Go
Copy to clipboard
1var numbers []int // nil slice
2fmt.Println(len(numbers))  // Output: 0  
3fmt.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.

Go
Copy to clipboard
1numbers := make([]int, 5)  // A slice of five integers
2fmt.Println(numbers)       // Output: [0 0 0 0 0]
3
4numbers := []int{1, 2, 3, 4, 5}  // Directly initializing a slice with elements
5fmt.Println(numbers)             // Output: [1 2 3 4 5]
6
7subSlice := numbers[1:4]         // Creating a sub-slice, slicing from 1 to 3 index
8fmt.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.

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

Although Go does not have a built-in function to remove elements from a slice directly, you can achieve this by utilizing slicing and the append() function. To remove elements, you create a new slice that skips over the elements you intend to remove.

Go
Copy to clipboard
1// Removing the element at index 2
2numbers = append(numbers[:2], numbers[3:]...)  // Creates a new slice by appending elements after index 2 to those before index 2
3fmt.Println(numbers)                           // Output: [1 2 4 5 6 7]

This method splits the slice around the element(s) to be removed and then combines the two parts. This operation does not immediately free the memory of the removed element(s) as they might still be part of the underlying array, highlighting the importance of understanding slice internals to manage memory effectively.

... in the line numbers = append(numbers[:2], numbers[3:]...) is used to add elements from a slice or array to another slice one by one. The ...' effectively tells the append function to unpack the elements of numbers[3:] (which is a slice) and treat them as separate arguments. Without ..., the append function would treat numbers[3:] as a single slice argument.

You might sometimes need to copy one slice to another when working with slices. The copy() function facilitates this, allowing you to duplicate the elements of a source slice to a destination slice. The number of elements copied is the minimum of len(src) and len(dst).

Go
Copy to clipboard
1moreNumbers := make([]int, len(numbers))  // Creating a new slice
2copy(moreNumbers, numbers)                // Copying elements from numbers to moreNumbers
3fmt.Println(moreNumbers)                  // Output: [1 2 4 5 6 7]

In this lesson, you've gained a deeper understanding of slices in Go—including their dynamic nature, how they differ from arrays, and the mechanics of adding and removing elements. Moreover, the manipulation of slice capacity and the copy() function have highlighted advanced capabilities of Go's slice mechanics. With these tools, you're now better prepared to efficiently manage and manipulate data sequences in Go, laying a solid foundation for upcoming practice sessions.