JSON to Go Struct

Was ist die JSON-zu-Go-Konvertierung?

Die JSON-zu-Go-Konvertierung überführt rohe JSON-Daten in Go-Typdefinitionen, die mit dem encoding/json-Paket aus der Standardbibliothek von Go funktionieren. Go ist statisch typisiert — jedes JSON-Feld benötigt ein entsprechendes Struct-Feld mit dem richtigen Typ und einem Struct-Tag, das dem Serializer mitteilt, welchem JSON-Key es zugeordnet werden soll. Diese Definitionen für große oder tief verschachtelte API-Antworten von Hand zu schreiben ist zeitaufwendig und fehleranfällig.

Das encoding/json-Paket, seit Go 1.0 Teil der Go-Spezifikation, verwendet Reflection, um JSON-Keys exportierten Struct-Feldern zuzuordnen. Die Zuordnung ist standardmäßig case-insensitive, aber explizite JSON-Struct-Tags sind die gängige Praxis, weil sie Mehrdeutigkeiten beseitigen und es erlauben, die PascalCase-Konvention von Go zu verwenden, während das JSON in camelCase oder snake_case bleibt. Ein Konverter automatisiert das: Er liest das JSON, leitet Go-Typen aus den Werten ab und gibt Struct-Definitionen mit den korrekten Tags aus.

Das Typsystem von Go bildet JSON sauber ab. Strings werden zu string, Booleans zu bool, Ganzzahlen zu int und Fließkommazahlen zu float64. Verschachtelte JSON-Objekte werden zu eigenen benannten Structs, Arrays werden zu Slices. Die Lücke ist null: Go hat keinen universellen Nullable-Typ, daher werden null-Werte typischerweise zu Pointer-Typen (*string, *int) oder interface{}. Ein Generator erledigt das alles in Millisekunden.

Warum einen JSON-zu-Go-Konverter verwenden?

Go-Structs aus JSON von Hand zu definieren bedeutet, Klammern zu zählen, Typen zu raten und Tags bei jeder API-Änderung neu zu schreiben. Ein Konverter beseitigt diese Reibung.

JSON-zu-Go-Anwendungsfälle

JSON-zu-Go-Typ-Mapping

Das encoding/json-Paket folgt spezifischen Regeln beim Abbilden von JSON-Werten auf Go-Typen. Die Tabelle zeigt das Standardmapping und gängige Alternativen. Die Spalte "Standard" zeigt, was die meisten Generatoren ausgeben. Die Spalte "Alternative" zeigt Typen, die je nach Anforderung gewählt werden können — etwa int64 für große IDs oder Pointer-Typen für nullable Felder.

Go-JSON-Struct-Tag-Referenz

Struct-Tags steuern, wie encoding/json Felder serialisiert und deserialisiert. Das json-Tag ist bei weitem das gebräuchlichste, kann aber mit anderen Tags (db, yaml, xml) am selben Feld kombiniert werden. Die Tag-Syntax ist ein per Backtick begrenzter String nach dem Feldtyp. Hier sind die json-Tag-Optionen, die encoding/json unterstützt.

json.Unmarshal vs. json.NewDecoder

Go bietet zwei Wege zur JSON-Dekodierung: json.Unmarshal für Byte-Slices und json.NewDecoder für io.Reader-Streams. Beide verwenden dieselben Struct-Tag-Regeln, unterscheiden sich aber darin, wann sie eingesetzt werden.

Code-Beispiele

Diese Beispiele zeigen, wie Go-Structs, die aus JSON generiert wurden, in echten Programmen verwendet werden, und wie sie aus anderen Sprachen generiert werden können. Die Go-Beispiele verwenden encoding/json aus der Standardbibliothek.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

Häufig gestellte Fragen