strings.ContainsAny — enthält irgendein Zeichen aus Set?

Die Funktion ist eines der schlankesten Prädikate im strings-Paket. Sie nimmt zwei Strings entgegen und gibt einen Wahrheitswert zurück — kein Index, kein Fehler, keine Allokation.

func ContainsAny(s, chars string) bool

s ist der zu durchsuchende Text, chars die Zeichenmenge. Ein true bedeutet: mindestens eine Rune aus chars taucht irgendwo in s auf.

Der häufigste Stolperstein bei ContainsAny ist die Verwechslung mit Contains. Während Contains einen festen, zusammenhängenden Substring sucht, behandelt ContainsAny sein zweites Argument als Menge: jedes Zeichen darin ist ein eigener Suchkandidat. ContainsAny("Hallo", "xyz") ist false, ContainsAny("Hallo", "xya") ist true, sobald die Rune a in s vorkommt.

Genau deshalb sind auch Reihenfolge und Doppelungen im Cutset bedeutungslos. "abc", "cba" und "aabbcc" sind als Cutsets exakt äquivalent.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Hallo Welt"

	// Cutset: irgendeine dieser Runes?
	fmt.Println(strings.ContainsAny(s, "xyz")) // false
	fmt.Println(strings.ContainsAny(s, "xyW")) // true (W trifft)

	// Reihenfolge und Doppelungen egal
	fmt.Println(strings.ContainsAny(s, "Wxy"))  // true
	fmt.Println(strings.ContainsAny(s, "WWWy")) // true

	// Vergleich mit Contains: dort ist "Wxy" EIN Substring
	fmt.Println(strings.Contains(s, "Wxy")) // false
}

false
true
true
true
false

Wer das Cutset-Konzept einmal verinnerlicht hat, vermeidet eine ganze Klasse von Bugs, in denen ein gemeinter Substring-Test heimlich zur Mengenprüfung wird.

Beide Randfälle leerer Strings liefern dieselbe Antwort, allerdings aus unterschiedlichen Gründen. Ein leeres Cutset enthält keine Runes, die getroffen werden könnten — das Ergebnis ist daher zwingend false. Ein leeres s enthält schlicht keine Zeichen, die einem Cutset angehören könnten, also ebenfalls false.

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ContainsAny("Hallo", "")) // false, Cutset leer
	fmt.Println(strings.ContainsAny("", "abc"))   // false, s leer
	fmt.Println(strings.ContainsAny("", ""))      // false
}

false
false
false

Diese Symmetrie ist praktisch, weil keine Sonderfallbehandlung im aufrufenden Code nötig ist — leere Eingaben fallen einfach durch.

ContainsAny iteriert intern über Runes, nicht über Bytes. Dadurch sind auch Multi-Byte-Codepoints wie deutsche Umlaute oder Emojis vollwertige Mitglieder des Cutsets. Ein ä belegt in UTF-8 zwei Bytes, wird aber als eine einzige Rune behandelt — eine byteweise Suche würde hier falsche Treffer produzieren.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Schöne Grüße aus München 🍻"

	// Umlaute als Cutset-Mitglieder
	fmt.Println(strings.ContainsAny(s, "äöü")) // true (ö, ü treffen)
	fmt.Println(strings.ContainsAny(s, "áéí")) // false

	// Emojis als Runes im Cutset
	fmt.Println(strings.ContainsAny(s, "🍕🍻🍷")) // true (🍻 trifft)
	fmt.Println(strings.ContainsAny(s, "🍕🍷"))   // false
}

true
false
true
false

Für die meisten internationalen Texte ist dieses Verhalten genau das, was man erwartet — anders als bei naiver Byte-Suche bleiben gemischte Zeichen aus verschiedenen Sprachen korrekt prüfbar.

Die drei Funktionen bilden ein zusammengehöriges Trio, unterscheiden sich aber klar in Rückgabewert und Semantik des zweiten Arguments. Wer den Unterschied im Kopf hat, greift in fast jedem Such-Szenario zum richtigen Werkzeug.

Faustregel: Contains für ganze Substrings, ContainsAny für reine Ja/Nein-Fragen über eine Zeichenmenge, IndexAny wenn die Trefferposition gebraucht wird.

Ein klassisches Einsatzfeld ist die Validierung von Benutzereingaben. Bevor ein Username in eine URL eingebaut oder in HTML eingebettet wird, lohnt sich eine schnelle Vorprüfung auf strukturzerstörende Zeichen wie <, >, ", ' oder &. ContainsAny reduziert diese Prüfung auf eine einzige, gut lesbare Zeile.

package main

import (
	"fmt"
	"strings"
)

const forbidden = `<>"'&`

func isValidUsername(name string) bool {
	if name == "" {
		return false
	}
	return !strings.ContainsAny(name, forbidden)
}

func main() {
	candidates := []string{
		"michael",
		"max_mustermann",
		`<script>`,
		"alice&bob",
		"O'Reilly",
	}

	for _, c := range candidates {
		fmt.Printf("%-20s -> %v\n", c, isValidUsername(c))
	}
}

michael              -> true
max_mustermann       -> true
<script>             -> false
alice&bob            -> false
O'Reilly             -> false

Wichtig: ContainsAny ersetzt keine vollständige Eingabevalidierung oder ein sauberes Escaping — es ist ein billiger Vorfilter, der offensichtlich riskante Eingaben früh ausschließt.

Beim Einlesen unbekannter Tabellendateien hilft eine schnelle Trennzeichen-Heuristik, bevor ein vollwertiger Parser gewählt wird. Die erste nicht-leere Zeile reicht oft, um zwischen Komma-, Semikolon- und Tab-getrennten Formaten zu unterscheiden.

package main

import (
	"fmt"
	"strings"
)

func sniffSeparator(line string) string {
	switch {
	case strings.ContainsAny(line, "\t"):
		return "tab"
	case strings.ContainsAny(line, ";"):
		return "semicolon"
	case strings.ContainsAny(line, ","):
		return "comma"
	default:
		return "unknown"
	}
}

func main() {
	lines := []string{
		"id,name,email",
		"id;name;email",
		"id\tname\temail",
		"einzelspalte",
	}

	for _, l := range lines {
		fmt.Printf("%-25q -> %s\n", l, sniffSeparator(l))
	}
}

"id,name,email"           -> comma
"id;name;email"           -> semicolon
"id\tname\temail"         -> tab
"einzelspalte"            -> unknown

Für robustere Erkennung würde man mehrere Zeilen sampeln und die Trennzeichen zählen — aber als erste Weichenstellung in einer Importpipeline ist ContainsAny ausreichend und sehr schnell.

Weiterführende Ressourcen

Externe Quellen

• strings.ContainsAny
• strings.IndexAny

Verwandte Artikel

• strings-Paket — Übersicht
• strings.Contains — fester Substring
• strings.ContainsRune — einzelne Rune
• strings.ContainsFunc — Prädikat über Runes