fmt.Fscanf — Format-String aus io.Reader parsen

Signatur und Rückgabewerte

Fscanf liest aus einem io.Reader, interpretiert den Inhalt nach einem Format-String und schreibt die geparsten Werte in die übergebenen Pointer:

func Fscanf(r io.Reader, format string, a ...any) (n int, err error)

Der Rückgabewert n zählt die erfolgreich gefüllten Argumente — nicht die gelesenen Bytes. Das ist wichtig: nach einem Teilerfolg weiß der Aufrufer genau, wie weit der Parser gekommen ist, und kann gezielt reagieren. Der Fehler io.EOF signalisiert das saubere Ende des Streams. Jeder andere Fehler deutet auf einen Format-Mismatch oder einen I/O-Fehler hin.

Strukturierte Records aus einer Datei

Der klassische Anwendungsfall: eine Datei, in der jede Zeile demselben starren Schema folgt. Hier Name=<wort> Age=<zahl> — ein Format ohne Varianz, ohne optionale Felder, ohne quoting. Genau das, wofür Format-String-Parsing gemacht ist:

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	data := `Name=Alice Age=30
Name=Bob Age=25
Name=Carol Age=42
`
	r := strings.NewReader(data)

	for {
		var name string
		var age int
		_, err := fmt.Fscanf(r, "Name=%s Age=%d\n", &name, &age)
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("Parse-Fehler:", err)
			break
		}
		fmt.Printf("%-6s -> %d Jahre\n", name, age)
	}
}

Alice  -> 30 Jahre
Bob    -> 25 Jahre
Carol  -> 42 Jahre

Die Schleife läuft, bis Fscanf io.EOF zurückgibt. Jeder andere Fehler wird sichtbar protokolliert. Der Reader ist hier ein strings.NewReader, kann aber genauso gut ein *os.File, ein net.Conn oder ein bufio.Reader sein — die Funktion sieht den Unterschied nicht.

Welche Verben gelten

Die Verben sind identisch mit Scanf und Sscanf — die Familie teilt sich denselben Parser. Eine Kurzübersicht:

Die vollständige Tabelle mit allen Feinheiten steht auf der Referenzseite Format-Verben.

Whitespace im Format ist flexibel

Wie bei den anderen Scan-Funktionen matched ein einzelnes Leerzeichen im Format-String beliebig viel Whitespace im Input — inklusive Tabs und Zeilenumbrüchen (außer bei Fscanln). Das ist bequem, kann aber auch Stolperfalle sein:

package main

import (
	"fmt"
	"strings"
)

func main() {
	r := strings.NewReader("x=42    y=99")
	var x, y int
	n, err := fmt.Fscanf(r, "x=%d y=%d", &x, &y)
	fmt.Println(n, err, x, y)
}

2 <nil> 42 99

Mehrere Leerzeichen zwischen x=42 und y=99 stören nicht — der Parser frisst sie alle. Wer eine exakte Trennung erzwingen will, muss zu anderen Werkzeugen greifen. Format-Strings sind dafür das falsche Werkzeug.

Pointer-Pflicht

Selbstverständlich gilt auch hier: alle Ziel-Argumente sind Pointer. Wer einen Wert statt einer Adresse übergibt, bekommt zur Laufzeit einen Fehler — der Compiler kann es nicht prüfen, weil die Variadics als any durchgereicht werden:

package main

import (
	"fmt"
	"strings"
)

func main() {
	r := strings.NewReader("count=7")
	var count int
	fmt.Fscanf(r, "count=%d", count) // FALSCH: kein Pointer
	fmt.Println(count)
}

0

Der Fehler wird vom Returnwert (err) signalisiert. Wer ihn ignoriert, sieht still den Nullwert. Deshalb: err immer prüfen, gerade beim Lernen.

Wann besser bufio.Scanner + Sscanf

Die größte Schwäche von Fscanf ist die Fehlerbehandlung mitten im Stream. Sobald eine einzige Zeile vom erwarteten Format abweicht, hängt der Parser an der Fehlerstelle fest — der Reader-Cursor steht irgendwo, der Folgeaufruf scheitert oft erneut, und es gibt keine saubere Möglichkeit, „bis zur nächsten Zeile zu überspringen".

Die idiomatische Lösung in Go: bufio.Scanner segmentiert den Stream zeilenweise, und fmt.Sscanf parst jede Zeile als unabhängigen String. Vorteile dieser Trennung:

• Eine fehlerhafte Zeile bricht nur diesen einen Sscanf-Aufruf — die Schleife läuft weiter.
• Fehlerhafte Zeilen lassen sich loggen, zählen, in eine Reject-Datei schreiben.
• Der Scanner-Cursor steht nach jedem Durchlauf garantiert am Zeilenanfang.
• Tests werden einfacher: man parst Strings, keine Reader-Mocks.

Für streng formatierte, vertrauenswürdige Streams (etwa selbst erzeugte Protokolldateien zwischen eigenen Systemen) bleibt Fscanf kompakt und idiomatisch. Sobald Input aus fremder Hand kommt — Konfigurationen, Logs anderer Programme, Netzwerk-Payloads — gewinnt der Scanner-Ansatz.

Strukturierte Logzeilen mit Fscanf parsen

Eine realistische Situation: ein kleiner Service schreibt strukturierte Logs in einem festen Schema. Datum in eckigen Klammern, Level, dann module=<name> und msg=<wort>. Solange das Format stabil ist, ist Fscanf ein direkter, lesbarer Weg:

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	log := `[2026-05-22] WARN module=auth msg=token_expired
[2026-05-22] INFO module=http msg=request_ok
[2026-05-22] ERROR module=db msg=connection_lost
`
	r := strings.NewReader(log)

	for {
		var date, level, module, msg string
		_, err := fmt.Fscanf(r,
			"[%s %s module=%s msg=%s\n",
			&date, &level, &module, &msg,
		)
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("Parse-Abbruch:", err)
			break
		}
		// %s liest bis Whitespace; das schließende ']' bleibt am date hängen.
		date = strings.TrimSuffix(date, "]")
		fmt.Printf("%-5s %-6s %s\n", level, module, msg)
	}
}

WARN  auth   token_expired
INFO  http   request_ok
ERROR db     connection_lost

Beachte das kleine Detail mit der schließenden eckigen Klammer: %s liest bis zum nächsten Whitespace und nimmt das ] mit. Das muss anschließend von Hand getrimmt werden. Genau diese Art von Mikro-Reibung ist es, die Fscanf in der Praxis spröde macht — der Parser kennt keine Trennzeichen außer Whitespace.

Dieselbe Datei mit bufio.Scanner + Sscanf

Derselbe Input, derselbe Output — aber mit einer Architektur, die einzelne kaputte Zeilen verzeiht:

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	log := `[2026-05-22] WARN module=auth msg=token_expired
[2026-05-22] INFO module=http msg=request_ok
GARBAGE-ZEILE-OHNE-FORMAT
[2026-05-22] ERROR module=db msg=connection_lost
`
	scanner := bufio.NewScanner(strings.NewReader(log))
	rejected := 0

	for scanner.Scan() {
		line := scanner.Text()

		var date, level, module, msg string
		_, err := fmt.Sscanf(line,
			"[%s %s module=%s msg=%s",
			&date, &level, &module, &msg,
		)
		if err != nil {
			rejected++
			continue // diese Zeile überspringen, weitermachen
		}
		date = strings.TrimSuffix(date, "]")
		fmt.Printf("%-5s %-6s %s\n", level, module, msg)
	}
	fmt.Printf("(%d Zeilen verworfen)\n", rejected)
}

WARN  auth   token_expired
INFO  http   request_ok
ERROR db     connection_lost
(1 Zeilen verworfen)

Die Garbage-Zeile mittendrin bringt die Pipeline nicht aus dem Tritt — sie wird gezählt, übersprungen, und der Rest läuft sauber durch. Diese Robustheit ist der Grund, warum erfahrene Go-Entwickler diesen Ansatz fast reflexhaft wählen. Fscanf direkt auf dem Reader hat seinen Platz, aber er ist enger als man zunächst denkt.

Weiterführende Ressourcen

Externe Quellen

• fmt.Fscanf
• io.Reader
• bufio.Scanner

Verwandte Artikel

• fmt-Paket — Übersicht
• fmt.Fscan — ohne Format-String
• fmt.Fscanln — am Newline stoppen
• fmt.Sscanf — aus String
• Format-Verben — Referenz