Golang Strings: Split, Join, Contains, Replace und mehr

Ein Go-String ist eine unveränderliche Folge von Bytes, normalerweise UTF-8-Text. Die Operatoren arbeiten auf dem String selbst (+, ==, <, Indizieren, Slicen), und alles andere steckt im Standardpaket strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Strings splitten

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

Der Fall Split("", ",") erwischt viele: Eine leere Eingabe ergibt einen Slice der Länge 1, nicht 0. Beim Splitten von Nutzereingaben vermeidest du mit Fields oder einer vorherigen Prüfung auf s == "" ein Phantom-Element.

strings.Cut ist der sauberste Weg, key=value, user@host und ähnliche Paare zu trennen. Go 1.24 hat außerdem Iterator-Versionen eingeführt, strings.SplitSeq und strings.FieldsSeq, die die Teile einzeln liefern, ohne einen Slice zu bauen.

Suchen

Jede Suche beachtet Groß- und Kleinschreibung, außer EqualFold. Um unabhängig davon zu suchen, wandle beide Seiten in Kleinbuchstaben um oder nimm EqualFold für Vergleiche ganzer Strings.

Umwandeln

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

Eine Falle: Trim, TrimLeft und TrimRight nehmen eine Menge von Zeichen, kein Präfix. strings.TrimLeft("abcab", "ab") entfernt jedes führende a und b und gibt "cab" zurück. Um ein exaktes Präfix oder Suffix zu entfernen, nimm TrimPrefix und TrimSuffix.

Verkettung und strings.Builder

+ verbindet Strings, und fmt.Sprintf formatiert Werte in einen String. Beide legen jedes Mal einen neuen String an, weil Strings unveränderlich sind. Für eine Handvoll Operationen ist das in Ordnung, in einer Schleife aber langsam, weil jedes += alles bisher Gebaute kopiert. Nimm stattdessen strings.Builder:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

Ein strings.Builder mit Nullwert ist sofort einsatzbereit. Er implementiert io.Writer, also schreibt fmt.Fprintf direkt hinein. Ruf vorher b.Grow(n) auf, wenn du ungefähr weißt, wie groß das Ergebnis wird. Kopier einen Builder nicht, nachdem du hineingeschrieben hast; übergib einen Pointer.

Mehrzeilige und Raw Strings

Go hat zwei Arten von String-Literalen:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

Strings in doppelten Anführungszeichen verarbeiten Escapes (\n, \t, \", \\, \u00e9) und müssen in eine Zeile passen. Raw Strings in Backquotes nehmen alles wörtlich, auch Zeilenumbrüche. Damit schreibst du mehrzeilige Strings, reguläre Ausdrücke, JSON und Windows-Pfade. Ein Raw String kann keinen Backquote enthalten, und Wagenrückläufe darin werden entfernt. Beachte, dass die Query oben mit einem Zeilenumbruch beginnt, da das Literal direkt nach dem öffnenden Backquote anfängt.

Länge, Indizes und Teilstrings

len(s) ist die Anzahl der Bytes. s[i] ist ein Byte, und s[i:j] ist ein Teilstring nach Byte-Positionen:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï und é belegen je zwei Bytes, also hat der String 12 Bytes und 10 Zeichen. Nach Bytes zu slicen ist sicher, solange die Positionen von strings.Index oder Ähnlichem kommen, die Byte-Offsets auf Zeichengrenzen liefern. Für „die ersten n Zeichen“ konvertierst du vorher in []rune. Die Seite zu Runes und Bytes erklärt UTF-8 im Detail.

Strings sind unveränderlich

Du kannst ein Byte nicht direkt ändern: s[0] = 'H' ist ein Compilerfehler (cannot assign to s[0] (neither addressable nor a map index expression)). Jede Funktion in strings gibt einen neuen String zurück. Zum Bearbeiten konvertierst du in []byte oder []rune, änderst den Slice und konvertierst zurück:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

Die Unveränderlichkeit ist auch der Grund, warum Teilstrings billig sind: s[2:5] teilt sich den Speicher mit s, statt ihn zu kopieren. Die Kehrseite: Ein kleiner Teilstring eines riesigen Strings hält den ganzen riesigen String am Leben. Nimm strings.Clone (Go 1.20), wenn du ein kurzes Stück einer großen Eingabe behältst.

Strings vergleichen

== und != vergleichen den Inhalt, und <, > vergleichen Byte für Byte, was bei ASCII alphabetisch ist. strings.Compare gibt es, wird aber selten gebraucht; slices.Sort auf einem []string nutzt <. Für eine sprachabhängige Sortierung von nicht englischem Text nimm golang.org/x/text/collate.

Andere Typen konvertieren

Zahlen werden mit strconv.Itoa, strconv.FormatFloat oder fmt.Sprintf zu Strings, und Strings werden mit strconv.Atoi und strconv.ParseFloat zu Zahlen. Schreib nicht string(42): Das erzeugt das Zeichen mit Codepoint 42, "*". Die Seite zur Typkonvertierung hat die vollständige Tabelle.

query := `SELECT id, name
FROM users
WHERE active = true`