包含切片的方法

Question

是否有类似slice.contains(object)Go中的方法而不必搜索切片中的每个元素？

Answer 1

从 Go 1.21 开始，您可以使用从前面提到的实验包升级的stdlibslices包。

\n

import  "slices"\n\nthings := []string{"foo", "bar", "baz"}\nslices.Contains(things, "foo") // true\n

\n\n

原答案：

\n

从 Go 1.18 开始，您可以使用slices包 \xe2\x80\x93 特别是通用Contains函数：\n https://pkg.go.dev/golang.org/x/exp/slices#Contains。

\n

go get golang.org/x/exp/slices\n

\n

import  "golang.org/x/exp/slices"\n

\n

things := []string{"foo", "bar", "baz"}\nslices.Contains(things, "foo") // true\n

\n

请注意，由于这是一个实验包，位于 stdlib 之外，因此它不受 Go 1 兼容性 Promise\xe2\x84\xa2 的约束，并且在正式添加到 stdlib 之前可能会发生变化。

\n

Answer 2

Mostafa已经指出这样的方法写起来很简单,而mkb给你一个提示,可以使用sort包中的二进制搜索.但是如果你打算做很多这样的包含检查,你也可以考虑使用地图.

通过使用value, ok := yourmap[key]成语来检查特定的地图密钥是否存在是微不足道的.由于您对该值不感兴趣,因此您也可以创建一个map[string]struct{}例如.struct{}在这里使用空的优点是它不需要任何额外的空间,并且Go的内部地图类型针对这种值进行了优化.因此,map[string] struct{}在Go世界中,套装是一种流行的选择.

Answer 3

不,这种方法不存在,但写起来很简单:

func contains(s []int, e int) bool {
    for _, a := range s {
        if a == e {
            return true
        }
    }
    return false
}

如果该查找是代码的重要部分,则可以使用地图,但地图也需要花费.

Answer 4

在 Go 1.18+ 中，我们可以使用泛型。

func Contains[T comparable](s []T, e T) bool {
    for _, v := range s {
        if v == e {
            return true
        }
    }
    return false
}

Answer 5

该排序包提供了构建块，如果你的片进行排序，或者您愿意排序。

input := []string{"bird", "apple", "ocean", "fork", "anchor"}
sort.Strings(input)

fmt.Println(contains(input, "apple")) // true
fmt.Println(contains(input, "grow"))  // false

...

func contains(s []string, searchterm string) bool {
    i := sort.SearchStrings(s, searchterm)
    return i < len(s) && s[i] == searchterm
}

SearchString承诺 return the index to insert x if x is not present (it could be len(a))，因此检查它会显示字符串是否包含已排序的切片。

Answer 6

如果切片进行排序,则在执行二进制搜索的sort包.

Answer 7

而不是使用slice,map可能是一个更好的解决方案.

简单的例子:

package main

import "fmt"


func contains(slice []string, item string) bool {
    set := make(map[string]struct{}, len(slice))
    for _, s := range slice {
        set[s] = struct{}{}
    }

    _, ok := set[item] 
    return ok
}

func main() {

    s := []string{"a", "b"}
    s1 := "a"
    fmt.Println(contains(s, s1))

}

http://play.golang.org/p/CEG6cu4JTf

Answer 8

func Contain(target interface{}, list interface{}) (bool, int) {
    if reflect.TypeOf(list).Kind() == reflect.Slice || reflect.TypeOf(list).Kind() == reflect.Array {
        listvalue := reflect.ValueOf(list)
        for i := 0; i < listvalue.Len(); i++ {
            if target == listvalue.Index(i).Interface() {
                return true, i
            }
        }
    }
    if reflect.TypeOf(target).Kind() == reflect.String && reflect.TypeOf(list).Kind() == reflect.String {
        return strings.Contains(list.(string), target.(string)), strings.Index(list.(string), target.(string))
    }
    return false, -1
}

Answer 9

我认为map[x]bool比 更有用map[x]struct{}。

为地图中不存在的项目建立索引将返回false。所以_, ok := m[X]你可以直接说m[X].

这使得在表达式中嵌套包含测试变得容易。

Answer 10

您可以使用Reflect包来迭代具体类型为切片的接口：

func HasElem(s interface{}, elem interface{}) bool {
    arrV := reflect.ValueOf(s)

    if arrV.Kind() == reflect.Slice {
        for i := 0; i < arrV.Len(); i++ {

            // XXX - panics if slice element points to an unexported struct field
            // see https://golang.org/pkg/reflect/#Value.Interface
            if arrV.Index(i).Interface() == elem {
                return true
            }
        }
    }

    return false
}

https://play.golang.org/p/jL5UD7yCNq