How to check if a slice contains an element in Go

1slices.Contains (Go 1.21+)Recommended

slices.Contains(s, v) walks the slice and reports whether any element == v. It's generic, so the same call works for strings, ints, floats — any comparable element type — and it reads exactly like what it does. This is the idiomatic form in any codebase on Go 1.21 or newer.

package main

import (
	"fmt"
	"slices"
)

func main() {
	fruits := []string{"apple", "banana", "cherry"}

	fmt.Println(slices.Contains(fruits, "banana"))
	fmt.Println(slices.Contains(fruits, "mango"))

	primes := []int{2, 3, 5, 7, 11}
	if slices.Contains(primes, 7) {
		fmt.Println("7 is prime")
	}
}

Prints true, false, then 7 is prime. Calling it on a nil or empty slice is safe and simply returns false — no guard needed. One near-namesake to not confuse it with: strings.Contains checks for a substring inside one string, not membership in a slice.

2The classic loop (any Go version)

Before Go 1.21 this loop was the answer, and it's still what slices.Contains does under the hood: range the slice, compare, return early on a hit. You'll see a helper like this in virtually every pre-generics codebase — often once per element type, which is exactly the boilerplate the slices package erased.

package main

import "fmt"

func contains(items []string, target string) bool {
	for _, v := range items {
		if v == target {
			return true
		}
	}
	return false
}

func main() {
	fruits := []string{"apple", "banana", "cherry"}
	fmt.Println(contains(fruits, "banana"))
	fmt.Println(contains(fruits, "mango"))
}

Prints true then false. The early return true matters: on average you scan half the slice for a hit, all of it for a miss — the same O(n) cost slices.Contains has. Inline the loop where it's used once; extract the helper when you check membership in more than one place.

3Custom matches with slices.ContainsFunc

== is often the wrong test: you want "equal ignoring case", or "any struct whose field matches". slices.ContainsFunc(s, f) takes a predicate and reports whether it returns true for any element — the escape hatch for every comparison slices.Contains can't express.

package main

import (
	"fmt"
	"slices"
	"strings"
)

type User struct {
	Name string
	Age  int
}

func main() {
	langs := []string{"Go", "Python", "Rust"}

	// Case-insensitive membership: compare with strings.EqualFold
	found := slices.ContainsFunc(langs, func(s string) bool {
		return strings.EqualFold(s, "GO")
	})
	fmt.Println(found)

	// Works on structs too -- match on any field you like
	users := []User{{"alice", 30}, {"bob", 25}}
	hasMinor := slices.ContainsFunc(users, func(u User) bool {
		return u.Age < 18
	})
	fmt.Println(hasMinor)
}

Prints true then false — "Go" matches "GO" under strings.EqualFold (proper Unicode case folding, cheaper than lower-casing both sides), and neither user is under 18. Sibling helpers slices.IndexFunc and slices.Max/MinFunc take the same predicate shape.

4When you need the position: slices.Index

Often "is it there?" is really "where is it?" — you want to update, remove, or slice around the element. slices.Index(s, v) returns the index of the first match, or -1 if there is none, so one call answers both questions.

package main

import (
	"fmt"
	"slices"
)

func main() {
	fruits := []string{"apple", "banana", "cherry"}

	fmt.Println(slices.Index(fruits, "cherry"))
	fmt.Println(slices.Index(fruits, "mango"))

	if i := slices.Index(fruits, "banana"); i >= 0 {
		fmt.Println("banana at index", i)
	}
}

Prints 2, -1, then banana at index 1. The if i := …; i >= 0 form scopes the index to the branch that uses it — the same pattern as the map comma-ok idiom. Note slices.Contains(s, v) is literally defined as slices.Index(s, v) >= 0.

5Which should you use?

6Many lookups? Use a map, not a slice

Every form above scans the slice — O(n) per call. Fine once; wasteful inside a loop that checks hundreds of values against the same list. The Go idiom for that is to pay O(n) once, building a map[T]struct{} set, and then answer every membership question in O(1) with the comma-ok lookup.

package main

import "fmt"

func main() {
	blocked := []string{"spam.com", "junk.net", "bad.org"}

	// Build the set once: O(n)
	set := make(map[string]struct{}, len(blocked))
	for _, d := range blocked {
		set[d] = struct{}{}
	}

	// Every lookup after that is O(1), however many you do
	for _, d := range []string{"mail.com", "junk.net"} {
		if _, ok := set[d]; ok {
			fmt.Println(d, "is blocked")
		} else {
			fmt.Println(d, "is fine")
		}
	}
}

Prints mail.com is fine then junk.net is blocked. The crossover comes fast: even a few dozen lookups against a moderate slice usually favors the map. The set pattern — empty-struct values, comma-ok reads — is covered in depth in check if a key exists in a map.