strings.Count — Anzahl nicht-überlappender Vorkommen

Die Signatur ist denkbar schmal: zwei Strings rein, ein int raus. Es gibt keine Optionen, keine Limits, kein Locale — Count arbeitet rein byteweise auf der UTF-8-Repräsentation und liefert die Trefferzahl als positive Ganzzahl (oder Null, wenn nichts gefunden wurde).

package main

import (
	"fmt"
	"strings"
)

// func Count(s, substr string) int

func main() {
	fmt.Println(strings.Count("banana", "an")) // 2
	fmt.Println(strings.Count("banana", "na")) // 2
	fmt.Println(strings.Count("banana", "x"))  // 0
}

2
2
0

s ist der zu durchsuchende String, substr das Muster — Reihenfolge wie bei allen anderen strings-Funktionen. Beide Argumente können beliebige Bytes enthalten, auch Steuerzeichen oder Multi-Byte-UTF-8.

Das wichtigste Detail von Count: gefundene Vorkommen überschneiden sich nicht. Nach einem Treffer rückt der interne Cursor um die volle Länge von substr weiter — nicht nur um ein Byte. Wer überlappende Treffer braucht (z. B. bei "aa" in "aaaa"), muss strings.Index in einer eigenen Schleife mit Schritt 1 verwenden.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// "aaaa" enthaelt "aa" rein lexikalisch dreimal (Pos 0, 1, 2)
	// Count zaehlt aber nicht-ueberlappend:
	fmt.Println(strings.Count("aaaa", "aa")) // 2, nicht 3

	// Wer Ueberlappung will, braucht manuelle Loop:
	overlap := func(s, sub string) int {
		n := 0
		for i := 0; i+len(sub) <= len(s); i++ {
			if s[i:i+len(sub)] == sub {
				n++
			}
		}
		return n
	}
	fmt.Println(overlap("aaaa", "aa")) // 3
}

2
3

Visualisiert: in aaaa greift Count bei Position 0 (aa..) und Position 2 (..aa) — die Position 1 wird übersprungen, weil der Cursor nach dem ersten Treffer auf Byte 2 weitergesetzt wird. Diese Semantik ist konsistent mit strings.Split und strings.Replace.

Wird Count mit einem leeren substr aufgerufen, liefert die Funktion einen scheinbar willkürlichen, in Wahrheit aber wohldefinierten Wert: die Anzahl der Runen plus 1. Mathematisch entspricht das den Positionen zwischen den Zeichen (vor dem ersten, zwischen je zwei Zeichen, nach dem letzten). Wichtig: gezählt werden Runen, nicht Bytes — Umlaute und Emojis tragen jeweils nur einen Schritt bei.

package main

import (
	"fmt"
	"strings"
	"unicode/utf8"
)

func main() {
	s := "abc"
	fmt.Println(strings.Count(s, ""))             // 4 = 3 Runen + 1
	fmt.Println(utf8.RuneCountInString(s) + 1)    // 4

	// Mit Mehrbyte-Runen wird der Unterschied zu len() deutlich:
	t := "äöü" // 3 Runen, 6 Bytes
	fmt.Println(len(t))                           // 6
	fmt.Println(utf8.RuneCountInString(t))        // 3
	fmt.Println(strings.Count(t, ""))             // 4 (Rune-Anzahl + 1)

	// Emoji zaehlt ebenfalls als 1 Rune:
	fmt.Println(strings.Count("a😀b", ""))        // 4
}

4
4
6
3
4
4

Dieses Verhalten ist konsistent zu strings.Split(s, ""), das genau einen Slice mit Rune-Anzahl Elementen liefert — die Trenner-Positionen sind dieselben.

Count ist intern eine schlanke Schleife über IndexByte/Index, also derselbe Mechanismus wie bei Contains. Bei Single-Byte-Substrings kommt auf gängigen Architekturen eine SIMD-beschleunigte Suchroutine zum Einsatz — das schlägt jede manuell geschriebene for-Schleife in Go deutlich. Die Komplexität ist linear in der Länge von s. substr darf beliebig kurz sein, ohne dass sich der Algorithmus prinzipiell verschlechtert.

Für 99 Prozent aller Anwendungen ist die Frage nach der Performance damit beantwortet: strings.Count ist schnell genug, und alles Eigene wird langsamer.

Es ist verlockend, eine Zählschleife „mal eben" selbst zu schreiben — pädagogisch lehrreich, in Produktion aber fast immer ein Rückschritt. Der folgende Vergleich zeigt eine naive Variante neben dem Stdlib-Aufruf: identisches Ergebnis, aber spürbar mehr Code und kein SIMD-Bonus.

package main

import (
	"fmt"
	"strings"
)

// Naive, nicht-ueberlappende Zaehlung — funktional korrekt,
// aber langsamer und fehleranfaelliger als strings.Count.
func naiveCount(s, sub string) int {
	if sub == "" {
		return len([]rune(s)) + 1 // Sonderfall nachbauen
	}
	n, i := 0, 0
	for i+len(sub) <= len(s) {
		if s[i:i+len(sub)] == sub {
			n++
			i += len(sub) // hinter den Treffer springen
		} else {
			i++
		}
	}
	return n
}

func main() {
	s := "banana banana banana"
	fmt.Println(naiveCount(s, "an"))    // 6
	fmt.Println(strings.Count(s, "an")) // 6 — identisch, aber knapper
}

6
6

Das Stdlib-Count hat zusätzlich den SIMD-Vorteil bei Single-Byte-Pattern, eine getestete Edge-Case-Behandlung für leere Strings und keinen Boilerplate. In neuen Code-Reviews fällt eine handgerollte Zählschleife heute fast immer durch — strings.Count ist das richtige Werkzeug.

Ein klassischer Einsatz ist die Zeilenzahl-Schätzung über Count(text, "\n"). Das ist deutlich schneller als ein bufio.Scanner-Durchlauf und reicht für Logs, Metriken oder Fortschritts-Anzeigen vollkommen aus. Ein Detail muss man kennen: ein Text ohne abschließenden \n enthält genauso viele \n-Zeichen wie Zeilenumbrüche, aber eine Zeile mehr — je nach Definition zählt man entweder die Trenner oder die Inhalte.

package main

import (
	"fmt"
	"strings"
)

func zeilen(text string) int {
	if text == "" {
		return 0
	}
	n := strings.Count(text, "\n")
	// Wenn der Text nicht mit \n endet, ist die letzte Zeile
	// noch ohne Trenner — also +1.
	if !strings.HasSuffix(text, "\n") {
		n++
	}
	return n
}

func main() {
	fmt.Println(zeilen(""))           // 0
	fmt.Println(zeilen("a"))          // 1
	fmt.Println(zeilen("a\n"))        // 1
	fmt.Println(zeilen("a\nb"))       // 2
	fmt.Println(zeilen("a\nb\n"))     // 2
	fmt.Println(zeilen("a\nb\nc\n"))  // 3
}

0
1
1
2
2
3

Wer \r\n-Zeilenenden (Windows) zu erwarten hat, normalisiert vorher oder zählt \n — Carriage-Returns ohne \n sind heute selten.

Wenn für eine ganze Liste von Wörtern die Häufigkeit im selben Text bestimmt werden soll, bietet sich die Kombination map[string]int plus strings.Count an. Für jede Suchanfrage entsteht so genau ein Count-Lauf — bei wenigen Mustern (z. B. 10–100) ist das in der Praxis unschlagbar einfach. Erst wenn die Patternliste sehr groß wird, lohnt sich ein Multi-Pattern-Algorithmus wie Aho-Corasick.

package main

import (
	"fmt"
	"sort"
	"strings"
)

func zaehleWoerter(text string, woerter []string) map[string]int {
	low := strings.ToLower(text)
	res := make(map[string]int, len(woerter))
	for _, w := range woerter {
		res[w] = strings.Count(low, strings.ToLower(w))
	}
	return res
}

func main() {
	text := `Go ist eine Sprache von Google.
Go-Code ist lesbar, Go-Tools sind schnell, und Go-Module helfen.`
	stats := zaehleWoerter(text, []string{"go", "tools", "rust"})

	// stabile Ausgabe
	keys := make([]string, 0, len(stats))
	for k := range stats {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		fmt.Printf("%-6s %d\n", k, stats[k])
	}
}

go     4
rust   0
tools  1

Die Lowercase-Normalisierung vor dem Zählen ist ein klassischer Stolperstein: ohne sie würden „Go" und „go" als unterschiedliche Patterns gezählt — fast immer nicht gewollt.

Weiterführende Ressourcen

Externe Quellen

• strings.Count
• unicode/utf8

Verwandte Artikel

• strings-Paket — Übersicht
• strings.Index — erstes Vorkommen
• strings.Contains — Existenz prüfen