JSON in Go-Structs umwandeln!

Gib JSON ein, um es in Go-Structs mit json-Tags umzuwandeln! Unterstützt Go (Golang) struct, json tags.
JSON
Ergebnis

JSON in Go-Structs umwandeln!

Wandle JSON in Go-Struct-Definitionen mit encoding/json-Tags um. Feldnamen folgen der Regel für exportierte Namen in Go und der Initialismen-Liste von golint (ID, URL, API, ...), und die Spalten sind ausgerichtet, als wäre der Code durch gofmt gelaufen.

Nützlich ist das, wenn du einen Typ brauchst, in den du ein Webhook-Payload oder eine API-Antwort per json.Unmarshal lädst, ein Request-Body-Struct für Handler in net/http, Gin oder Echo oder ein Konfigurations-Struct für ein CLI.

So funktioniert es

  1. Füge das JSON ein. Bei einem Array mit mehreren Zeilen werden Felder erkannt, die in manchen Zeilen fehlen, und mit omitempty markiert.
  2. Gib in Struct-Name den Namen des obersten Structs ein (Standard Root); er bleibt als ?name= in der URL.
  3. Füge das Ergebnis in eine .go-Datei ein und ergänze eine package-Klausel. Wurden Zeitfelder gefunden, ist import "time" enthalten.
  4. Verwende es als var ev WebhookEvent; err := json.Unmarshal(body, &ev).

Beispiel

Eingabe (JSON)
{
  "event_id": "evt_1Pq",
  "type": "invoice.paid",
  "created_at": "2024-05-01T03:15:00Z",
  "amount_cents": 4999,
  "customer": { "id": "cus_9", "email": "kim@example.com" },
  "retry_count": null
}
Ausgabe (Go)
import "time"

type WebhookEvent struct {
	EventID     string    `json:"event_id"`
	Type        string    `json:"type"`
	CreatedAt   time.Time `json:"created_at"`
	AmountCents int       `json:"amount_cents"`
	Customer    Customer  `json:"customer"`
	RetryCount  any       `json:"retry_count,omitempty"`
}

type Customer struct {
	ID    string `json:"id"`
	Email string `json:"email"`
}

event_id wird nach der Initialismen-Regel von golint zu EventID, und created_at, ein RFC-3339-String, wird als time.Time erkannt, wodurch import "time" hinzukommt. retry_count ist null, sein Typ ist also unbekannt: Es wird zu any mit omitempty.

Unterstützte Funktionen

  • Ein Tag json:"originalKey" an jedem Feld, dazu ,omitempty für Felder, die in manchen Zeilen fehlen oder null enthalten.
  • Optionale Werttypen (int, string, bool, Structs, time.Time) werden zu Pointern (*int), damit sich „nicht vorhanden“ vom Nullwert unterscheidet. Slices und any können ohnehin nil sein und bleiben ohne Pointer.
  • Zahlen: int für 32-Bit-Ganzzahlen, int64 darüber hinaus, float64, sobald Dezimalstellen vorkommen.
  • RFC-3339-Strings wie 2024-05-01T03:15:00Z werden als time.Time erkannt.
  • Gängige Initialismen bleiben großgeschrieben (user_id → UserID, home_url → HomeURL); Keys, die mit einer Ziffer beginnen, bekommen das Präfix Field.
  • Keys, die in einem Go-json-Tag nicht stehen können, etwa "", werden übersprungen und in einem Kommentar über dem Struct aufgelistet.
  • Ein Array von Objekten auf oberster Ebene wird zu einem Struct für das Element plus einem Kommentar, in []Root zu unmarshalen.

Anwendungsfälle

Webhook-Empfänger

Baue ein Struct aus einem Beispiel-Event, das ein Zahlungsdienst oder Git-Hoster sendet, und dekodiere es mit json.NewDecoder(r.Body).Decode(&ev), statt wiederholt Type Assertions auf map[string]any zu machen.

Request-Binding in Gin oder Echo

Erzeuge das Struct für c.ShouldBindJSON(&req) aus einem Beispiel-Request des Clients und ergänze bei Bedarf binding:"required"-Tags.

CLIs, die JSON-Konfiguration lesen

Wandle config.json einmal in ein Struct um, und ein einziges json.Unmarshal nach os.ReadFile liefert dir die gesamte Konfiguration als typisierte Werte.

Hinweise und Einschränkungen

  • time.Time wird nur für RFC-3339-Strings erkannt; Werte wie 2024-05-01 03:15:00 oder Unix-Timestamps bleiben string oder int.
  • json.Unmarshal ignoriert standardmäßig unbekannte Keys und gleicht Keys case-insensitive ab. Verwende Decoder.DisallowUnknownFields(), wenn du striktes Dekodieren willst.
  • int ist auf 64-Bit-Plattformen 64 Bit breit, int64 wird aber nur geschrieben, wenn ein Beispielwert 32 Bit überschreitet. Bei IDs, die wachsen können, ist es sicherer, selbst auf int64 umzustellen.
  • Verschachtelte Structs werden alle als eigene Typen auf oberster Ebene definiert; anonyme Inline-Structs werden nicht verwendet.
  • Werte mit gemischtem Typ und Werte, die immer nur null sind, werden zu any; ersetze sie, sobald der echte Typ bekannt ist.

Häufige Fragen

Warum sind optionale Felder Pointer wie *int?

Ein einfaches int-Feld ist 0, wenn der Key fehlt, und damit nicht von einer echten 0 zu unterscheiden. Ein Pointer ist nil, wenn der Key fehlt oder null ist, und zusammen mit omitempty fällt der Key beim erneuten Marshaling weg.

Kann ich die Feldnamen kleinschreiben?

encoding/json liest und schreibt nur exportierte (großgeschriebene) Felder; kleingeschriebene Felder werden selbst mit Tag ignoriert. In Go bleiben die Namen großgeschrieben, und der JSON-Key kommt ins Tag.

Ein null-Feld wie retry_count kam als any heraus.

Steht im Beispiel nur null, gibt es nichts, woraus sich ein Typ ableiten ließe. Pack eine weitere Antwort mit echtem Wert in ein Array und wandle beide um, oder ändere es von Hand in etwas wie *int.

Kann ich ein Go-Struct wieder in Beispiel-JSON umwandeln?

Ja. Füge das Struct im Tab Go struct → JSON oben ein; er liest die Tags und erzeugt Beispiel-JSON.