How to check if a string contains a substring in Go

1strings.ContainsRecommended

strings.Contains(s, substr) reports whether substr appears anywhere inside s. It never allocates, never returns an error, and on the standard toolchain it drops into assembly-optimised byte search (falling back to Rabin–Karp for long needles), so it is the fastest thing you can reach for. This is the answer to the question 99% of the time.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "compilebytes.com/examples/go"

	fmt.Println(strings.Contains(s, "examples"))
	fmt.Println(strings.Contains(s, "python"))

	// The empty string is a substring of every string.
	fmt.Println(strings.Contains(s, ""))

	if strings.Contains(s, "/go") {
		fmt.Println("this is a Go page")
	}
}

Prints true, false, true, then this is a Go page. The third line is the one that bites: an empty needle is contained in everything, so if substr comes from user input, guard it with substr != "" before you treat a true as a real match. Looking for an element in a []string instead? That's checking if a slice contains an element.

2HasPrefix and HasSuffix — anchored checks

Contains answers "anywhere", which is the wrong question for file extensions, URL schemes and path roots. strings.HasSuffix(name, ".png") anchors the match to the end and strings.HasPrefix to the start — both are O(len of the affix) and stop immediately on the first mismatch. Since Go 1.20, strings.CutPrefix and CutSuffix test and strip in one call.

package main

import (
	"fmt"
	"strings"
)

func main() {
	path := "images/logo.png"

	fmt.Println(strings.Contains(path, ".png"))  // anywhere
	fmt.Println(strings.HasSuffix(path, ".png")) // only at the end
	fmt.Println(strings.HasPrefix(path, "images/"))

	// Contains happily says yes to a name that merely mentions .png
	tricky := "logo.png.txt"
	fmt.Println(strings.Contains(tricky, ".png"), strings.HasSuffix(tricky, ".png"))

	// Test and strip in one call (Go 1.20+)
	rest, ok := strings.CutPrefix(path, "images/")
	fmt.Println(rest, ok)
}

The fourth line prints true false — logo.png.txt is a text file that merely mentions .png, and only HasSuffix gets that right. The last line prints logo.png true. For real filenames prefer filepath.Ext(path) == ".png", and lowercase first if the extension may be .PNG.

3ContainsAny, ContainsRune and ContainsFunc

These three answer a different question: not "is this sequence in there" but "is any character of this kind in there". ContainsAny(s, chars) treats its second argument as a set of runes, not a substring; ContainsRune(s, r) checks a single code point; and ContainsFunc(s, f) (Go 1.21+) takes a predicate, so any unicode.IsDigit-style function works.

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	pw := "hunter2!"

	// Is ANY one of these characters present?
	fmt.Println(strings.ContainsAny(pw, "!@#$%"))
	fmt.Println(strings.ContainsAny("hunter", "!@#$%"))

	// One rune, no substring machinery
	fmt.Println(strings.ContainsRune("caf\u00e9", '\u00e9'))

	// An empty character set matches nothing
	fmt.Println(strings.ContainsAny(pw, ""))

	// A predicate instead of a character list (Go 1.21+)
	fmt.Println(strings.ContainsFunc(pw, unicode.IsDigit))
}

Output is true, false, true, false, true. Note the asymmetry on line 4: Contains(s, "") is true but ContainsAny(s, "") is false — an empty set has nothing to match. Don't reach for ContainsAny(s, "abc") expecting it to find "abc"; that's Contains.

4Case-insensitive search (there is no ContainsFold)

The strings package ships EqualFold but no ContainsFold, and that omission is deliberate: case folding can change a string's length (German ß folds to SS), so a genuinely fold-aware search is not a byte scan and can't share Contains' fast path. The practical answer is to lowercase both sides and search that — and to know exactly where it lies to you.

package main

import (
	"fmt"
	"strings"
)

// ContainsFold reports whether substr is inside s, ignoring case.
// The strings package has no such function, so you write it.
func ContainsFold(s, substr string) bool {
	return strings.Contains(strings.ToLower(s), strings.ToLower(substr))
}

func main() {
	s := "Error: Disk Full"

	fmt.Println(strings.Contains(s, "disk full")) // case-sensitive
	fmt.Println(ContainsFold(s, "disk full"))

	// EqualFold compares two WHOLE strings -- it never searches
	fmt.Println(strings.EqualFold("Disk", "DISK"))
	fmt.Println(strings.EqualFold(s, "disk"))

	// ...so fold-compare the slice you already located
	i := strings.Index(s, "Disk")
	fmt.Println(strings.EqualFold(s[i:i+len("Disk")], "dIsK"))

	// ToLower is locale-blind: Turkish dotless i does not fold to "i"
	fmt.Println(ContainsFold("BALIK", "bal\u0131k"))
}

Lines print false, true, true, false, true, false. Line 4 is the trap people fall into: EqualFold(s, "disk") is false because EqualFold compares entire strings — it is == ignoring case, not a search. Use it on a slice you already found (line 5). And line 6 shows the limit of the ToLower trick: BALIK lowercases to balik, which is not the Turkish balık. Two ToLower calls also allocate two new strings per check, so hoist them out of hot loops.

5Index and LastIndex — when you need the position

Contains throws away information. If you need to know where the match is, call strings.Index (first occurrence) or strings.LastIndex (last one); both return -1 when there is no match, which is why the >= 0 comparison is the whole implementation of Contains. strings.Count answers "how many".

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "go/examples/go/strings"

	fmt.Println(strings.Index(s, "go"))
	fmt.Println(strings.LastIndex(s, "go"))
	fmt.Println(strings.Index(s, "rust"))

	// Contains is exactly this comparison
	fmt.Println(strings.Index(s, "examples") >= 0)

	if i := strings.Index(s, "/"); i >= 0 {
		fmt.Println(s[:i], "|", s[i+1:])
	}

	fmt.Println(strings.Count(s, "go"))

	// Every index is a BYTE offset, not a rune position
	fmt.Println(strings.IndexByte(s, '/'), strings.IndexRune("caf\u00e9!", '\u00e9'), strings.Index("caf\u00e9!", "!"))
}

Prints 0, 12, -1, true, go | examples/go/strings, 2, then 2 3 5. That last line is the gotcha: in café! the ! is at index 5, not 4, because indexes are byte offsets and é takes two bytes. Slicing on an index from Index is always safe though — in valid UTF-8 a byte search can never land mid-rune. Prefer strings.Cut over the Index-then-slice dance when you are splitting on a separator.

6Which should you use?

7regexp — when the needle is a pattern

If what you are looking for is a shape rather than a fixed string — a ticket id, a whole word, a case-insensitive match — regexp is the tool. MatchString is the Contains of the regexp world, and the (?i) flag gives you the case-insensitive search the strings package won't. Compile the pattern once at package level: MustCompile inside a hot function recompiles on every call.

package main

import (
	"fmt"
	"regexp"
)

// Compile once, at package level -- MustCompile panics on a bad pattern.
var errRe = regexp.MustCompile(`(?i)\berror\b`)

func main() {
	fmt.Println(errRe.MatchString("Fatal ERROR: disk full"))
	fmt.Println(errRe.MatchString("no errors here"))

	id := regexp.MustCompile(`[A-Z]{3}-\d{4}`)
	fmt.Println(id.MatchString("ticket ABC-1234 filed"))
	fmt.Println(id.FindString("ticket ABC-1234 filed"))
	fmt.Println(id.FindStringIndex("ticket ABC-1234 filed"))

	// A literal needs no regexp -- QuoteMeta shows what you'd have to escape
	fmt.Println(regexp.QuoteMeta("1.5.0"))
}

Prints true, false, true, ABC-1234, [7 15], then 1\.5\.0. Line 2 is why you'd bother: Contains(s, "error") would match errors, but \b anchors to word boundaries. The flip side is cost — Go's RE2 engine is linear-time and never blows up, but it is still an order of magnitude slower than strings.Contains. If your needle is a literal, don't use regexp; the QuoteMeta line shows how much of it you'd have to escape anyway.