Wie man JSON in Go schön ausgibt: vollständiger Leitfaden mit Beispielen

Warum sieht JSON in Go wie ein Chaos aus und wie behebt man das?

Haben Sie jemals ein Go-Programm geschrieben, das JSON ausgibt, und im Terminal so etwas erhalten?

{"name":"PythonLib","year":2025,"tags":["go","json","tutorial"],"active":true}

Geben Sie zu, das ohne spezielle Werkzeuge zu lesen, ist kein Vergnügen. Besonders wenn die Datenstruktur komplex ist und die Verschachtelung mehrere Ebenen tief geht. Die Augen beginnen zu wandern, und das Auffinden des gewünschten Feldes wird zur echten Herausforderung.

Die gute Nachricht: Go bietet integrierte Mittel, die dieses „Chaos“ in ein sauberes, strukturiertes Dokument verwandeln. Und heute werden wir alle Möglichkeiten durchgehen, JSON schön zu formatieren – von der einfachen Nutzung der Standardbibliothek bis zur Erstellung eines eigenen Pretty-print-Werkzeugs.

Dieses Material basiert auf einer echten Frage auf Stack Overflow (über 50.000 Aufrufe), das Thema ist also wirklich gefragt. Los geht's!

Was ist Pretty-print und wozu braucht man es?

Pretty-print (oder „schöner Druck“) ist die Formatierung von Daten mit Einrückungen, Zeilenumbrüchen und Ausrichtung, damit sie für Menschen lesbar sind. Im Kontext von JSON bedeutet das:

\n
• Hinzufügen von Leerzeichen oder Tabulatoren für verschachtelte Elemente
\n
• Umbrüche jedes Schlüssel-Wert-Paares in eine neue Zeile
\n
• Ausrichtung von Werten zur besseren Übersichtlichkeit
\n

Wozu braucht man das in Go? Stellen Sie sich vor, Sie debuggen eine API-Antwort, schreiben einen Logger oder geben einfach eine Konfiguration aus. Unformatierter JSON nimmt weniger Platz ein, ist aber völlig unlesbar. Pretty-print löst dieses Problem mit ein paar Zeilen Code.

Methode 1: json.MarshalIndent – die Standardlösung

Der einfachste und empfohlene Weg ist die Verwendung der Funktion json.MarshalIndent aus dem Standardpaket encoding/json. Sie macht genau das, was nötig ist: Sie nimmt Daten entgegen und gibt formatierten JSON mit Einrückungen zurück.

Hier ist ein einfaches Beispiel:

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n    "log"\n)\n\ntype Site struct {\n    Name   string   `json:"name"`\n    Year   int      `json:"year"`\n    Tags   []string `json:"tags"`\n    Active bool     `json:"active"`\n}\n\nfunc main() {\n    site := Site{\n        Name:   "PythonLib",\n        Year:   2025,\n        Tags:   []string{"go", "json", "tutorial"},\n        Active: true,\n    }\n\n    // Präfix — "", Einrückung — "  " (zwei Leerzeichen)\n    prettyJSON, err := json.MarshalIndent(site, "", "  ")\n    if err != nil {\n        log.Fatalf("Fehler beim Marshalling: %v", err)\n    }\n\n    fmt.Println(string(prettyJSON))\n}

Ergebnis:

{\n  "name": "PythonLib",\n  "year": 2025,\n  "tags": [\n    "go",\n    "json",\n    "tutorial"\n  ],\n  "active": true\n}

Schön, oder? Beachten Sie den zweiten und dritten Parameter von MarshalIndent:

\n
• Präfix – eine Zeichenfolge, die am Anfang jeder Zeile hinzugefügt wird. Normalerweise ein leerer String "".
\n
• Einrückung – eine Zeichenfolge für jede Verschachtelungsebene. Meistens werden zwei Leerzeichen " " oder ein Tabulator "\\t" verwendet.
\n

Einrückungen anpassen: Leerzeichen vs. Tabulator

Sie können den Einrückungsstil leicht ändern. Zum Beispiel mit Tabulator:

prettyJSON, _ := json.MarshalIndent(site, "", "\\t")\nfmt.Println(string(prettyJSON))

Ergebnis:

{\n\t"name": "PythonLib",\n\t"year": 2025,\n\t"tags": [\n\t\t"go",\n\t\t"json",\n\t\t"tutorial"\n\t],\n\t"active": true\n}

Welche Variante wählen? Wenn Ihr Projekt den Go-Standards folgt (und diese empfehlen Tabulatoren für Code), verwenden Sie "\\t". Wenn Sie in einem Team arbeiten, in dem Leerzeichen üblich sind, sind zwei Leerzeichen angemessener. Hauptsache, es ist einheitlich.

Methode 2: Pretty-print für rohe JSON-Strings

Was aber, wenn Sie bereits einen String mit unformatiertem JSON haben?