fmt.Fprintln — positional auf Writer, mit Newline

Signatur

func Fprintln(w io.Writer, a ...any) (n int, err error) — folgt dem typischen Muster der Fprint*-Familie: zuerst der Ziel-Writer, danach die Operanden als variadische any-Liste.

Drei Bestandteile prägen den Aufruf. Der erste Parameter w ist ein io.Writer — also alles, was eine Write([]byte) (int, error)-Methode hat. Danach folgt die variadische Argumentliste, die Fprintln mit dem Standardverb %v formatiert. Zurück kommt die Anzahl geschriebener Bytes sowie ein error — wichtig immer dann, wenn der Writer auch tatsächlich fehlschlagen kann.

Verhalten

Fprintln verhält sich für die Operanden exakt wie Println — nur das Ziel ist konfigurierbar. Zwischen je zwei Operanden fügt es immer ein Leerzeichen ein, am Ende immer ein \n.

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Fprintln(os.Stdout, "user", 42, true)
	fmt.Fprintln(os.Stdout, "next", "line")
}

user 42 true
next line

Drei Operanden, zwei dazwischenliegende Spaces, ein abschließendes Newline. Jeder Aufruf produziert genau eine Zeile.

Vergleich zu Fprintf

Fprintf erwartet einen Format-String mit Verben (%d, %s, %v, …) und gibt nur das aus, was dort steht — keine impliziten Spaces, keine implizites Newline. Fprintln kennt keinen Format-String, formatiert jedes Argument mit %v und garantiert Spaces plus Newline.

Faustregel: Sobald die Ausgabe ein klares Muster braucht — Spalten, Padding, Hex, Anführungszeichen, ein definiertes Layout — gehört es in Fprintf. Sobald es nur darum geht, ein paar Werte zusammen mit einer Beschreibung in eine Zeile zu kippen, ist Fprintln kürzer und weniger fehleranfällig.

Häufigster Use Case: Fehler nach Stderr

In CLI-Tools ist fmt.Fprintln(os.Stderr, …) das vermutlich am häufigsten getippte Fprintln-Muster überhaupt. Es trennt Diagnose-Output strikt vom eigentlichen Ergebnis und ist dabei deutlich kürzer als die Fprintf-Variante mit %v.

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	err := errors.New("connection refused")

	fmt.Fprintln(os.Stderr, "fehler:", err)
	fmt.Fprintf(os.Stderr, "fehler: %v\n", err)
}

fehler: connection refused
fehler: connection refused

Beide Zeilen erzeugen dieselbe Ausgabe — Fprintln spart aber das Format-Verb und das explizite \n. Bei einer einzelnen Zeile wirkt der Unterschied klein, in einem CLI-Tool mit Dutzenden Fehlerpfaden summiert sich der Effekt.

Error-Handling

Wie alle Fprint*-Funktionen liefert Fprintln (n int, err error). Bei os.Stdout und os.Stderr im normalen Terminal-Betrieb ignoriert man die Rückgabe in der Regel. Sobald aber Netzwerk-Writer (net.Conn, http.ResponseWriter), Datei-Writer mit potenziell vollem Dateisystem oder Pipe-Writer im Spiel sind, deren Gegenstelle wegbricht, sollte der Fehler geprüft werden.

package main

import (
	"fmt"
	"net"
)

func sendBanner(c net.Conn) error {
	if _, err := fmt.Fprintln(c, "WELCOME", "mibeon-service"); err != nil {
		return fmt.Errorf("banner senden: %w", err)
	}
	return nil
}

Beim Netzwerk-Writer kann ein abgebrochener Client die Write-Operation in einen Fehler kippen — wer das ignoriert, schreibt fröhlich weiter ins Nichts.

CLI-Tool mit Stdout-Result und Stderr-Diagnose

Ein typisches kleines Tool soll eine Datei einlesen, ihre Zeilen zählen und das Ergebnis nach Stdout schreiben — alle Status- und Fehlermeldungen aber strikt nach Stderr.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	if len(os.Args) < 2 {
		fmt.Fprintln(os.Stderr, "usage: zaehler <datei>")
		os.Exit(2)
	}

	path := os.Args[1]
	f, err := os.Open(path)
	if err != nil {
		fmt.Fprintln(os.Stderr, "öffnen fehlgeschlagen:", err)
		os.Exit(1)
	}
	defer f.Close()

	fmt.Fprintln(os.Stderr, "lese datei:", path)

	count := 0
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		count++
	}

	fmt.Println(count)
}

Die Trennung der Kanäle zahlt sich beim Verketten aus: zaehler /tmp/beispiel.txt | awk '{print $1*2}' sieht nur die Zahl — die Diagnose-Zeile landet im Terminal, nicht in der Pipe.

Mini-Logger in Datei

Wer einen schmalen, zeilenbasierten Event-Logger braucht — ohne log/slog, ohne externes Paket — bekommt mit os.OpenFile plus fmt.Fprintln ein erstaunlich brauchbares Werkzeug.

package main

import (
	"fmt"
	"os"
	"time"
)

func main() {
	logFile, err := os.OpenFile(
		"/tmp/events.log",
		os.O_APPEND|os.O_CREATE|os.O_WRONLY,
		0o644,
	)
	if err != nil {
		fmt.Fprintln(os.Stderr, "log öffnen:", err)
		os.Exit(1)
	}
	defer logFile.Close()

	events := []struct {
		user   string
		action string
	}{
		{"alice", "login"},
		{"bob", "upload"},
		{"alice", "logout"},
	}

	for _, e := range events {
		ts := time.Now().Format(time.RFC3339)
		fmt.Fprintln(logFile, ts, e.user, e.action)
	}
}

Jede Event-Zeile entsteht aus genau einem Fprintln-Aufruf: Zeitstempel, Benutzer, Aktion — automatisch mit Leerzeichen getrennt und durch Newline abgeschlossen. Für strukturiertes Logging mit Levels und Kontext führt langfristig kein Weg an log/slog vorbei; für ein einfaches Append-Log einer kleinen CLI ist diese Variante unschlagbar kurz.

Weiterführende Ressourcen

Externe Quellen

• fmt.Fprintln
• io.Writer
• os.Stderr

Verwandte Artikel

• fmt-Paket — Übersicht
• fmt.Println — auf Stdout
• fmt.Fprintf — mit Format-String