strings.Index — Byte-Offset des ersten Vorkommens

Die Signatur ist denkbar schlank: zwei Strings rein, ein int raus. Der zurückgegebene Index zeigt auf das erste Byte des Treffers in s; ist der Substring nicht enthalten, kommt -1.

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("Hallo Welt", "Welt")) // Treffer ab Byte 6
	fmt.Println(strings.Index("Hallo Welt", "xyz"))  // nicht enthalten
	fmt.Println(strings.Index("abcabc", "bc"))       // erstes Vorkommen
}

6
-1
1

Der dritte Aufruf zeigt das „erstes Vorkommen"-Verhalten: obwohl "bc" zweimal in "abcabc" steckt, liefert Index den ersten Treffer bei Position 1. Für das letzte Vorkommen gibt es LastIndex.

Go-Strings sind UTF-8-kodierte Byte-Sequenzen. Ein ASCII-Zeichen belegt ein Byte, ein Umlaut wie ä belegt zwei, ein Emoji vier. strings.Index zählt Bytes, nicht Code-Points — wer Zeichen-Positionen für Cursor, Spaltenzahlen oder Anzeigelogik braucht, muss umrechnen.

package main

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

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

	fmt.Println(len(s))                    // Bytes insgesamt
	fmt.Println(utf8.RuneCountInString(s)) // Runen insgesamt

	byteIdx := strings.Index(s, "Grüße")
	fmt.Println("Byte-Offset:", byteIdx)

	// Byte-Offset in Rune-Offset umrechnen
	runeIdx := utf8.RuneCountInString(s[:byteIdx])
	fmt.Println("Rune-Offset:", runeIdx)
}

15
12
Byte-Offset: 8
Rune-Offset: 7

"Schöne " belegt acht Bytes (das ö zählt doppelt), aber nur sieben Runen — daher die Differenz. Solange man den Offset wieder zum Slicen verwendet (s[:byteIdx], s[byteIdx:]), ist der Byte-Offset genau richtig, weil Go-Slicing ebenfalls byte-basiert ist.

Statt eines zweiten Rückgabewertes (ok bool) oder eines Errors nutzt Index den Wert -1, um „nicht gefunden" zu signalisieren. Das ist eine alte Unix/C-Tradition, die Go für die Index-Familie übernommen hat. Vor dem Slicen mit dem Ergebnis ist eine >= 0-Prüfung Pflicht, sonst läuft man bei -1 in einen Out-of-Range-Panic.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "user@example.com"

	if i := strings.Index(s, "@"); i >= 0 {
		user := s[:i]
		host := s[i+1:]
		fmt.Printf("user=%q host=%q\n", user, host)
	} else {
		fmt.Println("kein @ gefunden")
	}
}

user="user" host="example.com"

Das Pattern „Index holen, auf >= 0 prüfen, links/rechts slicen" zieht sich durch viele Parser. Seit Go 1.18 lässt sich derselbe Effekt mit strings.Cut oft eleganter ausdrücken — dazu unten mehr.

Ein häufig übersehener Spezialfall: der leere String gilt als an jeder Position vorhanden — Index(s, "") liefert daher 0. Umgekehrt ist in einem leeren s nichts Nicht-Leeres zu finden, also kommt -1.

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("abc", "")) // leerer Substring -> 0
	fmt.Println(strings.Index("", "x"))   // leeres s        -> -1
	fmt.Println(strings.Index("", ""))    // beides leer     -> 0
}

0
-1
0

Wer Nutzereingaben durchreicht und dabei nicht explizit auf Leerstrings prüft, bekommt mit Index(s, userInput) einen scheinbar harmlosen Treffer an Position 0 — eine Quelle für subtile Bugs in Such- und Filter-Pipelines.

Index ist eine der performance-sensitivsten Funktionen der Standardbibliothek und entsprechend stark optimiert. Für kurze Substrings (insbesondere ein einzelnes Byte) gibt es auf amd64 und arm64 handgeschriebene SIMD-Assembly, die ganze Register-Breiten parallel scannt. Für längere Pattern fällt Go auf einen Two-Way-Algorithmus (Crochemore-Perrin) zurück — linear in der Eingabelänge und ohne den schlimmsten Fall des naiven Matchings.

In Microbenchmarks bewegt sich Index für typische Eingaben im Bereich weniger Nanosekunden pro Aufruf. Für reine Existenzprüfungen empfiehlt sich trotzdem Contains, weil der Code dort die Intention klarer macht — performance-seitig sind beide identisch (Contains ruft intern Index >= 0).

Die drei Funktionen teilen sich die innere Suchmaschine und unterscheiden sich nur in Rückgabe und Suchrichtung. Die Wahl richtet sich nach der Frage, die man eigentlich beantworten will.

Faustregel: braucht der Code die Position für Slicing, ist Index/LastIndex richtig; geht es nur um Anwesenheit, sagt Contains das deutlicher.

In Config-Zeilen, Query-Strings oder Header-Werten taucht das Muster key=value ständig auf. Klassisch teilt man das mit Index am ersten = auf — der erste Treffer ist entscheidend, weil value selbst weitere = enthalten darf (etwa in base64).

package main

import (
	"fmt"
	"strings"
)

// parseKV zerlegt "key=value" am ersten '='.
// Variante mit Index — funktioniert in jeder Go-Version.
func parseKV(line string) (key, value string, ok bool) {
	i := strings.Index(line, "=")
	if i < 0 {
		return "", "", false
	}
	return line[:i], line[i+1:], true
}

func main() {
	lines := []string{
		"host=db.example.com",
		"token=abc=def=",  // value enthaelt '='
		"broken-line",
	}
	for _, l := range lines {
		k, v, ok := parseKV(l)
		fmt.Printf("%-25s -> key=%q value=%q ok=%v\n", l, k, v, ok)
	}

	// Seit Go 1.18 idiomatischer mit strings.Cut:
	k, v, ok := strings.Cut("host=db.example.com", "=")
	fmt.Println("Cut:", k, v, ok)
}

host=db.example.com       -> key="host" value="db.example.com" ok=true
token=abc=def=            -> key="token" value="abc=def=" ok=true
broken-line               -> key="" value="" ok=false
Cut: host db.example.com true

Für neuen Code ist strings.Cut die bessere Wahl: ein Aufruf liefert direkt beide Hälften plus ein ok-Flag, ohne dass man manuell mit Offsets hantiert. Index bleibt sinnvoll, wenn der Code Go 1.17 oder älter unterstützen muss oder wenn der Offset selbst — und nicht die Split-Hälften — gebraucht wird.

Für eine echte URL-Verarbeitung gehört net/url her, keine Frage. Für schnelle Vorab-Checks — etwa „Hat dieser String ein Schema?" oder „Welches Schema steht davor?" — ist Index aber das passende Werkzeug, weil der Separator :// einzigartig und kurz ist.

package main

import (
	"fmt"
	"strings"
)

// splitScheme trennt "scheme://rest" am ersten "://".
func splitScheme(raw string) (scheme, rest string) {
	i := strings.Index(raw, "://")
	if i < 0 {
		return "", raw
	}
	return raw[:i], raw[i+3:] // +3 ueberspringt "://"
}

func main() {
	urls := []string{
		"https://mibeon.de/docs/go",
		"postgres://user:pw@db:5432/app",
		"file:///etc/hosts",
		"einfach-nur-text",
	}
	for _, u := range urls {
		scheme, rest := splitScheme(u)
		fmt.Printf("%-35s scheme=%-10q rest=%q\n", u, scheme, rest)
	}
}

https://mibeon.de/docs/go           scheme="https"     rest="mibeon.de/docs/go"
postgres://user:pw@db:5432/app      scheme="postgres"  rest="user:pw@db:5432/app"
file:///etc/hosts                   scheme="file"      rest="/etc/hosts"
einfach-nur-text                    scheme=""          rest="einfach-nur-text"

Auffällig ist der file:///-Fall: der dritte Slash gehört bereits zum Pfad, der Host ist leer. Genau solche Edge-Cases zeigen, wann man von der eigenen Index-Lösung auf net/url.Parse wechseln sollte — alles, was über die simple Schema-Extraktion hinausgeht, ist dort robuster aufgehoben.

Weiterführende Ressourcen

Externe Quellen

• strings.Index
• strings.Contains
• strings.Cut
• net/url

Verwandte Artikel

• strings-Paket — Übersicht
• strings.Contains — Bool-Variante
• strings.IndexByte — Single-Byte-Hot-Path
• strings.IndexRune — Rune-Offset