strings.TrimPrefix — Substring-Präfix entfernen

Die Signatur ist minimalistisch und drückt klar aus, was die Funktion tut: zwei Strings rein, ein String raus. Es gibt keinen Fehler-Return, kein Erfolgs-Flag — die Funktion ist total, jede Eingabe ist gültig.

func TrimPrefix(s, prefix string) string

Wenn s mit prefix beginnt, wird s[len(prefix):] zurückgegeben. Andernfalls wird s unverändert (identische Slice-Header) zurückgegeben. Beide Pfade sind allokationsfrei — die Funktion produziert keine neuen Strings im Heap, sondern arbeitet ausschließlich über Slicing der bestehenden String-Bytes.

Dieser Punkt ist die wichtigste Erkenntnis über TrimPrefix. Das zweite Argument wird als Ganzes mit dem Anfang verglichen, nicht als Zeichenmenge interpretiert. Wenn der String nicht exakt mit diesem Substring beginnt, geschieht nichts.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "effective.go"

	// TrimPrefix: "file" als ganzer Substring → kein Match
	fmt.Printf("%q\n", strings.TrimPrefix(s, "file"))

	// TrimLeft: "file" als Cutset {f, i, l, e} → matcht 'e', 'f', 'f', 'e'
	fmt.Printf("%q\n", strings.TrimLeft(s, "file"))

	// TrimPrefix: passender Substring → entfernt
	fmt.Printf("%q\n", strings.TrimPrefix(s, "effective"))
}

"effective.go"
"ctive.go"
".go"

Im ersten Fall liefert TrimPrefix den Originalstring zurück, weil "effective.go" nicht mit "file" beginnt. Im zweiten Fall behandelt TrimLeft "file" als Menge {f, i, l, e} und schneidet von links jedes Zeichen weg, das in dieser Menge liegt — also e, f, f, e. Die beiden Ergebnisse haben nichts miteinander zu tun, obwohl beide Aufrufe identisch aussehen.

TrimPrefix entfernt das Präfix genau einmal. Falls derselbe Substring direkt danach noch einmal auftaucht, bleibt er stehen. Wer wiederholtes Strippen braucht, muss die Funktion in einer Schleife aufrufen oder ein anderes Werkzeug wählen.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// "ab" wird nur einmal entfernt
	fmt.Printf("%q\n", strings.TrimPrefix("ababcd", "ab"))

	// Wiederholtes Strippen via Schleife
	s := "ababcd"
	for strings.HasPrefix(s, "ab") {
		s = strings.TrimPrefix(s, "ab")
	}
	fmt.Printf("%q\n", s)
}

"abcd"
"cd"

Der erste Aufruf entfernt nur das erste "ab" und lässt das zweite stehen — das Ergebnis ist "abcd". Die Schleifenvariante wiederholt den Aufruf, solange HasPrefix true liefert, und entfernt damit alle führenden Wiederholungen. Diese Konstruktion ist allokationsfrei, weil jeder Schleifendurchlauf nur den Slice-Header verschiebt.

Ein leerer prefix ist ein gültiger Aufruf und führt zu einem No-Op: der String wird unverändert zurückgegeben. Das matcht die mathematische Definition — jeder String beginnt mit dem leeren Substring, aber das Abschneiden von null Bytes ändert nichts.

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.TrimPrefix("hallo", ""))
	fmt.Printf("%q\n", strings.TrimPrefix("", ""))
	fmt.Printf("%q\n", strings.TrimPrefix("", "abc"))
}

"hallo"
""
""

Auch der leere Eingabestring ist unproblematisch — er beginnt mit jedem leeren Präfix (Ergebnis: leer) und mit keinem nicht-leeren Präfix (Ergebnis: ebenfalls leer, unverändert). Es gibt keine Panics, keine Sonderfälle, die Funktion ist auf allen Eingaben definiert.

Diese drei Funktionen lösen verwandte Probleme, unterscheiden sich aber in dem, was sie zurückgeben. Die Wahl hängt davon ab, ob nur das gestrippte Ergebnis, eine Erfolgsmeldung oder beides gebraucht wird.

CutPrefix ist seit Go 1.20 verfügbar und ersetzt das alte Idiom if HasPrefix { TrimPrefix } durch einen einzigen, allokationsfreien Aufruf. Wer nicht auf Go 1.20+ angewiesen ist oder die Erfolgsinformation nicht braucht, kann weiterhin bequem TrimPrefix verwenden — beide Funktionen sind so eng verwandt, dass der Wechsel trivial bleibt.

TrimPrefix ist eine der billigsten Funktionen im strings-Paket. Im Match-Fall wird der Bytevergleich byteweise bis zur Länge len(prefix) durchgeführt und dann ein neuer Slice-Header s[len(prefix):] über demselben Backing-Array zurückgegeben — keine Kopie, keine Heap-Allokation, nur Pointer-Arithmetik. Im Kein-Match-Fall wird sofort der Originalstring zurückgegeben, ebenfalls ohne Allokation.

In Hot-Paths wie URL-Routing, Header-Parsing oder Schlüsselnormalisierung ist TrimPrefix damit praktisch kostenlos. Wer trotzdem benchmarkt, sollte beachten, dass der Compiler den Funktionsaufruf in vielen Fällen inlinen kann — der reale Overhead landet oft bei Null Nanosekunden pro Aufruf.

Ein typisches Anwendungsfeld ist das Aufbereiten von URLs für die Anzeige. Nutzer wollen in einer Liste meist nicht https://example.com/seite sehen, sondern nur die Domain mit Pfad. TrimPrefix ist hier ideal, weil es beide Fälle (mit und ohne Schema) gleich behandelt.

package main

import (
	"fmt"
	"strings"
)

func displayURL(u string) string {
	u = strings.TrimPrefix(u, "https://")
	u = strings.TrimPrefix(u, "http://")
	u = strings.TrimPrefix(u, "www.")
	return u
}

func main() {
	urls := []string{
		"https://example.com/start",
		"http://example.com/start",
		"www.example.com",
		"example.com",
	}
	for _, u := range urls {
		fmt.Printf("%-30s -> %s\n", u, displayURL(u))
	}
}

https://example.com/start      -> example.com/start
http://example.com/start       -> example.com/start
www.example.com                -> example.com
example.com                    -> example.com

Die Funktion arbeitet sich durch eine Kette von möglichen Präfixen. Jeder Aufruf ist ein No-Op, falls das Präfix fehlt — es gibt also keinen Grund, vorher mit HasPrefix zu prüfen. Der letzte Fall (example.com ohne jedes Präfix) durchläuft alle drei TrimPrefix-Aufrufe und bleibt komplett unverändert.

Beim Einlesen von Umgebungsvariablen oder Konfigurationsschlüsseln ist oft ein gemeinsames Präfix wie MIBEON_, APP_ oder ENV_ vorhanden, das vor der weiteren Verarbeitung verschwinden soll. TrimPrefix macht das in einer Zeile, sauber und ohne Sonderfall für fehlende Präfixe.

package main

import (
	"fmt"
	"strings"
)

func normalizeKey(key string) string {
	key = strings.TrimPrefix(key, "ENV_")
	return strings.ToLower(key)
}

func main() {
	keys := []string{
		"ENV_DATABASE_URL",
		"ENV_PORT",
		"DEBUG", // kein ENV_-Präfix
	}
	for _, k := range keys {
		fmt.Printf("%-20s -> %s\n", k, normalizeKey(k))
	}
}

ENV_DATABASE_URL     -> database_url
ENV_PORT             -> port
DEBUG                -> debug

Der Schlüssel DEBUG hat kein ENV_-Präfix und bleibt deshalb beim TrimPrefix-Aufruf unverändert. Anschließend wird er ganz normal kleingeschrieben. Genau dieses Verhalten — fehlendes Präfix ist kein Fehler, sondern ein No-Op — macht TrimPrefix so angenehm in Pipelines, in denen die Eingabeformate gemischt sein können.

Weiterführende Ressourcen

Externe Quellen

• strings.TrimPrefix
• strings.CutPrefix (Go 1.20+)

Verwandte Artikel

• strings-Paket — Übersicht
• strings.TrimLeft — Cutset-Variante
• strings.HasPrefix — nur prüfen
• strings.CutPrefix — mit Erfolgs-Flag