Generate Typed Code from JSON — TypeScript, Python, Go, Rust & More

Warum Code aus JSON generieren?

Jedes Projekt, das eine JSON-API verwendet, benötigt irgendwann typisierte Modelle. Sie kopieren eine Beispielantwort in Ihren Editor, betrachten die Felder und beginnen, eine Schnittstelle oder Struktur von Hand zu schreiben. Es funktioniert — bis die Nutzlast 40 Felder, drei Ebenen der Verschachtelung und ein Array von polymorphen Objekten hat. Dann wird es mühsam, fehleranfällig und langsam.

Ein Codegenerator beseitigt diesen manuellen Schritt. Fügen Sie ein JSON-Beispiel ein, wählen Sie eine Sprache aus, und erhalten Sie in Sekundenschnelle produktionsbereite Typdefinitionen. Die Vorteile sind konkret:

• Zeitersparnis — Typen für eine 50-Felder-Nutzlast zu generieren dauert Sekunden statt Minuten.
• Typensicherheit — Ihr Compiler oder Laufzeitumgebung erkennt Unstimmigkeiten, bevor sie in die Produktion gelangen.
• Weniger Boilerplate — kein manuelles Schreiben von Gettern, Settern, JSON-Tags oder Serde-Anmerkungen mehr.
• Konsistenz — jedes Teammitglied erhält die gleichen Modelle aus denselben Quelldaten.

Wie Typinferenz funktioniert

Ein JSON-zu-Code-Generator liest Ihre Beispieldaten und leitet einen Typ für jeden Wert ab. Strings werden zu string, Zahlen werden je nach Vorhandensein eines Dezimalpunkts zu int oder float, Booleans werden direkt abgebildet, und null erzeugt einen optionalen/nulbaren Wrapper. Objekte werden zu benannten Typen (Strukturen, Klassen, Schnittstellen), und Arrays werden zu typisierten Sammlungen von was auch immer ihre Elemente sind.

So werden JSON-Typen in verschiedenen Sprachen abgebildet:

JSON-Typ	TypeScript	Python	Java	Go	Rust	Swift
string	string	str	String	string	String	String
number (int)	number	int	int	int64	i64	Int
number (float)	number	float	double	float64	f64	Double
boolean	boolean	bool	boolean	bool	bool	Bool
null	null	None	null	*T (Zeiger)	Option<T>	T?
object	interface	dataclass	class (POJO)	struct	struct	struct (Codable)
array	T[]	list[T]	List<T>	[]T	Vec<T>	[T]

Die zentrale Erkenntnis: Ein Generator weiß nur, was er sieht. Wenn Ihre Beispieldaten 42 für ein Feld haben, das auch 42.5 sein kann, wählt der Generator int anstelle von float. Verwenden Sie repräsentative Beispieldaten für genaue Typen.

Beispielinput

Wir verwenden dieses JSON in den folgenden Beispielen. Es umfasst Strings, Zahlen, Booleans, ein verschachteltes Objekt und ein Array:

{
  "id": 1,
  "name": "Alice Johnson",
  "email": "alice@example.com",
  "active": true,
  "score": 97.5,
  "address": {
    "street": "123 Main St",
    "city": "Portland",
    "zip": "97201"
  },
  "tags": ["admin", "editor"]
}

TypeScript-Schnittstellen aus JSON

TypeScript ist das häufigste Ziel. Der Generator erstellt eine Schnittstelle für jedes Objekt und verwendet die Feldnamen als Eigenschaftsschlüssel:

interface Address {
  street: string;
  city: string;
  zip: string;
}

interface Root {
  id: number;
  name: string;
  email: string;
  active: boolean;
  score: number;
  address: Address;
  tags: string[];
}

Jedes Feld ist typisiert, das verschachtelte address-Objekt erhält seine eigene Schnittstelle, und tags wird aus seinem Inhalt als string[] abgeleitet. Sie können dies direkt in Ihr Projekt einfügen und mit vollständiger Autovervollständigung und Kompilierungsprüfungen verwenden.

Python-Dataclasses aus JSON

Der @dataclass-Dekorator von Python generiert automatisch __init__, __repr__ und Vergleichsmethoden. In Kombination mit Typ-Hinweisen ist es der sauberste Weg, JSON-Modelle in Python zu definieren:

from dataclasses import dataclass

@dataclass
class Address:
    street: str
    city: str
    zip: str

@dataclass
class Root:
    id: int
    name: str
    email: str
    active: bool
    score: float
    address: Address
    tags: list[str]

Kombinieren Sie dies mit einer Bibliothek wie dacite oder cattrs, um JSON-Wörterbücher direkt in diese Dataclass-Instanzen zu deserialisieren.

Java POJOs aus JSON

Java erfordert mehr Zeremonie — Felder, einen Konstruktor und Getter/Setter. Ein Generator spart hier die meiste Zeit:

public class Address {
    private String street;
    private String city;
    private String zip;

    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    public String getZip() { return zip; }
    public void setZip(String zip) { this.zip = zip; }
}

public class Root {
    private int id;
    private String name;
    private String email;
    private boolean active;
    private double score;
    private Address address;
    private List<String> tags;

    // Getter und Setter...
}

Die generierten POJOs funktionieren direkt mit Jackson, Gson oder jeder anderen JSON-Serialisierungsbibliothek im Java-Ökosystem.

Go-Strukturen aus JSON

Go-Strukturen verwenden Feld-Tags, um das JSON-Marshaling zu steuern. Der Generator produziert idiomatisches Go mit exportierten Feldern und json:"..."-Tags:

type Address struct {
    Street string `json:"street"`
    City   string `json:"city"`
    Zip    string `json:"zip"`
}

type Root struct {
    ID      int64    `json:"id"`
    Name    string   `json:"name"`
    Email   string   `json:"email"`
    Active  bool     `json:"active"`
    Score   float64  `json:"score"`
    Address Address  `json:"address"`
    Tags    []string `json:"tags"`
}

Die Tags stellen sicher, dass json.Unmarshal die Kleinbuchstaben-JSON-Schlüssel den exportierten (Großbuchstaben) Go-Feldern zuordnet. Die Feldnamen werden automatisch PascalCased, und id wird zu ID, gemäß den Go-Namenskonventionen.

Rust-Strukturen aus JSON

Rust verwendet das serde-Crate für die Serialisierung. Der Generator fügt die notwendigen Derive-Makros hinzu:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct Address {
    pub street: String,
    pub city: String,
    pub zip: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub active: bool,
    pub score: f64,
    pub address: Address,
    pub tags: Vec<String>,
}

Mit serde_json können Sie einen JSON-String mit einem einzigen Aufruf von serde_json::from_str in diese Strukturen deserialisieren. Der Compiler stellt sicher, dass jedes Feld vorhanden und korrekt typisiert ist.

Swift Codable aus JSON

Das Codable-Protokoll von Swift ermöglicht die integrierte JSON-Codierung und -Decodierung ohne externe Abhängigkeiten:

struct Address: Codable {
    let street: String
    let city: String
    let zip: String
}

struct Root: Codable {
    let id: Int
    let name: String
    let email: String
    let active: Bool
    let score: Double
    let address: Address
    let tags: [String]
}

Verwenden Sie JSONDecoder().decode(Root.self, from: data), um JSON-Daten direkt in diese Strukturen zu parsen. Swift leitet die Codierungsschlüssel automatisch von den Eigenschaftsnamen ab.

Umgang mit verschachtelten Objekten und Arrays

Verschachtelte Objekte sind der interessanteste Teil der Codegenerierung. Wenn der Generator einen Objektwert innerhalb eines anderen Objekts findet, erstellt er einen separaten benannten Typ. Die Namenskonvention basiert typischerweise auf dem Feldnamen:

• Ein Feld namens address, das ein Objekt enthält, erzeugt einen Typ namens Address.
• Ein Feld namens shipping_details erzeugt ShippingDetails (PascalCased).
• Tief verschachtelte Objekte folgen demselben Muster rekursiv — ein address mit einem verschachtelten coordinates-Objekt erzeugt sowohl Address- als auch Coordinates-Typen.

Arrays von Objekten werden ähnlich behandelt. Wenn items ein Array von Objekten ist, untersucht der Generator das erste Element (oder kombiniert alle Elemente), um den Typ abzuleiten, und erstellt einen singular benannten Typ wie Item.

Arrays von Primitiven (["admin", "editor"]) sind unkompliziert — sie werden zu string[], Vec<String>, []string usw. je nach Zielsprache.

Tipps für besseren generierten Code

Die Qualität der generierten Typen hängt vollständig von der Qualität Ihrer Eingabedaten ab. Einige praktische Tipps:

• Verwenden Sie repräsentative Beispieldaten. Fügen Sie mindestens ein Beispiel für jede Feldvariation hinzu. Wenn ein Feld null sein kann, fügen Sie einen Nullwert hinzu, damit der Generator es als optional markiert.
• Halten Sie die Typen konsistent. Wenn id in einigen Datensätzen eine Zahl und in anderen einen String ist, muss der Generator eines auswählen oder einen Union-Typ verwenden. Bereinigen Sie zuerst Ihre Beispieldaten.
• Benennen Sie den Wurzeltyp um. Die meisten Generatoren verwenden standardmäßig Root als obersten Namen. Benennen Sie ihn nach der Generierung in etwas Bedeutungsvolles wie User oder ApiResponse um.
• Flatten Sie vor der Generierung, wenn Sie nur einen Teil der Struktur benötigen. Kürzen Sie Ihr JSON-Beispiel auf nur die Felder, die Sie interessieren.
• Überprüfen Sie Randfälle. Leere Arrays ([]) können ohne Kontext nicht typisiert werden. Füllen Sie sie mit mindestens einem Element, damit der Generator den Elementtyp kennt.
• Überprüfen und anpassen. Generierter Code ist ein Ausgangspunkt. Möglicherweise möchten Sie Felder umbenennen, die Ganzzahldaten anpassen, Validierungsanmerkungen hinzufügen oder optionale Felder basierend auf Ihrem Fachwissen kennzeichnen.

Probieren Sie es selbst aus

Generieren Sie sofort typisierten Code: Fügen Sie beliebiges JSON in unseren JSON zu Code Generator ein und erhalten Sie produktionsbereite Typen für TypeScript, Python, Java, Go, Rust, Swift, Kotlin und C#. Keine Anmeldung erforderlich.