Kein Inhalt
Kostenloses Online-Tool JSON zu Rust. Fügen Sie API-Antwort-JSON ein, um automatisch Serde-Derive-Structs zu generieren, verschachtelte Objekte unabhängig aufgeteilt, Vec und Option intelligent erkannt, reine lokale Browser-Konvertierung, keine Registrierung erforderlich.
JSON zu Rust ist der Prozess der Umwandlung von JSON-formatierten Daten (Objekten oder Arrays) in Rust-struct-Typdefinitionen. Rust ist eine stark typisierte Systemprogrammiersprache, die häufig für Backend-Dienste, CLI-Tools, WebAssembly, eingebettete Systeme und Blockchain-Szenarien verwendet wird. In der Entwicklung müssen Sie häufig JSON-Beispiele aus API-Dokumentationen oder tatsächlichen Antworten in Rust-Typen konvertieren; das manuelle Schreiben von Structs ist nicht nur repetitiv, sondern auch anfällig für Feldtypfehler. Dieses Tool zielt darauf ab, diesen Prozess zu automatisieren, damit sich Entwickler auf die Geschäftslogik konzentrieren können.
Dieses Tool läuft lokal im Browser auf Basis von quicktype-core und verwendet die Renderoptionen just-types und no-comments, um sauberen Struct-Code für Rust zu generieren. Die Ausgabe umfasst use serde::{Serialize, Deserialize}; und entsprechende #[derive(Serialize, Deserialize)], direkt verwendbar mit serde_json zur Deserialisierung. Das bedeutet, dass Sie nicht nur einen Typentwurf erhalten, sondern Rust-Code, der in ein Cargo-Projekt gelegt und mit minimaler Abhängigkeitskonfiguration kompiliert/ausgeführt werden kann.
Typerkennung ist das Herzstück von JSON zu Rust. Das Tool ordnet JSON-Grundtypen Rust-Standardtypen zu: Zeichenfolgen zu String, Ganzzahlen zu i64, Gleitkommazahlen zu f64, Boolesche Werte zu bool, Arrays zu Vec<T>, verschachtelte Objekte zu unabhängigen Structs, Nullwerte zu Option<serde_json::Value>. Bei verschachtelten Objekten erstellt das Tool automatisch neue Structs für jede Ebene, benannt nach Großschreibung der ersten Buchstaben der Felder, z.B. generiert ein address-Feld eine Address-struct, Objekte in items-Arrays generieren eine Item-struct.
Im Gegensatz zu einigen Online-Tools, bei denen JSON zur Verarbeitung an Server hochgeladen werden muss, erfolgen alle Berechnungen dieses Tools in Ihrem Browser. quicktype-core wird über Web Worker geladen und ausgeführt; JSON-Parsing, Typerkennung, Rust-Codegenerierung und Dateidownloads erfolgen alle lokal, wobei keine Daten an einen Server gesendet werden. Dies ist besonders wichtig für JSON, das API-Schlüssel, Benutzerdatenschutzfelder oder nicht veröffentlichte Geschäftsstrukturen enthält; Daten werden beim Schließen der Seite aus dem Speicher gelöscht, was es zu einer sicheren Wahl für die JSON-Deserialisierung im Unternehmensintranet macht.
Generierter Code wird typischerweise in Cargo-Projekten verwendet. Sie müssen in Cargo.toml die Abhängigkeiten serde = { version = "1", features = ["derive"] } und serde_json = "1" hinzufügen, generierte Structs in .rs-Dateien im src-Verzeichnis kopieren und über mod-Deklarationen importieren. Dann können Sie serde_json::from_str::<User>(&json_string) verwenden, um echte API-Antworten in stark typisierte Structs umzuwandeln und Rusts Kompilierzeit-Typprüfung zu genießen. Für gängige Rust-Web-Frameworks wie Actix-web, axum, Rocket, Warp können generierte Structs direkt als Handler-Parameter und Antwortmodelle dienen.
Beachten Sie, dass automatisch generierter Code ein Ausgangspunkt und kein Endpunkt ist. Das Tool leitet Typen aus JSON-Beispielen ab und kann keine genauen Geschäftstypen bestimmen (z.B. werden semantische Typen wie URL, E-Mail, ID, Zeitstempel alle einheitlich als String oder i64 abgeleitet). Bei snake_case-JSON-Feldern werden Rust-struct-Felder unverändert generiert; Sie müssen möglicherweise manuell #[serde(rename = "user_name")] hinzufügen, um die Deserialisierungszuordnung aufrechtzuerhalten, oder String in semantische Typen wie chrono::DateTime<Utc>, uuid::Uuid, url::Url ändern. Wir empfehlen, generierte Ergebnisse als erste Entwürfe zu verwenden und dann Feldnamen, Typen und Annotationen gemäß Projektkonventionen zu verfeinern.
Verwenden Sie Actix-web 4.x mit der generierten Struct als web::Json<T>-Parameter; HTTP-POST-Request-Body automatisch deserialisiert.
// Cargo.toml
// [dependencies]
// actix-web = "4"
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};
// Auto-generiert von diesem Tool (aus JSON)
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateUserRequest {
name: String,
email: String,
age: i64,
tags: Vec<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct User {
id: i64,
name: String,
email: String,
age: i64,
tags: Vec<String>,
}
// Actix-web-Handler: JSON-Eingabe automatisch deserialisiert
async fn create_user(payload: web::Json<CreateUserRequest>) -> impl Responder {
let req = payload.into_inner();
let user = User {
id: 1,
name: req.name,
email: req.email,
age: req.age,
tags: req.tags,
};
HttpResponse::Ok().json(user) // Antwort wird ebenfalls mit serde_json serialisiert
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| {
App::new()
.route("/users", web::post().to(create_user))
})
.bind("127.0.0.1:8080")?
.run()
.await
}
/*
* Client-Aufruf:
* curl -X POST http://127.0.0.1:8080/users \
* -H "Content-Type: application/json" \
* -d '{"name":"Alice","email":"a@b.com","age":30,"tags":["rust","actix"]}'
*/axum-Server verwendet Json<T>-Extraktor, reqwest-Client verwendet .json::<T>() zum Deserialisieren von Antworten; generierte Structs sind bidirektional kompatibel.
// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
// reqwest = { version = "0.12", features = ["json"] }
use axum::{routing::get, Json, Router};
use serde::{Deserialize, Serialize};
// Auto-generiert von diesem Tool
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Address {
city: String,
zip: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct User {
id: i64,
name: String,
email: String,
address: Address,
tags: Vec<String>,
}
// axum-Handler: gibt JSON-Antwort zurück
async fn get_user() -> Json<User> {
Json(User {
id: 1,
name: "Alice".into(),
email: "a@b.com".into(),
address: Address { city: "Beijing".into(), zip: "100000".into() },
tags: vec!["rust".into(), "axum".into()],
})
}
// reqwest-Client: Remote-API-Antwort deserialisieren
async fn fetch_user(url: &str) -> Result<User, reqwest::Error> {
let user: User = reqwest::get(url).await?.json().await?;
Ok(user)
}
#[tokio::main]
async fn main() {
// axum-Dienst starten
let app = Router::new().route("/user", get(get_user));
let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
axum::serve(listener, app).await.unwrap();
}
/*
* Nach dem Build besuchen:
* curl http://127.0.0.1:8080/user
* {"id":1,"name":"Alice","email":"a@b.com",
* "address":{"city":"Beijing","zip":"100000"},
* "tags":["rust","axum"]}
*/Fügen Sie JSON-Inhalt in den linken Editor ein oder klicken Sie auf die Schaltfläche zum Hochladen, um eine .json/.txt-Datei auszuwählen. Sie können auch auf «Beispiel» klicken, um das integrierte Beispiel zu laden. Das Tool ruft automatisch quicktype-core innerhalb von 400ms auf, um Rust-Code zu generieren, und zeigt Serde-abgeleitete Structs rechts an. Wenn das JSON fehlerhaft ist, klicken Sie auf die Schaltfläche «JSON reparieren», um es vor der Konvertierung automatisch zu reparieren.
Ja. Das Tool verwendet den just-types-Rendermodus von quicktype-core und generiert use serde::{Serialize, Deserialize}; und #[derive(Serialize, Deserialize)] für Rust, direkt verwendbar mit serde_json zur Deserialisierung. Wenn Sie Serde nicht benötigen, können Sie die derive- und use-Anweisungen manuell entfernen.
Alle gültigen JSON-Strukturen werden unterstützt: Grundtypen (null, boolean, number, string), Arrays (eindimensional oder mehrdimensional), verschachtelte Objekte (beliebige Tiefe). JSON-Objekte generieren eine Root-struct; JSON-Arrays generieren einen Root-Typ Vec<T>. Nicht-JSON-Werte wie JavaScript-Objektliterale, Funktionen, Symbol, undefined werden nicht unterstützt.
Zeichenfolgen werden zu String, Ganzzahlen zu i64, Gleitkommazahlen zu f64, Boolesche Werte zu bool, Arrays zu Vec<T>, verschachtelte Objekte zu unabhängigen struct, null zu Option<serde_json::Value>. Detaillierte Zuordnungsregeln finden Sie in der «Schnellreferenztabelle JSON-Typen zu Rust-Typen» unten.
Nullwerte in JSON generieren Option<serde_json::Value>, was bedeutet, dass das Feld fehlen oder einen unsicheren Typ haben kann. Wenn Sie den tatsächlichen Feldtyp bereits kennen, können Sie im Quell-JSON einen Beispielwert angeben (z.B. "field": "" leitet String ab) und ihn dann nach der Generierung je nach Geschäftsanforderungen in präzisere Typen wie Option<String>, Option<i64> ändern.
Ja. JSON-Arrays werden einheitlich in Rusts generische Vec<T> konvertiert, wobei die Elementtypen automatisch aus dem ersten Array-Element abgeleitet werden. Zum Beispiel generiert ["a","b"] Vec<String>, [1,2,3] Vec<i64>, [{...},{...}] Vec<Item>. Leere Arrays [] werden standardmäßig zu Vec<serde_json::Value>, können nach der Generierung je nach Kontext manuell in bestimmte Typen geändert werden.
Jedes verschachtelte Objekt generiert eine unabhängige struct, benannt nach Großschreibung des ersten Buchstabens des Feldnamens. Wenn das Root-Objekt beispielsweise ein address-Feld enthält, werden sowohl Root- als auch Address-structs generiert, auf die in Root über address: Address verwiesen wird. Objekte mit gleicher Struktur verwenden denselben Typ wieder, um doppelte Definitionen zu vermeiden.
quicktype-core verwendet standardmäßig den JSON-Quellnamen (wie User) als Root-struct-Namen. Sie können Struct-Namen und Referenzstellen nach der Generierung manuell ändern. Der Dateiname der heruntergeladenen .rs-Datei kann beim Speichern ebenfalls nach Bedarf umbenannt werden. Wenn das Tool automatisch nach einem bestimmten Feld benennen soll, passen Sie den obersten JSON-Schlüssel vor dem Einfügen an.
Ja, er kann direkt verwendet werden, aber stellen Sie sicher, dass das Projekt serde- und serde_json-Abhängigkeiten hinzugefügt hat. Fügen Sie in Cargo.toml serde = { version = "1", features = ["derive"] } und serde_json = "1" hinzu, dann können Sie serde_json::from_str::<User>(&json) oder serde_json::from_reader(reader) verwenden, um die generierten structs zu deserialisieren.
Ja. Sowohl die JSON-Extractor von Actix-web 4.x als auch axum 0.7+ basieren auf serde_json; die generierte struct dient direkt als Handler-Parameter. Beispiel in axum: async fn create_user(Json(payload): Json<CreateUserRequest>) -> ...; in Actix-web: web::Json<CreateUserRequest>. Keine zusätzlichen Annotationen erforderlich.
Ja. reqwests response.json::<T>() ruft intern serde_json auf; übergeben Sie den generierten Struct-Typ: let user: User = reqwest::get(url).await?.json().await?;. Wenn Backend-API-Felder snake_case sind, während Rust-Felder camelCase sind, fügen Sie manuell #[serde(rename = "user_name")] hinzu.
Ja. Tauri-Befehlsfunktionsparameter werden über serde deserialisiert; verwenden Sie die generierte struct als Parametertyp: #[tauri::command] fn create_user(payload: CreateUserRequest) -> Result<User, String>. Wenn das Frontend-JS invoke('create_user', payload) aufruft, wird payload automatisch zu JSON serialisiert und dann auf Rust-Seite deserialisiert.
Das Tool generiert standardmäßig Grundtypen wie String und i64. Wenn Sie semantische Typen wie chrono::DateTime<Utc>, uuid::Uuid, url::Url, std::net::IpAddr benötigen, passen Sie die Feldtypen nach der Generierung manuell an. Diese Typen implementieren alle Serde's Deserialize; verwenden Sie einfach chrono::{DateTime, Utc}; und sie kompilieren.
Läuft vollständig in Ihrem lokalen Browser. JSON-Parsing, Rust-Codegenerierung und Dateidownloads erfolgen alle im Browser über JavaScript und quicktype-core Web Worker; weder eingegebene JSON-Daten noch generierter Rust-Code werden an einen Server hochgeladen, noch in der Cloud protokolliert oder zwischengespeichert. Vertrauliches JSON mit API-Schlüsseln, Tokens oder nicht veröffentlichten Geschäftsfeldern ist sicher verwendbar; Daten werden beim Schließen der Seite gelöscht.
Nein. Das Tool ist vollständig kostenlos, keine Registrierung, Anmeldung oder Autorisierung erforderlich. Seite öffnen und verwenden; alle Funktionen sind lokal in Ihrem Browser verfügbar.
Das Tool erkennt automatisch die JSON-Gültigkeit; bei Fehlern erscheint rechts eine rote Fehlermeldung mit einer Schaltfläche «JSON reparieren». Beim Klicken werden häufige Fehler automatisch behoben: abschließende Kommas, einfache Anführungszeichen durch doppelte ersetzt, fehlende Anführungszeichen für Schlüssel ergänzt, Kommentare entfernt usw. Nach erfolgreicher Reparatur generiert es weiter Rust-Code.
Es gibt keine explizite Zeilenbegrenzung, aber Browser-Parsing und -Rendern sehr großer JSONs werden langsamer. Empfehlungen: ① Teilen Sie JSON und konvertieren Sie stapelweise; ② Konzentrieren Sie sich jeweils auf eine Verschachtelungsebene; ③ Wenn Sie 100+ Structs stapelweise generieren müssen, verwenden Sie das quicktype-CLI-Tool (npm i -g quicktype) oder IDE-Plugins.
Beide konvertieren JSON in Typdefinitionen der Zielsprache, aber die Ausgabeformen unterscheiden sich: JSON zu Rust generiert Serde-abgeleitete Structs, die zur Laufzeit deserialisierbare Datenmodelle sind; JSON zu TypeScript generiert interface/type-Deklarationen, die nur zur Kompilierzeit-Typprüfung verwendet werden. Wählen Sie je nach Tech-Stack und Laufzeitszenario.
Die Struct-Definitionen selbst können no_std sein (abhängen nur von core, nicht von std). Aber serde_json unter no_std erfordert die Verwendung von serde_json::de::from_slice und die Aktivierung entsprechender Features und kann String nicht verwenden (muss durch &str oder heapless::String ersetzt werden). In eingebetteten Szenarien müssen Sie normalerweise Feldtypen und Allokatoren manuell anpassen.
Das Tool behält ursprüngliche JSON-Feldnamen bei (einschließlich snake_case); Rust-Felder folgen standardmäßig der snake_case-Namenskonvention, sodass bei Übereinstimmung mit JSON-Namen keine Inkonsistenzen auftreten. Wenn Feldunterschiede auftreten, liegt das normalerweise daran, dass das Quell-JSON Sonderzeichen enthält oder doppelte Schlüssel zusammengeführt wurden; wir empfehlen, vor der Konvertierung in einem JSON-Reparaturtool zu bereinigen.
Das Tool leitet automatisch entsprechende Rust-Typen entsprechend dem Typ des JSON-Werts ab:
| JSON-Wertbeispiel | Generierter Rust-Typ | Beschreibung |
|---|---|---|
null | Option<serde_json::Value> | Nullwerttyp ungewiss; umschließt serde_json::Value mit Option als Fallback |
true / false | bool | JSON-Boolesche Werte werden direkt Rust bool zugeordnet |
42 | i64 | JSON-Ganzzahlen standardmäßig i64 (nach Bedarf manuell in u32/usize ändern) |
3.14 | f64 | JSON-Gleitkommazahlen standardmäßig f64 (f64 für Hochpräzisionsszenarien empfohlen) |
"hello" | String | JSON-Zeichenfolgen werden Rust String zugeordnet (können manuell in &str/chrono::DateTime/uuid::Uuid geändert werden) |
["a","b"] | Vec<String> | Zeichenfolgenarrays werden zu Vec<String> |
[1,2,3] | Vec<i64> | Ganzzahl-Arrays werden zu Vec<i64> |
[{...},{...}] | Vec<Item> | Objektarrays generieren entsprechende Struct aus erstem Element, dann mit Vec umschlossen |
[] | Vec<serde_json::Value> | Leere Arrays können Elementtyp nicht ableiten; verwenden serde_json::Value als Fallback, empfehlen manuelle Änderung zu konkretem Typ nach Generierung |
{...} verschachteltes Objekt | Unabhängige struct | Verschachtelte Objekte generieren unabhängige structs, Feldnamen großgeschrieben (z.B. address→Address) |
{ "key": null } | Option<serde_json::Value> | Wenn Feldwert null ist, standardmäßig Option<serde_json::Value>; kann manuell in Option<String> geändert werden |
Alle Operationen dieses JSON-zu-Rust-Tools erfolgen vollständig lokal in Ihrem Browser: JSON-Parsing, Rust-Codegenerierung und Dateidownloads werden alle clientseitig über das quicktype-core-WebAssembly-Modul ausgeführt; kein JSON-Inhalt, keine hochgeladenen Dateien oder generierter Code werden über das Netzwerk an einen Server gesendet. Dateiuploads verwenden die native FileReader-API des Browsers, um direkt in den Speicher zu lesen, ohne zwischengeschaltete Dienste zu durchlaufen. Kein Cookie-Tracking, keine Benutzereingaben oder Nutzungsdaten werden gesammelt. Nach dem Schließen oder Aktualisieren der Seite werden alle Ein- und Ausgaben automatisch aus dem Speicher gelöscht. Geeignet für die Verarbeitung von JSON mit API-Schlüsseln, Tokens, Benutzerdatenschutzdaten, nicht veröffentlichten Geschäftsstrukturen und internen Schnittstellenfeldern.