strings.Map — Rune-für-Rune transformieren

Die Signatur ist kompakt und nimmt eine Mapping-Funktion als erstes Argument entgegen, gefolgt vom Eingabestring.

func Map(mapping func(rune) rune, s string) string

Die Reihenfolge ist bewusst so gewählt, dass Closures direkt am Aufrufort inline definiert werden können und die Mapping-Logik am Anfang sichtbar steht. Der Eingabestring s kommt zuletzt — das passt zum typischen Pipeline-Stil, wo Daten am Ende übergeben werden.

Das wichtigste Detail der Semantik: gibt mapping einen negativen rune-Wert zurück, wird die ursprüngliche Rune aus dem Ergebnis entfernt. Idiomatisch wird dafür -1 verwendet, aber jeder negative Wert funktioniert. Damit lassen sich Filter und Transformation in einer einzigen Funktion kombinieren.

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	// Alle Whitespaces entfernen, sonst unverändert lassen
	stripWS := func(r rune) rune {
		if unicode.IsSpace(r) {
			return -1
		}
		return r
	}

	s := "Hallo  Welt\tmit\nUmbrüchen"
	fmt.Println(strings.Map(stripWS, s))
}

HalloWeltmitUmbrüchen

Der Mechanismus ist elegant, weil derselbe Funktionswert sowohl „keep" (positive Rune zurückgeben) als auch „drop" (negative Rune zurückgeben) und „transform" (andere positive Rune zurückgeben) ausdrücken kann. Es gibt keinen separaten Filter-Schritt — ein Aufruf, ein Pass über den String.

strings.Map iteriert über den Eingabestring rune-weise, nicht byte-weise. Das ist der entscheidende Unterschied zu bytes.Map und macht die Funktion UTF-8-sicher. Multi-Byte-Sequenzen werden als ein einzelner rune-Wert an die Mapping-Funktion übergeben.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Jede Rune wird einmal aufgerufen — auch Umlaute und Emoji
	count := 0
	strings.Map(func(r rune) rune {
		count++
		fmt.Printf("rune #%d = %q (%U)\n", count, r, r)
		return r
	}, "Hä!🚀")
}

rune #1 = 'H' (U+0048)
rune #2 = 'ä' (U+00E4)
rune #3 = '!' (U+0021)
rune #4 = '🚀' (U+1F680)

Ungültige UTF-8-Sequenzen im Input werden durch utf8.RuneError (U+FFFD) ersetzt, bevor die Mapping-Funktion aufgerufen wird — das schützt vor unerwarteten Byte-Mustern und stellt sicher, dass die Mapping-Logik immer mit gültigen Code-Points arbeitet.

strings.Map allokiert intern einen strings.Builder mit der Kapazität des Eingabestrings. Wenn keine Rune geändert oder entfernt wird (Identitäts-Mapping), wird trotzdem ein neuer String erzeugt — anders als bei strings.Replace, das im No-Op-Fall den Originalstring durchreicht.

Faustregel: strings.Map lohnt sich, wenn die Transformation pro Rune individuell ist und nicht durch ein fixes Pattern beschrieben werden kann. Für feste Substitutionen ist strings.Replacer schneller, weil dieser eine Trie-Suche statt eines Funktionsaufrufs pro Rune nutzt. Für ein einzelnes Substring-Replace ist strings.ReplaceAll schneller.

Ein klassischer Einsatz: aus einem Titel einen URL-tauglichen Slug bauen. Großbuchstaben werden zu Kleinbuchstaben, Leerzeichen zu Bindestrichen, alles andere wird entweder durchgereicht oder entfernt.

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func slug(s string) string {
	return strings.Map(func(r rune) rune {
		switch {
		case unicode.IsLetter(r):
			return unicode.ToLower(r)
		case unicode.IsDigit(r):
			return r
		case unicode.IsSpace(r) || r == '-':
			return '-'
		default:
			return -1
		}
	}, s)
}

func main() {
	fmt.Println(slug("Hallo Welt!"))
	fmt.Println(slug("Büro für Übersetzungen — Köln, 2026"))
}

hallo-welt
büro-für-übersetzungen--köln-2026

Das Beispiel zeigt sowohl die Transformation (ToLower), den Filter (-1 für Satzzeichen) als auch das Mapping (Whitespace zu -) in einer einzigen Funktion. Für „echte" Slugs müssten doppelte Bindestriche noch zusammengefasst und Umlaute transliteriert werden — beides idealerweise in einem zweiten Pass mit strings.ReplaceAll oder einer Transliterations-Library.

Das strings-Paket bietet strings.Map als die idiomatische Variante für character-weise Verschlüsselungen wie ROT13. Die Standardbibliothek liefert sogar strings.NewReader zusammen mit golang.org/x/text/transform — aber für eine reine Lehrbuch-Version ist strings.Map perfekt geeignet.

package main

import (
	"fmt"
	"strings"
)

func rot13(r rune) rune {
	switch {
	case r >= 'A' && r <= 'Z':
		return 'A' + (r-'A'+13)%26
	case r >= 'a' && r <= 'z':
		return 'a' + (r-'a'+13)%26
	}
	return r
}

func main() {
	enc := strings.Map(rot13, "Hallo Welt! 1234")
	fmt.Println(enc)
	fmt.Println(strings.Map(rot13, enc)) // zweimal angewandt = original
}

Unyyb Jryg! 1234
Hallo Welt! 1234

ROT13 ist symmetrisch: zweimal angewandt ergibt sich der Originalstring. Das macht das Beispiel zu einem schönen Selbsttest, weil keine separate Decode-Funktion nötig ist. Ziffern, Satzzeichen und Whitespace werden unverändert durchgereicht — die switch-Anweisung greift nur bei Buchstaben.

Weiterführende Ressourcen

Externe Quellen

• strings.Map
• bytes.Map (byte-orientiertes Pendant)
• Go Blog — Strings, bytes, runes and characters

Verwandte Artikel

• strings-Paket — Übersicht
• strings.Replacer — Multi-Substitution
• strings.ReplaceAll — Substring-Ersatz
• strings.Repeat — String wiederholen