Das strconv-Paket — String-Zahl-Konvertierung

strconv lässt sich in fünf klare Funktionsgruppen einteilen — drei für Zahlen, eine für Go-Literale, eine für Rune-Klassifizierung. Dazu kommt der zentrale Fehler-Typ.

Gruppe	Zweck	Hauptvertreter
Parse	String → Zahl/Bool	ParseInt, ParseFloat, ParseBool
Format	Zahl/Bool → String	FormatInt, FormatFloat, FormatBool
Append	Zahl/Bool an []byte anhängen	AppendInt, AppendFloat, AppendQuote
Quote/Unquote	Go-String-Literale	Quote, Unquote, QuoteRune
Rune-Check	Druckbarkeit, Backquote-Eignung	IsPrint, IsGraphic, CanBackquote

Die Append*-Familie ist nicht nur ein zweiter Weg — sie ist der Hot-Path-Standard, weil sie einen vorhandenen []byte-Puffer wiederverwendet und damit ohne Allokation auskommt.

Beide Pakete können Zahlen in Strings umwandeln — aber sie zielen auf unterschiedliche Szenarien. fmt glänzt mit dynamischen Format-Strings und gemischten Argument-Listen; strconv glänzt mit Geschwindigkeit und API-Präzision für genau einen Wert.

Aufgabe	Empfehlung
Einzelne Zahl in String	strconv.FormatInt / Itoa
Mehrere Werte mit Layout	fmt.Sprintf
Hot-Path-Serializer (Logger, JSON)	strconv.Append*
User-Input parsen	strconv.Parse* mit NumError-Handling
Debug-Dump mit Escapes	strconv.Quote

Faustregel: alles, was sich mit einem %d, %f, %t oder %q beschreiben ließe, ist in strconv schneller und klarer.

Die kürzesten Wege zwischen string und int. Beide Funktionen sind dünne Hüllen um ParseInt(s, 10, 0) bzw. FormatInt(int64(n), 10) — handlich, aber ohne Basis- oder bitSize-Kontrolle.

• strconv.Atoi — String → int (dezimal).
• strconv.Itoa — int → String (dezimal).

Die volle Konvertierungs-API mit Basis-Wahl (2–36 oder 0 für Auto-Erkennung), bitSize für Range-Checks, und strukturierten Fehlern via NumError.

• strconv.ParseInt — vorzeichenbehaftete Zahl mit Basis.
• strconv.ParseUint — vorzeichenlose Zahl mit Basis.
• strconv.ParseFloat — Float inkl. Hex-Floats, NaN, Inf.
• strconv.ParseBool — 1/0, t/f, true/false.
• strconv.ParseComplex — komplexe Zahl (Go 1.15+).

Spiegelbild zu Parse*. Alle erzeugen einen neuen String pro Aufruf — für Hot-Paths besser Append* nutzen.

• strconv.FormatInt — int64 → String mit Basis. (in Vorbereitung)
• strconv.FormatUint — uint64 → String mit Basis. (in Vorbereitung)
• strconv.FormatFloat — Float mit Verb, Präzision, bitSize. (in Vorbereitung)
• strconv.FormatBool — true/false. (in Vorbereitung)
• strconv.FormatComplex — komplexe Zahl (Go 1.15+). (in Vorbereitung)

Hängen die Textdarstellung an einen vorhandenen []byte an. Bei ausreichender Kapazität: null Allokationen. Das Muster steckt unter der Haube von encoding/json, slog, zap und allem, was auf Durchsatz getunt ist.

• strconv.AppendInt — wie FormatInt, aber an []byte. (in Vorbereitung)
• strconv.AppendUint — wie FormatUint, aber an []byte. (in Vorbereitung)
• strconv.AppendFloat — wie FormatFloat, aber an []byte. (in Vorbereitung)
• strconv.AppendBool — wie FormatBool, aber an []byte. (in Vorbereitung)

Verpackt Strings in Go-Literal-Form mit Anführungszeichen und Escapes. Drei Varianten: Quote (klassisch), QuoteToASCII (nicht-ASCII als \uXXXX) und QuoteToGraphic (nur druckbare Zeichen unverändert).

• strconv.Quote — String → Go-Literal. (in Vorbereitung)
• strconv.QuoteToASCII — wie Quote, alles Nicht-ASCII escapen. (in Vorbereitung)
• strconv.QuoteToGraphic — wie Quote, nur graphic Runen lassen. (in Vorbereitung)
• strconv.QuoteRune — Rune → Go-Rune-Literal. (in Vorbereitung)
• strconv.QuoteRuneToASCII — Rune-Literal als reines ASCII. (in Vorbereitung)
• strconv.QuoteRuneToGraphic — Rune-Literal, graphic erhalten. (in Vorbereitung)

Wie die Quote*-Funktionen, aber an einen []byte angehängt — Hot-Path-tauglich.

• strconv.AppendQuote — Quote an []byte. (in Vorbereitung)
• strconv.AppendQuoteToASCII — QuoteToASCII an []byte. (in Vorbereitung)
• strconv.AppendQuoteToGraphic — QuoteToGraphic an []byte. (in Vorbereitung)
• strconv.AppendQuoteRune — QuoteRune an []byte. (in Vorbereitung)
• strconv.AppendQuoteRuneToASCII — QuoteRuneToASCII an []byte. (in Vorbereitung)
• strconv.AppendQuoteRuneToGraphic — QuoteRuneToGraphic an []byte. (in Vorbereitung)

Umkehrung der Quote-Familie: nimmt einen Go-Literal-String und liefert den enthaltenen Wert. Erkennt "…", `…` (Raw-String) und '…' (Rune).

• strconv.Unquote — Go-Literal → String. (in Vorbereitung)
• strconv.UnquoteChar — eine Rune aus einem Literal lesen. (in Vorbereitung)

Hilfsfunktionen rund um Druckbarkeit und Quote-Strategien. CanBackquote entscheidet, ob ein String unverändert in ` … ` passt; IsPrint und IsGraphic sind die Prädikate hinter QuoteToASCII und QuoteToGraphic.

• strconv.IsPrint — Rune ist druckbar (Letter, Mark, Number, Punct, Symbol, ASCII-Space). (in Vorbereitung)
• strconv.IsGraphic — Rune ist „graphic" (alles IsPrint plus weitere Spaces). (in Vorbereitung)
• strconv.CanBackquote — String kann als Raw-String-Literal stehen. (in Vorbereitung)

Alle Parse*-Funktionen geben bei Fehler einen *strconv.NumError zurück. Über errors.Is lassen sich ErrSyntax (Eingabe formal falsch) und ErrRange (Wert außerhalb bitSize) sauber trennen.

• strconv.NumError — strukturierter Fehler-Typ. (in Vorbereitung)
• strconv.ErrSyntax — Sentinel: ungültige Eingabe. (in Vorbereitung)
• strconv.ErrRange — Sentinel: Wert zu groß/klein. (in Vorbereitung)
• strconv.IntSize — Konstante: native int-Breite (32 oder 64). (in Vorbereitung)

---

Interessantes

Atoi für int, ParseInt für Kontrolle

strconv.Atoi ist die kurze Variante für plattformnatives int. Sobald die Zielgröße (int8, int32, int64) oder eine andere Basis gebraucht wird, ist ParseInt(s, base, bitSize) der richtige Einstieg.

base 0 erkennt Präfixe automatisch

Mit ParseInt(s, 0, 64) liest Go 0x, 0o und 0b automatisch als hex, oktal und binär. Praktisch für Konfigurations-Werte, in denen Nutzer die Schreibweise wählen dürfen.

FormatFloat mit prec=-1

Der Sonderwert -1 produziert die kürzeste Darstellung, aus der ParseFloat den ursprünglichen Float bit-exakt rekonstruieren kann. Standardwahl für jede persistente Float-Serialisierung.

Append* in Hot Paths

Die Append*-Varianten schreiben in einen vorhandenen []byte und allokieren bei ausreichender Kapazität nichts. Pflicht in Serializern, Loggern und allem, was auf Durchsatz getunt ist.

strconv schlägt fmt.Sprintf um Faktor 3-10

Ohne Reflection und Format-String-Parsing arbeitet strconv deutlich schneller als fmt.Sprintf. Bei simplen Konvertierungen ist strconv immer die richtige Wahl — fmt glänzt nur, wenn das Format dynamisch oder gemischt ist.

ParseBool akzeptiert nur konkrete Tokens

Erlaubt sind ausschließlich 1/0, t/f, T/F und die Wörter true/false in drei Schreibweisen. „yes", „on", „y" gibt es nicht — wer das braucht, baut einen eigenen Wrapper.

errors.Is gegen ErrSyntax vs. ErrRange

Beide Sentinel-Errors haben verschiedene Bedeutungen: Syntax = Eingabe formal falsch, Range = formal okay aber zu groß. errors.Is(err, strconv.ErrRange) trennt sie zuverlässig.

strconv.Quote für Debug-Ausgabe

Quote macht Steuerzeichen, Anführungszeichen und unsichtbare Whitespaces sichtbar — exakt im Go-Literal-Stil. Erste Wahl, wenn User-Strings in Logs landen sollen.

Weiterführende Ressourcen

Externe Quellen

• strconv — Paket-Dokumentation
• strconv.NumError
• Go Blog — Strings, bytes, runes and characters
• IEEE 754 (Wikipedia)

Verwandte Artikel

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