ZetCode

Go filter slice

last modified February 26, 2021

Go filter slice tutorial shows how to filter a slice in Golang.

A filtering operation processes a data structure (e.g. an array) and produces a new data structure containing exactly those elements for which the given predicate returns true.

A predicate is a single-argument function which returns a boolean value.

Go filter slice example

In the following example, we filter out positive values.

positive.go
package main

import (
    "fmt"
)

func main() {

    vals := []int{-2, 0, 1, 9, 7, -3, -5, 6}
    positive := []int{}

    for i := range vals {
        if vals[i] > 0 {
            positive = append(positive, vals[i])
        }
    }

    fmt.Println(positive)
}

We have a slice of integers. We create a new slice from the existing one having only its positive values.

for i := range vals {
    if vals[i] > 0 {
        positive = append(positive, vals[i])
    }
}

We go over the elements of the array with a for loop. We test each element if it is greater than zero. All the elements that satisfy the condition are copied to the new positive slice. The original slice is not modified.

$ go run simple.go 
[1 9 7 6]

Go filter slice in-place

In the following example, the slice is modified during the filtering operation.

positive.go
package main

import (
    "fmt"
)

func main() {

    vals := []int{-2, 0, 1, 9, 7, -3, -5, 6}

    n := 0
    for _, val := range vals {
        if isPositive(val) {
            vals[n] = val
            n++
        }
    }

    vals = vals[:n]
    fmt.Println(vals)
}

func isPositive(val int) bool {
    if val > 0 {
        return true
    } else {

        return false
    }
}

The example modifies the vals slice to include only positive values. No new slice is created.

Go filter slice by string length

In the following example, we filter by the string length.

fil_strlen.go
package main

import (
    "fmt"
)

func main() {

    words := []string{"sky", "forest", "fly", "cup", "wood",
        "falcon", "so", "see", "tool"}
    filtered := []string{}

    for i := range words {
        if len(words[i]) == 3 {
            filtered = append(filtered, words[i])
        }
    }

    fmt.Println(filtered)
}

In the filtering operation we only include words that have three characters.

$ go run fil_strlen.go 
[sky fly cup see]

Go filter slice generic example

The next example has a bit more generic filtering function.

generic.go
package main

import (
    "fmt"
    "strings"
)

func main() {

    words := []string{"sky", "forest", "fly", "cup", "wood",
        "falcon", "so", "see", "tool"}

    filtered := Filter(words, func(word string) bool {
        return strings.HasPrefix(word, "s")
    })

    fmt.Println(filtered)

    filtered2 := Filter(words, func(word string) bool {
        return len(word) == 3
    })

    fmt.Println(filtered2)
}

func Filter(vs []string, f func(string) bool) []string {
    filtered := make([]string, 0)
    for _, v := range vs {
        if f(v) {
            filtered = append(filtered, v)
        }
    }
    return filtered
}

We have a slice of words. We filter the slice by string preffix and by string length.

$ go run fil_strlen2.go 
[sky so see]
[sky fly cup see]

In this tutorial, we have filtered slices in Go.

List all Go tutorials.