Skip to content

JSON zu Rust Struct Konverter

JSON einfügen, sofort idiomatische Rust-serde-Structs erhalten, 100 % im Browser. Korrekte i64/u64/f64-Typen, Option für null, #[serde(rename)] für camelCase. Kostenlos.

Kein Tracking Läuft im Browser Kostenlos
Optionen
0 Zeichen
Rust-Ausgabe
0 Zeilen
Ausgabe anhand der serde-Semantik und der rustfmt-Formatierung für reale API-Nutzlasten verifiziert. — Go Tools Team · Jul 2, 2026

Was ist die JSON-zu-Rust-Konvertierung?

Die JSON-zu-Rust-Konvertierung verwandelt ein JSON-Beispiel in kompilierfertige Rust-Structs mit den Makros #[derive(Serialize, Deserialize)] von serde, sodass Sie nie wieder Deserialisierungs-Boilerplate für API-Antworten oder Konfigurationsdateien von Hand schreiben. Dieser schnelle Rust-Struct-Generator leitet korrekte Zahlentypen ab, markiert fehlende Felder als Option und ergänzt #[serde(rename)] für Schlüssel, die nicht snake_case sind — alles zu 100 % in Ihrem Browser.

Beispiele

API-Antwort

{"id":101,"name":"Ada Lovelace","email":"ada@example.com","active":true,"roles":["admin","user"]}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub active: bool,
    pub roles: Vec<String>,
}

Eine typische REST-Nutzlast wird zu einem serde-fähigen Struct, das Sie direkt in Ihren Client einfügen können. Zahlen ergeben i64, Arrays werden zu Vec<String>.

Verschachteltes Objekt

{"repo":"serde","owner":{"login":"dtolnay","id":100}}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub repo: String,
    pub owner: Owner,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Owner {
    pub login: String,
    pub id: i64,
}

Verschachtelte Objekte werden zu separaten, benannten Structs (Owner), die per Feld referenziert werden — identische Formen werden dedupliziert.

Array von Objekten (optionales Feld)

{"users":[{"id":1,"nick":"x"},{"id":2}]}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub users: Vec<User>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub nick: Option<String>,
}

Arrays von Objekten werden zu einem Element-Struct zusammengeführt. Schlüssel, die in manchen Elementen fehlen, werden zu Option<String> — kein #[serde(default)] nötig.

camelCase-Schlüssel

{"login":"octocat","publicRepos":15,"followerCount":9001,"createdAt":"2011-01-25"}
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub login: String,
    #[serde(rename = "publicRepos")]
    pub public_repos: i64,
    #[serde(rename = "followerCount")]
    pub follower_count: i64,
    #[serde(rename = "createdAt")]
    pub created_at: String,
}

Felder werden zu snake_case, wobei #[serde(rename)] auf den ursprünglichen JSON-Schlüssel zurückverweist. Bereits snake-Schlüssel wie login erhalten keinen rename.

So konvertieren Sie JSON nach Rust

  1. 1

    JSON einfügen

    Fügen Sie ein JSON-Objekt, ein Array oder eine API-Antwort in das Eingabefeld ein. Die Konvertierung startet sofort.

  2. 2

    Ausgabe anpassen

    Benennen Sie das Root-Struct um und schalten Sie serde-Derives, Debug und Clone oder die pub-Sichtbarkeit um, passend zum Stil Ihres Crates.

  3. 3

    Kopieren oder herunterladen

    Übernehmen Sie das erzeugte Rust mit einem Klick und fügen Sie es direkt in Ihr Projekt ein.

Common Use Cases

Typisierte API-Clients
Verwandeln Sie eine Beispiel-Antwort von REST oder GraphQL in serde-Structs für einen reqwest- oder ähnlichen Client, ohne Deserialisierungs-Boilerplate von Hand zu schreiben.
Konfigurations- und Fixture-Parsing
Erzeugen Sie Structs für JSON-Konfigurationsdateien, Test-Fixtures oder Webhook-Nutzlasten, die Sie mit serde_json deserialisieren müssen.
Schnelles Prototyping
Fügen Sie eine unbekannte Nutzlast ein, um ihre Struktur sofort als Rust-Typen zu sehen — eine schnelle Möglichkeit, eine neue API zu erkunden, bevor Sie sie anbinden.

Wie die Konvertierung funktioniert

Strukturelle Inferenz
Jedes Objekt wird zu einem benannten Struct; identische Formen werden dedupliziert, sodass Sie ein Struct erhalten und keine Kopien. Arrays von Objekten werden Schlüssel für Schlüssel zusammengeführt, und Schlüssel, die in manchen Elementen fehlen, werden zu Option<T>.
Korrekte Zahlentypisierung
Ganzzahlen werden zu i64, steigen jenseits von i64::MAX auf u64 und fallen jenseits von u64 auf f64 zurück. Floats werden am Token erkannt (1.0, 2e3), sodass die serde-Deserialisierung nie an einer Float-in-Integer-Diskrepanz scheitert.
Idiomatische, kompilierbare Bezeichner
Schlüssel werden zu snake_case-Feldern mit #[serde(rename)] zurück auf den ursprünglichen Schlüssel; Rust-Schlüsselwörter, doppelte Namen und Nicht-Bezeichner-Schlüssel werden bereinigt, sodass die Ausgabe stets kompiliert.
100 % clientseitig
Parsing und Generierung laufen in Ihrem Browser ohne Netzwerkaufrufe, sodass Ihre Daten privat bleiben.

Tipps für saubere Rust-Structs

Benennen Sie Ihr Root-Struct
Vergeben Sie einen aussagekräftigen Root-Namen (z. B. User, ApiResponse) statt des Standards Root für lesbaren Code.
serde_json nur bei Bedarf hinzufügen
serde_json::Value erscheint bei leeren oder gemischten Arrays und reinen null-Feldern. Geben Sie diesen Feldern nach Möglichkeit einen konkreten Typ aus einem reichhaltigeren Beispiel oder fügen Sie serde_json zu Cargo.toml hinzu.
Option vs. Pflichtfeld prüfen
Felder werden nur dann als Option<T> markiert, wenn ein Beispiel sie auslässt. Fügen Sie eine repräsentative Nutzlast ein, damit das Werkzeug Pflicht- und optionale Felder genau ableitet.

Häufig gestellte Fragen

Wie konvertiere ich JSON in ein Rust-Struct?
Fügen Sie Ihr JSON in das Eingabefeld ein. Der Konverter liest es sofort in Ihrem Browser und erzeugt rechts Rust-Structs mit serde-Derives. Klicken Sie auf Kopieren, um das Ergebnis zu übernehmen — kein Upload, kein Konto, kein Warten.
Erzeugt es serde-Derives? Brauche ich serde und serde_json?
Ja — die Ausgabe verwendet standardmäßig #[derive(Debug, Clone, Serialize, Deserialize)]. Fügen Sie serde mit dem derive-Feature zu Ihrer Cargo.toml hinzu. serde_json brauchen Sie nur als Abhängigkeit, wenn die Ausgabe serde_json::Value enthält, was bei leeren oder gemischten Arrays und reinen null-Feldern vorkommt. Schalten Sie den serde-Umschalter aus, um schlichte Structs auszugeben.
Wie verwende ich das erzeugte Struct, um JSON zu parsen?
Fügen Sie serde_json zu Ihrer Cargo.toml hinzu und deserialisieren Sie in einer Zeile: let root: Root = serde_json::from_str(json)?;. Das erzeugte Deserialize-Derive erledigt den Rest — nutzen Sie serde_json::from_slice für einen Byte-Slice oder from_reader für eine Datei oder einen HTTP-Body und serde_json::to_string zum Zurückserialisieren.
Wie werden optionale und null-Felder behandelt?
Wenn ein Schlüssel in manchen Array-Elementen vorkommt, in anderen aber nicht, wird er zu einem Option-Feld. Ein Feld, das ausschließlich null ist, wird zu einem optionalen serde_json::Value. serde behandelt Option automatisch als optional, sodass kein #[serde(default)]-Attribut hinzugefügt wird oder nötig ist.
Wie geht es mit camelCase-Schlüsseln und Rust-Schlüsselwörtern um?
Feldnamen werden in idiomatisches snake_case umgewandelt, und ein #[serde(rename)]-Attribut verweist sie auf den exakten JSON-Schlüssel zurück. Reservierte Schlüsselwörter wie type oder match werden als type_ oder match_ mit einem rename ausgegeben, was robuster ist als rohe Bezeichner, weil es auch self, crate und super abdeckt.
Kann es #[serde(rename_all)] statt Renames pro Feld verwenden?
Das Werkzeug gibt ein #[serde(rename)] pro Feld aus, weil das immer funktioniert — selbst wenn eine Nutzlast camelCase, snake_case und unregelmäßige Schlüssel mischt. Wenn jedes Feld eines Structs derselben Konvention folgt, löschen Sie diese Attribute und setzen Sie stattdessen ein einzelnes #[serde(rename_all = "camelCase")] auf das Struct; beide deserialisieren identisch.
Welchen Rust-Zahlentyp verwendet es?
Ganzzahlen werden zu i64 oder zu u64, wenn ein Wert i64::MAX überschreitet, und fallen jenseits von u64 auf f64 zurück — so bleiben große IDs verlustfrei. Jede Zahl mit Dezimalpunkt oder Exponent (wie 1.0 oder 2e3) wird zu f64, weil serde einen Float in einem Integer-Feld ablehnen würde.
Wie werden Datumsangaben und Zeitstempel typisiert?
JSON kennt keinen Datumstyp, daher werden ISO-Strings wie 2011-01-25 oder RFC-3339-Zeitstempel als String ausgegeben. Für echte Datumsverarbeitung ändern Sie das Feld auf einen chrono-Typ — DateTime in der Utc-Zeitzone oder NaiveDate — und aktivieren Sie das serde-Feature von chrono. serde parst RFC 3339 dann automatisch.
Wie behandle ich Objekte mit dynamischen oder unbekannten Schlüsseln?
Wenn die Schlüssel variieren — etwa eine Zuordnung von IDs zu Werten — ersetzen Sie das erzeugte Struct durch eine HashMap mit String als Schlüssel. Um ein typisiertes Struct zu behalten und zugleich zusätzliche Felder zu erfassen, fügen Sie ein #[serde(flatten)]-Feld hinzu, das eine HashMap ist. Für völlig dynamische Werte ist serde_json::Value der Auffangtyp.
Sind meine JSON-Daten privat und sicher?
Ja. Die Konvertierung läuft zu 100 % in Ihrem Browser mit JavaScript. Ihr JSON — einschließlich Tokens, IDs oder Kundendaten — verlässt die Seite niemals und wird nie an einen Server gesendet.
Kann ich schlichte Rust-Structs ohne serde erzeugen?
Ja. Schalten Sie den serde-Umschalter aus, um die use-serde-Zeile, die Serialize- und Deserialize-Derives und alle #[serde(rename)]-Attribute wegzulassen — übrig bleiben saubere Structs. Sie können auch die Debug- und Clone-Derives und die pub-Sichtbarkeit umschalten.
Ist das Werkzeug kostenlos? Brauche ich ein Konto?
Es ist völlig kostenlos, ohne Anmeldung, ohne Limits und ohne Werbung, die den Arbeitsbereich überlädt.

Verwandte Werkzeuge

Alle Werkzeuge anzeigen →