Slices in GoLang

Slices are resizable arrays that provide huge flexibility when working with it. In this post, we will see how to use slices in GoLang.

Declaration of a slice

A slice is declared just like an array but without mentioning its size.

package main

func main() {
	var aslice []string     // a string slice
}

Difference between slices and arrays

Arrays, after declared of some size, cannot be resized, whereas slices can be resized. Slices are reference-types while arrays are value-type.

Creating slices in GoLang

Noe, we will see how we can create slices for our usage. There are quite a few ways we can create a slice.

1. Using slice literal syntax

Slice literal is the initialization syntax of a slice. Below is an example of using slice literal syntax to create a slice.

package main

import "fmt"

func main() {
	var stringSlice = []string{"This", "is", "a", "string", "slice"}
	fmt.Println(stringSlice)  // prints [This is a string slice]
}

2. Creating slices from an array

A slice has a reference to an array. So, it’s not difficult to create them from arrays. Here is how to do that.

array[lowerIndex:higherIndex]

Element high is excluded here.

package main

import "fmt"

func main() {
	var arr = [4]int{1, 2, 3, 4}
	var arrSlice = arr[1:3]
	
	fmt.Println(arrSlice)   //prints [2 3]
}

3. Creating slices from another slice

Slices can be created from other slices by taking a slice of that slice.

package main

import "fmt"

func main() {
	var odds =  [8]int{1, 3, 5, 7, 9, 11, 13, 15}
	slice1 := odds[2:]
	fmt.Println(slice1)     // prints [5 7 9 11 13 15]
	slice2 := slice1[2:4]
	fmt.Println(slice2)     // prints [9 11]
}

4. Creating slices using make() function

There is a function in Go called make(), which can be used to create slices as well. Which takes in type of slice, length, and capacity of that slice.

package main

import "fmt"

func main() {
	s := make([]int, 5) // make an int slice of length 5
	fmt.Println(s) // [0 0 0 0 0]
}

The len() and cap() functions

The len() and cap() functions provide the length and capacity of a slice. To understand the difference between both, let’s see an example.

package main

import "fmt"

func main() {
	s := []int{2, 4, 6, 8, 10}
	fmt.Println(len(s), cap(s))     // 5 5
	arr := [6]int{1, 2, 3, 4, 5, 6}
	arrSlice := arr[2:4]
	fmt.Println(len(arrSlice), cap(arrSlice))  // 2 4
}

Zero-valued slices

The zero-valued slice is nil. That means its length and capacity is zero. Here is an example showing it.

package main

import "fmt"

func main() {
	s := []int{}
	fmt.Println(len(s), cap(s))
}

Modifying values in slices

The modification of values inside slices is really simple. All we need to do is just assign data in that index or slice. Here is an example illustrating the ways it can be done.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4}
	s[1] = 0
	fmt.Println(s)   // [1 0 3 4]
}

Removing values from slices

To remove value at index i in a slice we can simply append elements up to index i and from i+1 to the end. This is what it looks like.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5, 6, 7, 8}
	//v := []int{}
	_ = append(s[:3], s[4:]...)    // remove 3rd elem
	fmt.Println(s)
}

Passing slice to a function

When a slice is passed to a function and made changes inside it, the changes will be available outside as well. The reason behind this is that the slice is a reference type.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5, 6, 7, 8}
	PrintSlice(s)    // [1 2 3 4 5 6 7 8]
}

func PrintSlice(a []int) {
	fmt.Println(a)
}

Slice functions

There are slice functions that make using slice even easier. Here are some important ones.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5, 6, 7, 8}
	var s2 = make([]int, 5)
	
	// append function
	s = append(s, 9, 10)
	
	fmt.Println(s)   // [1 2 3 4 5 6 7 8 9 10]
	
	// copy function
	ne := copy(s2, s) // returns number of elements copied
	fmt.Println(s2, ne)  // [1 2 3 4 5] 5
}

Slice of slices

We can create a slice of slices which is essentially a multidimensional slice.

package main

import "fmt"

func main() {
	mds := [][]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 8},     // mandatory last comma
	}
	
	fmt.Println(mds)    // [[1 2 3] [4 5 6] [7 8 8]]
}

Iterating over a slice elements

Iteration over a slice can be done using a for-range loop. We can use simple for loop along with len function also. Here is how to do that.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	
	for i, v := range s {
		fmt.Println(i, v)
	}
	
	// output: 
	// 0 1
	// 1 2
	// 2 3
	// 3 4
	// 4 5
	// 5 6
	// 6 7
	// 7 8
	// 8 9
}

This is how we can use slices in Go.