Go Slice

Creating a slice (with and without make)

Similar to maps, there are two ways to create a slice:

1. Using the make function

   s := make([]int, 5)

2. Using a slice literal

   s := []int{1, 2, 3, 4, 5}

   • s: name of the slice
   • int: represents the data type of the slice. In this case, it can hold only the integer values
   • {1, 2, 3, 4, 5}: elements of the slice

The 5 in the first example is the initial length of the slice (named capacity in the documentation), but it doesn't mean that the slice won't be able to grow beyond that.

Retrieving and updating values in a slice

To retrieve a value from a slice, the syntax is exactly the same as for arrays:

package main

import "fmt"

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

Output

1
5

And the assignment operator can be used to update a value:

package main

import "fmt"

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

Output

10

Finding the length of a slice

We can use the built-in len() function to find the number of elements in a slice. For Example:

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    fmt.Println("The length of slice is:", len(s))

}

Output

The length of slice is: 5

Iterating over a slice

To iterate over a slice, we can use two kinds of loops:

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(s); i++ {
        fmt.Println(s[i])
    }
}

Using for range to iterate over a slice

We can also use for range to loop through elements of slice in Golang. For example:

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    for i, v := range s {
        fmt.Println(i, v)
    }
}

The first one is closer to the syntax of C and Java, whereas the second one is more idiomatic in Go.

Appending values to a slice

To append a value to a slice and to grow the slice if necessary, we can use the append function:

package main

import "fmt"

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

[1 2 3 4 5 6]

Each time the slice grows, the capacity of the slice doubles.

Example

Let's implement the first use case mentioned above: the list of prime numbers below a given number.

package main

import "fmt"

func getPrimes(n int) []int {
    primes := []int{}
    for i := 2; i <= n; i++ {
        if isPrime(i) {
            primes = append(primes, i)
        }
    }
    return primes
}

func main() {
    fmt.Println(getPrimes(10))  // [2 3 5 7]
    fmt.Println(getPrimes(100))
}

There are plenty of ways to write the isPrime function, but here is one possible implementation:

func isPrime(n int) bool {
    if n < 2 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}