Rust-zu-JSON-Konverter
Füge Rust-Structs mit Serialize-Derive ein. Bekomm sauberes JSON zurück.
Was dieses Tool macht
Wenn du schon mal ein Struct definiert, #[derive(Serialize)] draufgeklatscht und dann gemerkt hast, dass du eigentlich nur das JSON willst — ohne das serde-Boilerplate, ohne serde_json in die Cargo.toml zu schreiben und cargo run laufen zu lassen — dann macht dieses Tool genau das. Füge dein Rust hier ein und bekomm gültiges JSON zurück, ohne cargo anzufassen. Es verkraftet ein einzelnes Struct-Literal, ein ganzes Modul mit mehreren Typen oder etwas mit tief verschachteltem Vec und Option — gleiches Ergebnis: ein sauberes JSON-Dokument, in dem jedes Feld erhalten bleibt.
Der Konverter bildet nach, wie serde die Werte tatsächlich serialisiert. String und &str werden zu JSON-Strings. i32, u64, f32, f64 werden zu JSON-Zahlen. bool wird zu true/false. Vec<T>, &[T] und [T; N] werden zu JSON-Arrays. HashMap<String, V> / BTreeMap<String, V> werden zu JSON-Objekten. Option<T> mit None wird zu JSON-null; mit Some(value) wird der innere Typ serialisiert. Tupel kommen als heterogene Arrays raus — exakt so dokumentiert auf serde.rs/data-model.
Serde-Attribute werden respektiert. #[serde(rename = "x")] benennt den JSON-Key um, #[serde(skip)] entfernt das Feld und #[serde(flatten)] zieht die Felder eines verschachtelten Structs ins Parent-Objekt hoch. enum-Typen folgen standardmäßig der externally-tagged Repräsentation (konfigurierbar mit #[serde(tag = "type")]). Füge mehrere Structs auf einmal ein und jedes landet als Top-Level-Eintrag in der Ausgabe. Wenn du Webservices auf Basis der Rust-Standardbibliothek plus axum/actix baust, fällt diese Ausgabe direkt in deine Integrationstests.
So geht's
Drei Schritte. Funktioniert gleich, egal ob du ein einzelnes Struct oder ein ganzes Modul mit einem Dutzend Typen einfügst.
Rust einfügen (oder Beispiel laden)
Pack dein Rust einfach in den linken Editor. Ein Struct, ein Tuple Struct, ein Enum mit Varianten, mehrere Typen oder verschachtelte Vec/Option/HashMap — alles ok. Klick auf Beispiel laden, um erst mal ein realistisches Beispiel zu sehen.
Du musst keine use-Anweisungen, Lifetimes oder Derive-Attribute entfernen. Lass die Rust-Syntax, wie sie ist — die serde-Attribute gehören zu dem, was der Parser liest.
Auf Konvertieren klicken
Klick auf den grünen Konvertieren-Button. Das Tool liest den Rust-Code, behält jedes Struct und jedes Feld bei und gibt das JSON in einem Rutsch aus. Währenddessen läuft ein kurzer Ladeindikator.
JSON kopieren
Das rechte Panel füllt sich mit eingerücktem JSON. Kopier es in einen reqwest-Test, einen axum-Integrationstest, deine OpenAPI-Beispiele oder einen curl-Befehl. Kein Rebuild nötig.
Wann das wirklich hilft
Fixtures für Webservices
Du hast ein Request-Struct aus axum oder actix und brauchst das JSON für einen Test oder einen curl-Call. Struct einfügen, JSON schnappen, weitermachen — kein cargo-Zyklus.
Config-Templates für CLIs
Eine clap-basierte CLI mit einem Config-Struct. Wandle es in ein JSON-Template, das Nutzer editieren können — ohne dass du nur für die Doku eine eigene <code>Default</code>-Impl schreibst.
Seeds für Integrationstests
Mach aus den Struct-Literalen deiner Unit-Tests JSON-Seed-Dateien für Integrationstests, Mock-Server oder Fixtures für Embedded-Datenbanken.
Doku, die dem Code folgt
Generiere JSON-Beispiele für dein README oder deine OpenAPI-Spec direkt aus den echten Rust-Typen, damit die Doku nicht mehr auseinanderdriftet.
Häufige Fragen
Brauche ich serde und serde_json in meiner Cargo.toml?
Für dieses Tool nicht — es läuft serverseitig und kompiliert deinen Code nicht. Für den Laufzeit-Einsatz in deiner eigenen App ist serde mit dem derive-Feature plus serde_json die Standardkombination.
Werden #[serde(rename)], #[serde(skip)] und #[serde(flatten)] berücksichtigt?
Ja. #[serde(rename = "x")] benennt den JSON-Key um, #[serde(skip)] entfernt das Feld aus der Ausgabe und #[serde(flatten)] zieht verschachtelte Struct-Felder ins Parent — passend zur Doku der serde-Feld-Attribute.
Wie werden Option, Vec und HashMap behandelt?
Option<T> mit None wird zu JSON-null; mit Some(v) wird der innere Wert serialisiert. Vec<T>, Slices und Arrays werden zu JSON-Arrays. HashMap<String, V> und BTreeMap<String, V> werden zu JSON-Objekten; Maps mit Nicht-String-Keys bekommen ihre Keys zu Strings konvertiert.
Und Enums mit Varianten?
Standardmäßig nutzen Enum-Varianten die externally-tagged Repräsentation ({ "VariantName": {...} }). Die Attribute #[serde(tag = "type")], #[serde(untagged)] und #[serde(content = "data")] schalten auf internally-tagged, untagged oder adjacently-tagged um — das Tool liest diese Attribute und gibt entsprechend aus.
Wird mein Code gespeichert?
Dein Code wird zur Konvertierung ans Backend geschickt und nicht dauerhaft gespeichert — wir loggen das Payload nicht. Wirf bei sensiblem Code vorher nochmal einen Blick drauf.
Was ist mit Lifetimes oder Generics im Rust-Code?
Lifetimes (&'a str) werden ignoriert — JSON kennt das Konzept nicht. Konkret instanziierte Generics (Vec<User>) funktionieren. Nicht instanziierte Generics kommen als null raus. Makros, die zu echter Syntax expandieren, funktionieren; Makros, die auf ein hier unsichtbares proc-macro-Crate angewiesen sind, werden als opak behandelt.
Andere Tools, die du vielleicht brauchst
Rust zu JSON ist nur ein Puzzlestück. Das hier passt gut dazu: