如何在Golang中过滤切片

Go过滤切片教程展示了如何在Golang中过滤切片。

过滤操作处理一个数据结构（例如数组）并生成一个新的数据结构，该数据结构恰好包含给定谓词返回true的那些元素。

谓词是一个返回布尔值的单参数函数。

$ go version
go version go1.18.1 linux/amd64

我们使用Go版本1.18。

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)
}

我们有一个整数片段。我们从仅具有正值的现有切片创建一个新切片。

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

我们使用for循环遍历数组的元素。我们测试每个元素是否大于零。所有满足条件的元素都被复制到新的positive切片中。原始切片没有被修改。

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

就地过滤切片

在下面的示例中，切片在过滤操作期间被修改。

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
    }
}

该示例修改了vals切片以仅包含正值。没有创建新切片。

根据字符串长度过滤切片

在下面的示例中，我们按字符串长度进行过滤。

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)
}

在过滤操作中，我们只包括具有三个字符的单词。

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

过滤结构切片

在下面的例子中，我们过滤了一片结构。

package main

import "fmt"

type User struct {
    name       string
    occupation string
    country    string
}

func main() {

    users := []User{

        {"John Doe", "gardener", "USA"},
        {"Roger Roe", "driver", "UK"},
        {"Paul Smith", "programmer", "Canada"},
        {"Lucia Mala", "teacher", "Slovakia"},
        {"Patrick Connor", "shopkeeper", "USA"},
        {"Tim Welson", "programmer", "Canada"},
        {"Tomas Smutny", "programmer", "Slovakia"},
    }

    var programmers []User

    for _, user := range users {

        if isProgrammer(user) {
            programmers = append(programmers, user)
        }
    }

    fmt.Println("Programmers:")
    for _, u := range programmers {

        fmt.Println(u)
    }
}

func isProgrammer(user User) bool {

    return user.occupation == "programmer"
}

我们有一部分用户。我们创建一个仅包含程序员的新切片。

for _, user := range users {

    if isProgrammer(user) {
        programmers = append(programmers, user)
    }
}

我们遍历users切片，仅当用户满足isProgrammer谓词时，才将当前用户添加到programmers切片。

func isProgrammer(user User) bool {

    return user.occupation == "programmer"
}

对于occupation字段等于“程序员”的所有用户，IsProgrammer谓词返回true。

$ go run filter_slice_structs.go
Programmers:
{Paul Smith programmer Canada}
{Tim Welson programmer Canada}
{Tomas Smutny programmer Slovakia}

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
}

我们有一段话。我们按字符串前缀和字符串长度过滤切片。

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

在本教程中，我们在Go中过滤了切片。

列出所有Go教程。