Das strings-Paket — String-Manipulation

Sechs Funktionsgruppen plus drei Typen

Das strings-Paket gliedert sich entlang der Operation, nicht des Inputs: alle Funktionen nehmen Strings entgegen, unterscheiden sich aber darin, ob sie suchen, zerteilen, trimmen, ersetzen oder iterieren. Hinzu kommen drei Typen, die Performance-kritische Pfade abdecken.

Gruppe	Beispiele	Zweck
Suchen / Prüfen	Contains, HasPrefix, Index, Count	Vorkommen feststellen, Offset finden
Teilen / Joinen	Split, Fields, Cut, Join	String in Stücke zerlegen oder zusammenfügen
Trimmen	Trim, TrimSpace, TrimPrefix	Ränder entfernen
Ersetzen / Verändern	Replace, ReplaceAll, Map, ToLower	Inhalte austauschen oder transformieren
Iteratoren (Go 1.24+)	Lines, SplitSeq, FieldsSeq	Range-fähig ohne []string-Allokation
Typen	Builder, Reader, Replacer	Performance-kritische Bausteine

UTF-8 und Byte-Offsets

Strings sind in Go immer UTF-8-kodiert und werden byteweise indiziert. Die Index*-Funktionen geben deshalb einen Byte-Offset zurück, keinen Rune-Offset. Bei reinem ASCII fällt das nie auf, sobald aber Umlaute oder Emojis vorkommen, kann der Index mitten in eine Multibyte-Sequenz fallen — das anschließende Slicen zerstört dann die UTF-8-Kodierung.

Wer Rune-Positionen braucht, arbeitet mit utf8.RuneCountInString, iteriert mit range über den String oder nutzt die rune-orientierten Detail-Seiten wie IndexRune und ContainsRune.

Trim-Varianten: Cutset vs. Substring

Hier lauert die häufigste Anfängerfalle des Pakets. Trim/TrimLeft/TrimRight arbeiten mit einem Cutset — der zweite Parameter ist eine Menge einzelner Zeichen, die solange vom Rand entfernt werden, wie sie auftreten. TrimPrefix/TrimSuffix dagegen entfernen einen gesamten Substring genau einmal, falls er als Präfix/Suffix vorhanden ist.

Das bedeutet konkret: strings.TrimLeft("effective.go", "file") ergibt ".go", weil e, f, i, l alle im Cutset sind. Das ist fast nie das, was man eigentlich wollte. Für Wort-Präfixe immer TrimPrefix nehmen.

Funktionen — Suchen, Prüfen, Lokalisieren

Die Such-Familie deckt zwei Achsen ab: Bool-Prädikate (Contains*, HasPrefix/Suffix, EqualFold) und Index-Lookup (Index*, LastIndex*, Count). Beide Varianten existieren parallel, weil sich nicht immer der Index aus der Existenz ableiten lässt und der Compiler die Bool-Form besser optimieren kann.

• strings.Contains — enthält Teilstring?
• strings.ContainsAny — enthält irgendein Zeichen aus Set?
• strings.ContainsRune — enthält Rune?
• strings.ContainsFunc — Prädikat über Runes (Go 1.21+).
• strings.HasPrefix — beginnt mit?
• strings.HasSuffix — endet auf?
• strings.EqualFold — case-insensitiver Vergleich.
• strings.Index — erstes Vorkommen, Byte-Offset.
• strings.IndexAny — erster Treffer aus Zeichensatz.
• strings.IndexByte — Single-Byte-Hot-Path.
• strings.IndexRune — Rune-Offset (mehrere Bytes möglich).
• strings.IndexFunc — erster Treffer per Prädikat.
• strings.LastIndex — letztes Vorkommen.
• strings.LastIndexAny — letztes aus Zeichensatz.
• strings.LastIndexByte — letztes Single-Byte.
• strings.LastIndexFunc — letztes per Prädikat.
• strings.Count — Anzahl nicht-überlappender Vorkommen.

Funktionen — Teilen, Sammeln, Joinen

Vom feinen Whitespace-Trenner (Fields) über exakte Trenner (Split) bis zum modernen Schnitt-Pattern (Cut). Split zerlegt an exakt dem Trenner und behält leere Felder, Fields trennt an Whitespace-Sequenzen und überspringt sie. Cut (Go 1.18+) ersetzt das klassische Index+Slice-Pattern für Key-Value-Parsing.

• strings.Split — exakter Trenner, leere Felder bleiben.
• strings.SplitN — Maximalzahl Stücke.
• strings.SplitAfter — Trenner am Ende jedes Stücks.
• strings.SplitAfterN — Kombination beider.
• strings.Fields — Whitespace-Sequenzen als Trenner.
• strings.FieldsFunc — Trenner per Prädikat.
• strings.Cut — (before, after, found) (Go 1.18+).
• strings.CutPrefix — Präfix abschneiden mit Erfolgs-Flag (Go 1.20+).
• strings.CutSuffix — Suffix abschneiden mit Erfolgs-Flag (Go 1.20+).
• strings.Join — Slice zusammenführen, allokations-optimiert.

Funktionen — Trimmen

Cutset-basierte Trim-Funktionen (Trim*) entfernen einzelne Zeichen vom Rand, Präfix-/Suffix-basierte (TrimPrefix/TrimSuffix) ganze Substrings. TrimFunc und Verwandte arbeiten mit Prädikat über Runes — siehe Cutset vs. Substring.

• strings.Trim — Cutset von beiden Seiten. (in Vorbereitung)
• strings.TrimLeft — Cutset von links. (in Vorbereitung)
• strings.TrimRight — Cutset von rechts. (in Vorbereitung)
• strings.TrimSpace — Whitespace beidseitig. (in Vorbereitung)
• strings.TrimPrefix — Substring-Präfix entfernen. (in Vorbereitung)
• strings.TrimSuffix — Substring-Suffix entfernen. (in Vorbereitung)
• strings.TrimFunc — Prädikat beidseitig. (in Vorbereitung)
• strings.TrimLeftFunc — Prädikat links. (in Vorbereitung)
• strings.TrimRightFunc — Prädikat rechts. (in Vorbereitung)

Funktionen — Ersetzen und Verändern

Ersetzungs- und Transformations-Funktionen. Replace/ReplaceAll sind die direkten Single-Pattern-Werkzeuge, Map arbeitet rune-weise mit Drop-Option, Repeat baut Wiederholungen. Für mehrere parallele Ersetzungen ist strings.Replacer die richtige Wahl — vorkompiliert, threadsafe, in einem Pass.

• strings.Replace — Substring-Ersetzung mit Limit. (in Vorbereitung)
• strings.ReplaceAll — alle Vorkommen (Go 1.12+). (in Vorbereitung)
• strings.Map — Rune-Mapping mit Drop-Option. (in Vorbereitung)
• strings.Repeat — String n-mal wiederholen. (in Vorbereitung)
• strings.ToLower — Kleinbuchstaben (Unicode-aware). (in Vorbereitung)
• strings.ToUpper — Großbuchstaben (Unicode-aware). (in Vorbereitung)
• strings.ToTitle — Title-Case (selten = ToUpper). (in Vorbereitung)
• strings.ToValidUTF8 — Ersatz für ungültige UTF-8-Sequenzen. (in Vorbereitung)

Funktionen — Iteratoren (Go 1.24+)

Mit Go 1.24 sind range-fähige Iterator-Varianten dazugekommen, die []string-Allokationen vermeiden — der Hot-Path-freundliche Weg, über Tokens zu laufen. Statt for _, line := range strings.Split(s, "\n") schreibt man for line := range strings.SplitSeq(s, "\n") und spart die Slice-Allokation.

• strings.Lines — über Zeilen iterieren. (in Vorbereitung)
• strings.SplitSeq — Split als Iterator. (in Vorbereitung)
• strings.SplitAfterSeq — SplitAfter als Iterator. (in Vorbereitung)
• strings.FieldsSeq — Fields als Iterator. (in Vorbereitung)
• strings.FieldsFuncSeq — FieldsFunc als Iterator. (in Vorbereitung)

Typen

Die drei großen Typen des Pakets bündeln Performance-kritische Idiome. Der Builder löst das O(n²)-Problem wiederholter Konkatenation, der Reader brückt String → io.Reader ohne Kopie, der Replacer kompiliert mehrere Substitutionen in einen Pass.

• strings.Builder — effizienter String-Aufbau ohne Kopier-Kaskade.
• strings.Reader — io.Reader-Adapter für vorhandene Strings.
• strings.Replacer — vorkompilierte Multi-Substitution.

Weiterführende Ressourcen

Externe Quellen

• strings — Go Documentation
• Go Blog: Strings, bytes, runes and characters in Go
• strings.Builder
• strings.Cut (Go 1.18+)
• Effective Go: Append

Verwandte Artikel

• fmt — Formatierte I/O
• strconv — String-Number-Conversion
• bytes — Byte-Slice-Manipulation
• Standardbibliothek-Übersicht