Contextualizing slices in Go

Go is a high-level language with low-level language features. It was designed by Robert Griesemer, Rob Pike, and Ken Thompson and released by Google in 2012. Go supports high-level language constructs and characteristics, such as garbage collectionProcess of freeing up (or collecting) unused memory from the heap, Golang generics, high-performance networking, and Go concurrency. At the same time, it offers implementation and control that has low-level characteristics. For example, it provides high-level concurrency support through goroutines and also through channels, but low-level functionality can also be used with the sync/atomic package to enforce thread-safe synchronization. It is statically typed, fully compiled, and hence offers better runtime efficiency (compared to Java, Python, JavaScript, and other interpretable languages).

The Go language has a special data structure called a slice that provides a powerful and efficient way to represent arrays due to its dynamic size and flexibility.

Slices in Go language

A slice is an array with a variable length that can store the same type of elements. Internally, a slice is a reference to an underlying array. A slice always starts with 0 index, and the last element of a slice is at N-1 index where N is the length of the slice. The size C of the underlying array is known as the capacity of the slice where C is always greater than or equal to N.

Slice, pointer, and array: A pictorial explanation

Go can be viewed as a C-family language and provides the support for pointers and arrays. However, for safety reasons, there are restrictions on Go pointers (when compared with C pointers). In addition, Go supports slices, which are flexible and dynamic.

The following diagram shows a pictorial comparison of an array, a pointer, and a slice. The memory layout of a slice in Go is a structure that consists of a pointer to an array and two variables (len and cap indicating the length and the capacity of a slice, respectively). A pointer holds the memory address of a value. The type *T is a pointer to the value T. While the length of an array is fixed, the slice and the pointer may point to any element of the array (memory address). While the pointer does not have a particular size or capacity associated, the memory layout of a slice in Go contains variables to hold the length and the capacity of the slice.

Slice vs. array

Array size must be defined while defining an array variable or else [...] must be used in array declaration to let the Go compiler determine it automatically. If nothing is put in the square brackets, then a slice is created. Valid indices for both the arrays and slices are from 0 and l-1 where l is the length of an array or a slice. Moreover, the size of an array can't be changed after creation, however a slice in this context is flexible.

Another difference arises while dealing with function arguments. All function arguments are passed by value in Go language. Therefore, while passing an array to a function, a copy of that array is created and passed to the function. Consequently, changes to the array done inside the function are lost on function's return. On the contrary, as mentioned above, a slice is a header containing pointer to an underlying array. Therefore, while passing a slice to a function, copy of that header is made and passed to the function. Hence, argument passing using a slice is faster and also preserves any changes performed in the function on the original slice.

Therefore, given this flexibility and power of a slice, a slice is usually preferable to an array while programming in Go. However, arrays are still useful in Go when a detailed memory layout is needed. For example, while reading a .wav (audio) file, there's an informational header with a fixed structure. Many fields in this header are usually of no concern in the implementation. While committing a write/read in this type of file in Go, a structure containing the desired fields is defined. In between, arrays of an appropriate size are defined to take care of unimportant fields in the audio file header.

Slice vs. pointer

A pointer is represented by *T where T is the type of the stored value. For example in ptr *int, the ptr is a pointer to an int. The * operator[object Object] dereferences the pointer while the & operator provides the address of the variable (which is also a pointer to the variable).

While function arguments are passed by value in Go, pointers are one of the ways to avoid copy overhead for passing structures and arrays. Additionally, pointers to structures are handy while creating data structures like linked lists and binary trees. For further clarity about internal layout of a pointer in Go language, please refer to the figure and the discussion in this Go language lesson. However, Go doesn't support the pointer arithmetics that are available in C. Compared with pointers, slices are passed to a function without the need to use a pointer since Go passes the pointer to the underlying array of a slice internally.

Connection between a slice and an array

Each slice is based on an underlying array with a length that's the same as the capacity of the slice. If an existing array is connected with a slice, any changes to the slice affect the referenced array. However, when the capacity of the slice changes, contents of the old underlying array are copied to a new array with the updated capacity, and the slice is pointed to the new array. For a better understanding, please refer to the coding example in this Go language lesson.

A brief walk through slice

A slice can be created in the following different ways:

1. With an empty slice using var keyword as follows: var aSlice []datatype.

2. With an array syntax without specifying the array size to declare a slice. For example, aSliceArray := []datatype {value1, value2, ..., valueN}.

3. By slicing an existing array to define a new slice. For example,
   anArray := [length]datatype {value1, value2, ..., valueN}
aSliceArray := anArray[i1:i2], i1, and i2 are the desired indices here.

4. With a slice using new keyword. For example, aSliceArray := new([capacity] datatype)[0:length].

5. By declaring a slice using the make() function. For example, aSliceArray := make([]datatype, length, capacity).

Note: For cases 3–5 above, values of length and capacity must be defined in the code at the time of declaration.

In the following code widget, lines 10–24 show different ways to create (declare or initialize) an int type slice. In addition, line 31 shows that slices of other types (e.g., string) can also be defined. The function reflect.ValueOf(var).Kind() in lines 32 and 40 returns the name of data type kind (slice). Functions len(var) and cap(var) in lines 32 and 41 return the length and the capacity of the sliceLength of a slice is the number of elements in a slice. Capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice.. The == operator can be used to determine whether a slice is nil or not (see lines 33–34). However, comparing two slices using the == operator will result in an error. (Please run the following code widget again after uncommenting line 36.)

After slice creation, different slice operations can be used to add, access, and change the slice elements. Following code widget shows the syntax for access and modification operations (lines 12–13) on an int slice. Lines 17–19 demonstrate the addition of new elements in a slice using the append() method. However, there's no built-in method in Go language for item removal from a slice for optimization reasons. This task is achieved by defining a function remove_element(intArray []int, index int) []int in lines 25–27 that intelligently uses a built-in append() method.

Wrapping up and next steps

In brief, Go is an ideal programming language to learn with so many attractive features. If you are interested in exploring further resources, please refer to the following courses and don't forget to share your feedback and opinions with us!