Using Go Arrays and Slices: A Basic Guide

What are Go Arrays and Slices?

In the Go programming language, arrays and slices are two fundamental structures for creating data collections. Arrays are data sets with a fixed length, consisting of elements of a single type, stored contiguously in memory. Slices, on the other hand, are flexible data structures built on top of arrays, with dynamic length and capacity. Understanding the differences between Go arrays and slices is key to writing effective and efficient code.

Working with Go Arrays

Go arrays are structures whose size is determined at the moment they are defined. When defining an array, you specify its type and the number of elements. Below you can see how to create and use an integer array in Go:

package main
import "fmt"
func main() {
    var numbers [5]int = [5]int{10, 20, 30, 40, 50}
    fmt.Println(numbers)
    fmt.Println("First element:", numbers[0])
    numbers[2] = 100
    fmt.Println("Updated array:", numbers)
}

Because arrays are value types, when you assign an array to another variable, it is copied. Their lightweight and fixed nature makes them preferable in certain cases, but slices—which are more flexible—are used most of the time.

Flexible Data Management with Slices

Slices are structures that are defined on top of an array and whose length and capacity can be grown dynamically. Go slices are very suitable for dynamically holding multiple pieces of data in applications. For example, creating a slice and adding elements is as easy as the following:

package main
import "fmt"
func main() {
    names := []string{"Ahmet", "Mehmet", "Ayşe"}
    fmt.Println(names)
    names = append(names, "Zeynep")
    fmt.Println("New names:", names)
    fmt.Println("Length:", len(names), "Capacity:", cap(names))
}

While working with slices, you can easily manage data using built-in functions like append(), copy(), and len(). Slices automatically create new arrays in the background to grow the data size and preserve the existing content when necessary.

Conclusion: Differences Between Go Arrays and Slices

The use of Go arrays and slices allows you to choose the most suitable data model based on the structure and variability of the data. Arrays are stable and fast, while slices are flexible and practical. Slices are especially preferred in situations where the size of the data is changeable. Arrays stand out in scenarios that require performance and memory optimization. These key differences between Go arrays and slices help make your code more sustainable and efficient.