排序包提供构建块，如果你的片已经排序或你愿意排序。

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承诺，如果x不存在，将返回插入x的索引(它可以是len(a))，因此检查它可以揭示字符串是否包含已排序的切片。

如果切片已排序，则排序包中实现了二进制搜索。

相比使用切片，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

从Go 1.18开始，你可以使用slices包——特别是泛型Contains函数: https://pkg.go.dev/golang.org/x/exp/slices。

go get golang.org/x/exp/slices

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

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

请注意，由于这是在标准库之外的一个实验包，所以它不绑定到Go 1兼容性承诺™，并且在正式添加到标准库之前可能会更改。

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

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

不确定这里是否需要泛型。你只需要为你想要的行为订立契约。如果您想让自己的对象在集合中表现自己，那么在其他语言中，通过重写Equals()和GetHashCode()，您必须做的事情不亚于下面所做的事情。

type Identifiable interface{
    GetIdentity() string
}

func IsIdentical(this Identifiable, that Identifiable) bool{
    return (&this == &that) || (this.GetIdentity() == that.GetIdentity())
}

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