entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://golang.org/pkg/sort/#Search|blocks|key|4m43o|text|如果对切片进行了排序，则在中实现二进制搜索the+sort+package|unstyled|depth|inlineStyleRanges|offset|length|style|UNDERLINE|CODE|entityRanges^0|L|G|P|4|L|G|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|N|G|@$H|O|I|P|J|K]|$H|Q|I|R|J|L]]|M|@$H|S|I|T|A|U]]|6|$]]]]

If the slice is sorted, there is a binary search implemented in <a href="http://golang.org/pkg/sort/#Search" rel="noreferrer">the <code>sort</code> package</a>.

entityMap|blocks|key|35fhe|text|不，这样的方法不存在，但写起来很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ecpml|func+contains(s+[]int,+e+int)+bool+{
++++for+_,+a+:=+range+s+{
++++++++if+a+==+e+{
++++++++++++return+true
++++++++}
++++}
++++return+false
}|code-block|syntax|javascript|435eb|如果查找是代码的重要部分，则可以使用映射，但映射也有成本。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

No, such method does not exist, but is trivial to write:

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

You can use a map if that lookup is an important part of your code, but maps have cost too.

entityMap|blocks|key|1r5be|text|Mostafa已经指出，这样的方法编写起来很简单，mkb给了您一个提示，让您使用排序包中的二进制搜索。但是，如果您要执行大量此类包含检查，则还可以考虑使用map。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|vh7t|方法来检查特定的映射键是否存在是很容易的。value,+ok+:=+yourmap[key]习语。由于您对值不感兴趣，因此还可以创建一个map[string]struct{}例如。使用空的struct{}这里的优点是它不需要任何额外的空间，并且Go的内部映射类型针对这种值进行了优化。因此，map[string]+struct{}是围棋世界中流行的棋盘选择。|offset|length|style|CODE^0|0|L|P|1W|J|2M|8|41|K^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|J|9|@$E|K|F|L|G|H]|$E|M|F|N|G|H]|$E|O|F|P|G|H]|$E|Q|F|R|G|H]]|A|@]|B|$]]]]

Mostafa has already <a href="https://stackoverflow.com/a/10485970/">pointed out</a> that such a method is trivial to write, and mkb gave you a hint to use the binary search from the sort package. But if you are going to do a lot of such contains checks, you might also consider using a map instead.
It's trivial to check if a specific map key exists by using the <code>value, ok := yourmap[key]</code> idiom. Since you aren't interested in the value, you might also create a <code>map[string]struct{}</code> for example. Using an empty <code>struct{}</code> here has the advantage that it doesn't require any additional space and Go's internal map type is optimized for that kind of values. Therefore, <code>map[string] struct{}</code> is a popular choice for sets in the Go world.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://play.golang.org/p/CEG6cu4JTf|blocks|key|20avc|text|而不是使用slice,+map可能是一个更好的解决方案。|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|asocb|简单的例子：|6u8km|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))

}|code-block|syntax|javascript|1chm1|UNDERLINE^0|5|5|C|3|0|0|0|0|Z|0|Z|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|V|G|@$H|W|I|X|J|K]|$H|Y|I|Z|J|K]]|L|@]|6|$]]|$A|M|C|N|2|E|F|10|G|@]|L|@]|6|$]]|$A|O|C|P|2|Q|F|11|G|@]|L|@]|6|$R|S]]|$A|T|C|8|2|E|F|12|G|@$H|13|I|14|J|U]]|L|@$H|15|I|16|A|17]]|6|$]]]]

Instead of using a <code>slice</code>, <code>map</code> may be a better solution.

simple example:

<pre><code>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))

}
</code></pre>

<a href="http://play.golang.org/p/CEG6cu4JTf" rel="noreferrer">http://play.golang.org/p/CEG6cu4JTf</a>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://play.golang.org/p/jL5UD7yCNq|blocks|key|40asu|text|您可以使用反思包以迭代其具体类型为切片的接口：|unstyled|depth|inlineStyleRanges|entityRanges|c09ej|func+HasElem(s+interface{},+elem+interface{})+bool+{
++++arrV+:=+reflect.ValueOf(s)

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

++++++++++++//+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
}|code-block|syntax|javascript|7unq2|offset|length|style|UNDERLINE^0|0|0|0|10|0|10|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|S|G|@]|H|@]|6|$]]|$A|I|C|J|2|K|F|T|G|@]|H|@]|6|$L|M]]|$A|N|C|8|2|E|F|U|G|@$O|V|P|W|Q|R]]|H|@$O|X|P|Y|A|Z]]|6|$]]]]

You can use the reflect package to iterate over an interface whose concrete type is a slice:

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

 if arrV.Kind() == reflect.Slice {
 for i := 0; i &lt; 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
}
</code></pre>

<a href="https://play.golang.org/p/jL5UD7yCNq" rel="nofollow noreferrer">https://play.golang.org/p/jL5UD7yCNq</a>

entityMap|blocks|key|4a89r|text|不确定这里是否需要泛型。你只需要为你想要的行为签订一份合同。如果您希望自己的对象在集合中表现自己，那么执行以下操作只不过是在其他语言中必须执行的操作，例如，通过重写Equals()和GetHashCode()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56hdm|type+Identifiable+interface{
++++GetIdentity()+string
}

func+IsIdentical(this+Identifiable,+that+Identifiable)+bool{
++++return+(&this+==+&that)+%7C%7C+(this.GetIdentity()+==+that.GetIdentity())
}

func+contains(s+[]Identifiable,+e+Identifiable)+bool+{
++++for+_,+a+:=+range+s+{
++++++++if+IsIdentical(a,e)+{
++++++++++++return+true
++++++++}
++++}
++++return+false
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Not sure generics are needed here. You just need a contract for your desired behavior. Doing the following is no more than what you would have to do in other languages if you wanted your own objects to behave themselves in collections, by overriding Equals() and GetHashCode() for instance.

<pre><code>type Identifiable interface{
 GetIdentity() string
}

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

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

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/awalterschulze/goderive|blocks|key|2fpl5|text|如果使用map根据键查找项是不可行的，可以考虑使用goderive工具。Goderive生成一个包含方法的特定类型的实现，使您的代码既可读又高效。|unstyled|depth|inlineStyleRanges|offset|length|style|UNDERLINE|entityRanges|cpq6c|示例；|d8tka|type+Foo+struct+{
++++Field1+string
++++Field2+int
}+

func+Test(m+Foo)+bool+{
+++++var+allItems+[]Foo
+++++return+deriveContainsFoo(allItems,+m)
}|code-block|syntax|javascript|1gte7|要生成deriveContainsFoo方法，请执行以下操作：|16nrn|使用安装goderive派生go+get+-u+github.com/awalterschulze/goderive|unordered-list-item|CODE|9fakn|运行goderive+./...在您的工作区文件夹中|bu0jl|将为deriveContains生成此方法：|dljhn|func+deriveContainsFoo(list+[]Foo,+item+Foo)+bool+{
++++for+_,+v+:=+range+list+{
++++++++if+v+==+item+{
++++++++++++return+true
++++++++}
++++}
++++return+false
}|a77hm|Goderive还支持其他一些有用的辅助方法，以便在go中应用函数式编程风格。^0|P|8|P|8|0|0|0|0|0|E|18|0|2|E|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|17|G|@$H|18|I|19|J|K]]|L|@$H|1A|I|1B|A|1C]]|6|$]]|$A|M|C|N|2|E|F|1D|G|@]|L|@]|6|$]]|$A|O|C|P|2|Q|F|1E|G|@]|L|@]|6|$R|S]]|$A|T|C|U|2|E|F|1F|G|@]|L|@]|6|$]]|$A|V|C|W|2|X|F|1G|G|@$H|1H|I|1I|J|Y]]|L|@]|6|$]]|$A|Z|C|10|2|X|F|1J|G|@$H|1K|I|1L|J|Y]]|L|@]|6|$]]|$A|11|C|12|2|E|F|1M|G|@]|L|@]|6|$]]|$A|13|C|14|2|Q|F|1N|G|@]|L|@]|6|$R|S]]|$A|15|C|16|2|E|F|1O|G|@]|L|@]|6|$]]]]

If it is not feasable to use a map for finding items based on a key, you can consider the <a href="https://github.com/awalterschulze/goderive" rel="nofollow noreferrer">goderive</a> tool. Goderive generates a type specific implementation of a contains method, making your code both readable and efficient. 

Example;

<pre><code>type Foo struct {
 Field1 string
 Field2 int
} 

func Test(m Foo) bool {
 var allItems []Foo
 return deriveContainsFoo(allItems, m)
}
</code></pre>

To generate the deriveContainsFoo method:

<ul>
<li>Install goderive with <code>go get -u github.com/awalterschulze/goderive</code></li>
<li>Run <code>goderive ./...</code> in your workspace folder</li>
</ul>

This method will be generated for deriveContains:

<pre><code>func deriveContainsFoo(list []Foo, item Foo) bool {
 for _, v := range list {
 if v == item {
 return true
 }
 }
 return false
}
</code></pre>

Goderive has support for quite some other useful helper methods to apply a functional programming style in go.

entityMap|blocks|key|1b6pf|text|func+Contain(target+interface{},+list+interface{})+(bool,+int)+{
++++if+reflect.TypeOf(list).Kind()+==+reflect.Slice+%7C%7C+reflect.TypeOf(list).Kind()+==+reflect.Array+{
++++++++listvalue+:=+reflect.ValueOf(list)
++++++++for+i+:=+0;+i+<+listvalue.Len();+i%2B%2B+{
++++++++++++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
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>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 &lt; listvalue.Len(); i++ {
 if target == listvalue.Index(i).Interface() {
 return true, i
 }
 }
 }
 if reflect.TypeOf(target).Kind() == reflect.String &amp;&amp; reflect.TypeOf(list).Kind() == reflect.String {
 return strings.Contains(list.(string), target.(string)), strings.Index(list.(string), target.(string))
 }
 return false, -1
}
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://golang.org/pkg/sort/|blocks|key|akf0j|text|The+sort排序如果您的切片已排序或您希望对其进行排序，package将提供构建块。|unstyled|depth|inlineStyleRanges|offset|length|style|UNDERLINE|entityRanges|bets5|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
}|code-block|syntax|javascript|4f0c5|SearchString承诺会回来the+index+to+insert+x+if+x+is+not+present+(it+could+be+len(a))，所以检查它会显示字符串是否包含排序后的切片。|CODE^0|4|4|4|4|0|0|0|0|C|H|1Q^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|U|G|@$H|V|I|W|J|K]]|L|@$H|X|I|Y|A|Z]]|6|$]]|$A|M|C|N|2|O|F|10|G|@]|L|@]|6|$P|Q]]|$A|R|C|S|2|E|F|11|G|@$H|12|I|13|J|T]|$H|14|I|15|J|T]]|L|@]|6|$]]]]

The <a href="https://golang.org/pkg/sort/" rel="noreferrer">sort</a> package provides the building blocks if your slice is sorted or you are willing to sort it.

<pre><code>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 &lt; len(s) &amp;&amp; s[i] == searchterm
}
</code></pre>

<code>SearchString</code> promises to return <code>the index to insert x if x is not present (it could be len(a))</code>, so a check of that reveals whether the string is contained the sorted slice.

entityMap|blocks|key|dng91|text|go风格：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|db8va|func+Contains(n+int,+match+func(i+int)+bool)+bool+{
++++for+i+:=+0;+i+<+n;+i%2B%2B+{
++++++++if+match(i)+{
++++++++++++return+true
++++++++}
++++}
++++return+false
}


s+:=+[]string{"a",+"b",+"c",+"o"}
//+test+if+s+contains+"o"
ok+:=+Contains(len(s),+func(i+int)+bool+{
++++return+s[i]+==+"o"
})|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

The go style:

<pre><code>func Contains(n int, match func(i int) bool) bool {
 for i := 0; i &lt; n; i++ {
 if match(i) {
 return true
 }
 }
 return false
}


s := []string{"a", "b", "c", "o"}
// test if s contains "o"
ok := Contains(len(s), func(i int) bool {
 return s[i] == "o"
})
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://gist.github.com/NorbertFenk/7bed6760198800207e84f141c41d93c7|blocks|key|83v0c|text|我用这些答案中的解决方案创建了一个非常简单的基准。|unstyled|depth|inlineStyleRanges|entityRanges|e6fii|offset|length|style|UNDERLINE|chf04|这不是一个真正的基准测试，因为最初，我没有插入太多元素，但可以随意派生和更改它。^0|0|0|1W|0|1W|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|P|G|@]|H|@]|6|$]]|$A|I|C|8|2|E|F|Q|G|@$J|R|K|S|L|M]]|H|@$J|T|K|U|A|V]]|6|$]]|$A|N|C|O|2|E|F|W|G|@]|H|@]|6|$]]]]

I created a very simple benchmark with the solutions from these answers.

<a href="https://gist.github.com/NorbertFenk/7bed6760198800207e84f141c41d93c7" rel="nofollow noreferrer">https://gist.github.com/NorbertFenk/7bed6760198800207e84f141c41d93c7</a>

It isn't a real benchmark because initially, I haven't inserted too many elements but feel free to fork and change it.

entityMap|blocks|key|7i3ov|text|这可能会被认为有点“老生常谈”，但根据切片的大小和内容，您可以将切片连接在一起并进行字符串搜索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|esugu|例如，你有一个包含单个单词值的切片(例如"yes"，"no"，"maybe")。这些结果被附加到切片上。如果你想检查这个切片是否包含任何“可能”的结果，你可以使用|eqrp3|exSlice+:=+["yes",+"no",+"yes",+"maybe"]
if+strings.Contains(strings.Join(exSlice,+","),+"maybe")+{
++fmt.Println("We+have+a+maybe!")
}|code-block|syntax|javascript|cn8e7|这是否合适实际上取决于切片的大小和其成员的长度。对于大片或长值，可能存在性能或适用性问题，但对于有限大小和简单值的较小片，它是实现所需结果的有效一行程序。^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|N|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|O|9|@]|A|@]|B|$]]]]

It might be considered a bit 'hacky' but depending the size and contents of the slice, you can join the slice together and do a string search.

For example you have a slice containing single word values (e.g. "yes", "no", "maybe"). These results are appended to a slice. If you want to check if this slice contains any "maybe" results, you may use

<pre><code>exSlice := ["yes", "no", "yes", "maybe"]
if strings.Contains(strings.Join(exSlice, ","), "maybe") {
 fmt.Println("We have a maybe!")
}
</code></pre>

How suitable this is really depends on the size of the slice and length of its members. There may be performance or suitability issues for large slices or long values, but for smaller slices of finite size and simple values it is a valid one-liner to achieve the desired result.

entityMap|blocks|key|8deg7|text|我觉得地图Xbool比map更有用Xstruct{}。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|a1jpq|为不存在的项目对地图进行索引将返回false，因此_，ok+:=+mX，你可以直接说mX。|5r074|这使得在表达式中嵌套包含测试变得很容易。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

I think <code>map[x]bool</code> is more useful than <code>map[x]struct{}</code>.
Indexing the map for an item that isn't present will return <code>false</code>. so instead of <code>_, ok := m[X]</code>, you can just say <code>m[X]</code>.
This makes it easy to nest inclusion tests in expressions.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/glassonion1/xgo/blob/main/contains.go|blocks|key|d1513|text|我使用反射包创建了以下包含函数。此函数可用于各种类型，如int32或struct等。|unstyled|depth|inlineStyleRanges|entityRanges|68mj9|//+Contains+returns+true+if+an+element+is+present+in+a+slice
func+Contains(list+interface{},+elem+interface{})+bool+{
++++listV+:=+reflect.ValueOf(list)

++++if+listV.Kind()+==+reflect.Slice+{
++++++++for+i+:=+0;+i+<+listV.Len();+i%2B%2B+{
++++++++++++item+:=+listV.Index(i).Interface()

++++++++++++target+:=+reflect.ValueOf(elem).Convert(reflect.TypeOf(item)).Interface()
++++++++++++if+ok+:=+reflect.DeepEqual(item,+target);+ok+{
++++++++++++++++return+true
++++++++++++}
++++++++}
++++}
++++return+false
}|code-block|syntax|javascript|1tjvj|contains函数的用法如下|6l68h|//+slice+of+int32
containsInt32+:=+Contains([]int32{1,+2,+3,+4,+5},+3)
fmt.Println("contains+int32:",+containsInt32)

//+slice+of+float64
containsFloat64+:=+Contains([]float64{1.1,+2.2,+3.3,+4.4,+5.5},+4.4)
fmt.Println("contains+float64:",+containsFloat64)


//+slice+of+struct
type+item+struct+{
++++ID+++string
++++Name+string
}
list+:=+[]item{
++++item{
++++++++ID:+++"1",
++++++++Name:+"test1",
++++},
++++item{
++++++++ID:+++"2",
++++++++Name:+"test2",
++++},
++++item{
++++++++ID:+++"3",
++++++++Name:+"test3",
++++},
}
target+:=+item{
++++ID:+++"2",
++++Name:+"test2",
}
containsStruct+:=+Contains(list,+target)
fmt.Println("contains+struct:",+containsStruct)

//+Output:
//+contains+int32:+true
//+contains+float64:+true
//+contains+struct:+true|alf7o|有关更多详细信息，请参阅此处：|6mo42|offset|length|style|UNDERLINE^0|0|0|0|0|0|0|1K|0|1K|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|Y|G|@]|H|@]|6|$]]|$A|I|C|J|2|K|F|Z|G|@]|H|@]|6|$L|M]]|$A|N|C|O|2|E|F|10|G|@]|H|@]|6|$]]|$A|P|C|Q|2|K|F|11|G|@]|H|@]|6|$L|M]]|$A|R|C|S|2|E|F|12|G|@]|H|@]|6|$]]|$A|T|C|8|2|E|F|13|G|@$U|14|V|15|W|X]]|H|@$U|16|V|17|A|18]]|6|$]]]]

I created the following Contains function using reflect package.
This function can be used for various types like int32 or struct etc.
<pre class="lang-golang prettyprint-override"><code>// Contains returns true if an element is present in a slice
func Contains(list interface{}, elem interface{}) bool {
 listV := reflect.ValueOf(list)

 if listV.Kind() == reflect.Slice {
 for i := 0; i &lt; listV.Len(); i++ {
 item := listV.Index(i).Interface()

 target := reflect.ValueOf(elem).Convert(reflect.TypeOf(item)).Interface()
 if ok := reflect.DeepEqual(item, target); ok {
 return true
 }
 }
 }
 return false
}
</code></pre>
Usage of contains function is below
<pre class="lang-golang prettyprint-override"><code>// slice of int32
containsInt32 := Contains([]int32{1, 2, 3, 4, 5}, 3)
fmt.Println(&quot;contains int32:&quot;, containsInt32)

// slice of float64
containsFloat64 := Contains([]float64{1.1, 2.2, 3.3, 4.4, 5.5}, 4.4)
fmt.Println(&quot;contains float64:&quot;, containsFloat64)


// slice of struct
type item struct {
 ID string
 Name string
}
list := []item{
 item{
 ID: &quot;1&quot;,
 Name: &quot;test1&quot;,
 },
 item{
 ID: &quot;2&quot;,
 Name: &quot;test2&quot;,
 },
 item{
 ID: &quot;3&quot;,
 Name: &quot;test3&quot;,
 },
}
target := item{
 ID: &quot;2&quot;,
 Name: &quot;test2&quot;,
}
containsStruct := Contains(list, target)
fmt.Println(&quot;contains struct:&quot;, containsStruct)

// Output:
// contains int32: true
// contains float64: true
// contains struct: true
</code></pre>
Please see here for more details:
<a href="https://github.com/glassonion1/xgo/blob/main/contains.go" rel="nofollow noreferrer">https://github.com/glassonion1/xgo/blob/main/contains.go</a>

Is there anything similar to a <code>slice.contains(object)</code> method in Go without having to do a search through each element in a slice?

Contains method for a slice

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

问包含切片的方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问包含切片的方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问包含切片的方法
EN