fmt.Print — positional nach Stdout, ohne Newline

Signatur

fmt.Print ist eine variadische Funktion: func Print(a ...any) (n int, err error). Sie nimmt beliebig viele Argumente beliebigen Typs entgegen und schreibt sie ohne Formatierungsanweisung nach os.Stdout. Die Rückgabe besteht aus der Anzahl tatsächlich geschriebener Bytes sowie einem error-Wert, der bei os.Stdout praktisch nie auftritt, aber Teil des einheitlichen Print-Vertrags ist.

Im Vergleich zu Printf fehlt der erste format string-Parameter, im Vergleich zu Println fehlt das angehängte Newline. Die variadische Signatur ...any (in älterem Code ...interface{}) erlaubt jede Mischung von Typen — Strings, Zahlen, Structs, Slices — die intern über die %v-Standardformatierung dargestellt werden.

Die Leerzeichen-Regel

Das überraschendste Detail von fmt.Print ist seine Whitespace-Heuristik: Leerzeichen werden zwischen zwei aufeinanderfolgenden Operanden nur dann automatisch eingefügt, wenn keiner der beiden Operanden ein String ist. Sobald einer der beiden ein String ist, werden die Werte ohne Trennzeichen direkt konkateniert — eine Regel, die in keiner anderen weit verbreiteten Print-Funktion so existiert.

Diese Regel wirkt willkürlich, hat aber einen pragmatischen Hintergrund: Strings enthalten oft selbst schon Whitespace (Doppelpunkte, Leerzeichen, Bindestriche), während rohe Zahlen oder Booleans visuell zusammenkleben würden, wenn sie ohne Trenner gedruckt würden.

package main

import "fmt"

func main() {
    fmt.Print("a", "b")
    fmt.Print("\n")
    fmt.Print(1, 2)
    fmt.Print("\n")
    fmt.Print("a", 1)
    fmt.Print("\n")
    fmt.Print(1, "b")
    fmt.Print("\n")
    fmt.Print(1, 2, 3)
    fmt.Print("\n")
    fmt.Print(1, "x", 2)
    fmt.Print("\n")
}

ab
1 2
a1
1b
1 2 3
1x2

Beachtenswert ist der letzte Fall: Sobald ein einziger String zwischen Nicht-String-Operanden steht, fallen alle Leerzeichen weg — die Regel wird paarweise zwischen direkten Nachbarn ausgewertet. Wer hier zuverlässig Trennzeichen will, muss sie explizit selbst einbauen oder direkt zu Println oder Printf greifen.

Vergleich zu Println

Println macht zwei Dinge, die Print nicht macht: Es fügt immer ein Leerzeichen zwischen je zwei Operanden ein — unabhängig davon, ob es Strings sind oder nicht — und hängt am Ende immer ein \n an.

package main

import "fmt"

func main() {
    fmt.Print("Hallo", "Welt", 42)
    fmt.Print("\n--\n")
    fmt.Println("Hallo", "Welt", 42)
    fmt.Print("--\n")
    fmt.Printf("%v %v %v\n", "Hallo", "Welt", 42)
}

HalloWelt42
--
Hallo Welt 42
--
Hallo Welt 42

Print liefert HalloWelt42 ohne jedes Trennzeichen, weil zwei der drei Operanden Strings sind und damit die Whitespace-Heuristik komplett ausschaltet. Println setzt zwischen jedes Paar ein Space und schließt mit \n ab — genau das Verhalten, das in 90 % der Debugging-Sessions gewünscht ist.

Vergleich zu Printf

Printf ist das genaue Gegenstück zu Print: ein Format-String steuert exakt, wie jeder Operand gerendert wird, welche Trenner dazwischen stehen und ob am Ende ein Newline kommt. Während Print mit einer impliziten und teilweise überraschenden Regel arbeitet, ist bei Printf jedes Whitespace und jedes Zeichen vom Aufrufer kontrolliert.

Die praktische Daumenregel: Printf ist die richtige Wahl, sobald man Werte mit Kontext ausgibt ("x = %d, y = %d"), Breiten oder Präzisionen braucht oder eine bestimmte Reihenfolge mit %[N]v referenziert. Print lohnt sich nur dann, wenn man tatsächlich genau die Whitespace-Heuristik will — was selten ist — oder wenn man bewusst kein Newline an den Output anhängen möchte.

Häufige Verwirrung

Die häufigste Stolperfalle ist die Erwartung, fmt.Print verhielte sich wie Pythons print() oder JavaScripts console.log() — also mit automatischem Leerzeichen zwischen allen Argumenten. In Go ist das genau dann nicht der Fall, wenn mindestens einer der direkten Nachbarn ein String ist.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Print("Hallo", "Welt", "\n")
    fmt.Println("Hallo", "Welt")
    fmt.Printf("%s %s\n", "Hallo", "Welt")

    worte := []string{"Hallo", "Welt", "aus", "Go"}
    fmt.Println(strings.Join(worte, " "))
}

HalloWelt
Hallo Welt
Hallo Welt
Hallo Welt aus Go

Welche der drei Lösungen passt, hängt vom Kontext ab: Println ist die schnellste Korrektur, Printf der saubere Weg bei festen Strukturen und strings.Join die richtige Antwort, wenn eine variable Anzahl an Strings mit immer demselben Trenner verbunden werden soll.

Rückgabewerte

Wie bei Printf und Println liefert Print ein Paar aus geschriebenen Bytes und einem error zurück. In den allermeisten Programmen werden beide Werte stillschweigend verworfen, weil der Output nach os.Stdout geht und ein Fehler dort nur in absoluten Ausnahmesituationen — etwa bei geschlossenem Deskriptor — überhaupt auftritt.

Relevant werden die Rückgabewerte erst, wenn man die Print-Logik auf andere Writer übertragen will. Genau dafür existiert fmt.Fprint, das denselben Whitespace-Algorithmus benutzt, aber gegen ein beliebiges io.Writer-Ziel schreibt.

Wann Print wirklich Sinn macht

Es gibt drei Situationen, in denen Print die objektiv bessere Wahl gegenüber Println oder Printf ist, und alle drei haben einen gemeinsamen Nenner: Man will kein Newline am Ende. Der erste Use Case ist die schlichte Konkatenation ohne Format-String. Der zweite ist die Aktualisierung derselben Zeile per \r-Carriage-Return — typisch für Spinner und Progress-Bars. Der dritte sind Tools, deren Output in eine Shell-Pipeline geht und deren letzte Zeile bewusst ohne abschließendes \n enden soll.

Praxis 1 — Spinner-Output

Ein klassischer Anwendungsfall ohne Newline ist ein Loading-Indikator, der immer dieselbe Zeile im Terminal überschreibt. Dafür schreibt man am Anfang jeder Aktualisierung ein \r (Carriage Return), das den Cursor an den Zeilenanfang setzt, ohne in die nächste Zeile zu springen.

package main

import (
    "fmt"
    "time"
)

func main() {
    frames := []rune{'|', '/', '-', '\\'}
    for i := 0; i <= 100; i += 25 {
        frame := frames[(i/25)%len(frames)]
        fmt.Print("\rFortschritt ", string(frame), " ", i, "%")
        time.Sleep(50 * time.Millisecond)
    }
    fmt.Println()
}

Fortschritt \ 100%

Im Terminal sieht man während des Laufs jede Zwischenstufe an derselben Position — gespeichert bleibt am Ende nur die letzte Zeile. Das abschließende fmt.Println() ohne Argumente sorgt dafür, dass der Cursor nach Ende des Spinners in die nächste Zeile springt.

Praxis 2 — Pipe-freundlicher Output

Kommandozeilen-Tools, deren Output in eine Shell-Pipeline weitergereicht wird, profitieren manchmal davon, kein abschließendes Newline zu schreiben.

package main

import "fmt"

func main() {
    id := "550e8400-e29b-41d4-a716-446655440000"
    fmt.Print(id)
}

550e8400-e29b-41d4-a716-446655440000

Aufgerufen als go run uuid-pipe.go | pbcopy landet exakt die UUID in der Zwischenablage — ohne ein angehängtes Newline, das in vielen Eingabefeldern als unsichtbares Zeichen Probleme macht.

Weiterführende Ressourcen

Externe Quellen

• fmt.Print
• fmt package — Printing
• Effective Go: Printing

Verwandte Artikel

• fmt-Paket — Übersicht
• fmt.Println — mit Newline
• fmt.Printf — mit Format-String
• fmt.Fprintf — auf io.Writer
• Format-Verben — Referenz