Resources
21. Slices
A window into an array!
Slice Type
Array size is fixed in Go. We can not add more elements to an existing array. This is limiting from a programmer's point of view. Go provides slices to address this concern.
Slices in Go can grow. Arrays are fixed length sequence where as slices are variable length sequence in Go. Slices are very lightweight data structures.A slice has three components: a pointer, a length, and a capacity.
Declaring slice
While declaring slice, we need to specify type of element slice will hold with empty pair of
[].[]T defines a slice of type T.main.go
1
func printSlice(s []string) {
2
fmt.Printf("size: %v, capacity:%v,value:%v\n",
3
len(s), cap(s), s)
4
}
5
func main() {
6
// declaring slice
7
var names []string
8
printSlice(names)
9
//output size: 0, capacity:0,value:[]
10
}
Copied!
While declaring an array, we need to specify size while slice declaration has empty size.
a is an array below while s is a slice.main.go
1
var a [5]int
2
var s []int
Copied!
Creating slice
Declaring slice using var does not allocate backing array for slice. Instead, we have to create slice using
make function. Make function accepts 3 parameters, first is type of slice, second is length of slice to create and optionally third parameter as capacity of slice.s := make([]T,length,capacity) main.go
1
names = make([]string, 5)
2
printSlice(names)
3
// output : size: 5, capacity:5, value:[ ]
Copied!
If we know in advance, what capacity we need for slice, we can make slice with that capacity.
main.go
1
names = make([]string, 5, 20)
2
printSlice(names)
3
// output : size: 5, capacity:20, value:[ ]
Copied!
Accessing slice elements
Since slice is window into an array, its elements can be accessed by using square brackets
[] with an index that begins at 0 similar to array access.main.go
1
greetings := make([]string, 2)
2
greetings[0] = "Hello"
3
greetings[1] = "World"
4
printSlice(greetings)
5
// output: size: 2, capacity:2, value:[Hello World]
Copied!
Zero values
When new slice is created using
make all its elements get initialized to its zero values.main.go
1
numbers := make([]float64, 8)
2
months := make([]string, 12)
3
fmt.Println(numbers)
4
fmt.Println(months)
5
// output :
6
// numbers => [0 0 0 0 0 0 0 0]
7
// months => [ ]
Copied!
Slice literals
If we know in advance what values a slice will start with, we can initialize the slice with those values using slice literal. We do not need to
make function call when using slice literals.[]T{values}main.go
1
data := []string{
2
"Hello",
3
"World!",
4
}
5
printSlice(data)
6
//out size: 2, capacity:2, value:[Hello World!]
Copied!
Slice from an existing array
We can create slice from an existing array. To create slice from existing array, we need to specify start index and end index using syntax
array[startIndex:endIndex]If starting index is zero, it can be skipped. If end index equals length of array, it can be skipped.
main.go
1
days := [7]string{"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"}
2
weekdays := days[0:5]
3
// if first element of slice is same as first
4
//element of array, start index can be skipped
5
weekdays = days[:5]
6
printSlice(weekdays)
7
8
weekend := days[5:7]
9
// if last element of slice is same as last
10
// element of array, end index can be skipped
11
weekend = days[5:]
12
printSlice(weekend)
13
14
alldays := days[0:7]
15
// if slice has all array elements, both start
16
// index and end index can be skipped
17
alldays = days[:]
18
printSlice(alldays)
Copied!
Nil and empty slice
Go has both nil and empty slices. When we use var declaration, it initializes nil slice provided we do not use slice literal. If we use short variable declaration and create slice using make, it initializes empty slice. In case of nil slice, no backing array is created, while for empty slice backing array is present.
use
len(s) == 0, and not s == nilfor checking for empty slice.main.go
1
// empty and nil slices
2
s := make([]string, 3)[3:]
3
var e []string
4
printSlice(s)
5
printSlice(e)
6
7
fmt.Println("Is s nil => ", s == nil)
8
fmt.Println("Is e nil => ", e == nil)
Copied!
Iterating over slice
Iteration over slice is similar to array iteration. Preferred way is to
for...rangemain.go
1
// iterating over slices
2
for _, day := range alldays {
3
fmt.Println(day)
4
}
Copied!
Type of slice and comparison
Unlike array, slice types are defined what type of data slice store. Comparison is not possible using
== unlike arrays. For most use cases where comparison needs to be done, we need to write our own comparison codemain.go
1
func testEquality(a, b []string) bool {
2
if len(a) != len(b) {
3
return false
4
}
5
for i := range a {
6
if a[i] != b[i] {
7
return false
8
}
9
}
10
return true
11
}
Copied!
Append
The advantage slices have over arrays is the fact that slices can increase capacity and hold more elements at run-time. To add elements to slice, we use built in
append function.append can be used to add one or more elements to slice. Append operation may create new slice if new elements to add do not fit in existing capacity of slice. Whenever we do append operation, we reassigned the returned slice to original slice. Returned slice may or may not be new slice.
s := append(s, e)main.go
1
s := make([]string, 0)
2
// appending elements
3
s = append(s, "a")
4
printSlice(s)
5
s = append(s, "e")
6
printSlice(s)
7
s = append(s, "i")
8
printSlice(s)
9
s = append(s, "o")
10
s = append(s, "u")
11
printSlice(s)
12
// output
13
// size: 1, capacity:1, value:[a]
14
// size: 2, capacity:2, value:[a e]
15
// size: 3, capacity:4, value:[a e i]
16
// size: 5, capacity:8, value:[a e i o u]
Copied!
GitHub Code
codewithgo-samples/main.go at master · gophersumit/codewithgo-samples
GitHub
learn-go-with-tests/arrays-and-slices.md at master · quii/learn-go-with-tests
GitHub
Blog Posts
Go Slices: usage and internals - go.dev
Understanding Slices in Go Programming
Slices of Slices of Slices in Go
Iterating Over Slices In Go
SliceTricks · golang/go Wiki
GitHub
Videos
Last modified 2yr ago