Nog geen content
Gratis online tool JSON naar Rust. Plak API-response JSON om automatisch Serde derive structs te genereren, geneste objecten onafhankelijk gesplitst, Vec en Option slim afgeleid, pure lokale browserconversie, geen registratie nodig.
JSON naar Rust is het proces van het converteren van JSON-gegevens naar Rust struct typedefinities.
Deze tool draait lokaal in de browser gebaseerd op quicktype-core.
Type-inferentie is het hart van JSON naar Rust.
Alle berekeningen vinden plaats in de browser, geen gegevens worden naar servers verzonden.
Gegenereerde code wordt typisch gebruikt in Cargo-projecten.
Automatisch gegenereerde code is een startpunt, geen eindpunt.
Gebruik Actix-web 4.x met de gegenereerde struct als web::Json<T> parameter.
// 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};
#[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>,
}
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)
}
#[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
}axum server gebruikt Json<T> extractor, reqwest client gebruikt .json::<T>().
// Cargo.toml
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// reqwest = { version = "0.12", features = ["json"] }
use axum::{routing::get, Json, Router};
use serde::{Deserialize, Serialize};
#[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> }
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()] })
}
#[tokio::main]
async fn main() {
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();
}Plak JSON in de linker editor, de tool genereert automatisch Rust code.
Ja, inclusief #[derive(Serialize, Deserialize)] en use statements.
Alle geldige JSON-structuren: primitieve typen, arrays, geneste objecten.
Strings→String, integers→i64, floats→f64, booleans→bool, arrays→Vec<T>, geneste objecten→onafhankelijke struct, null→Option<serde_json::Value>.
Null-waarden genereren Option<serde_json::Value>.
Ja, JSON arrays worden Vec<T>.
Elk genest object genereert een onafhankelijke struct.
Ja, wijzig namen handmatig na generatie.
Ja, voeg serde en serde_json toe aan Cargo.toml.
Ja, direct als web::Json<T> of Json<T> parameter.
Ja, gebruik als #[tauri::command] parametertype.
Ja, wijzig typen handmatig na generatie.
Nee, alles lokaal in de browser.
Nee, volledig gratis zonder registratie.
De tool leidt automatisch de corresponderende Rust-typen af:
| Voorbeeld JSON | Gegenereerd Rust-type | Beschrijving |
|---|---|---|
null | Option<serde_json::Value> | Null-waarde, Option als fallback |
true / false | bool | JSON booleans → bool |
42 | i64 | JSON integers → i64 |
3.14 | f64 | JSON floats → f64 |
"hello" | String | JSON strings → String |
["a","b"] | Vec<String> | String arrays → Vec<String> |
[1,2,3] | Vec<i64> | Integer arrays → Vec<i64> |
[{...},{...}] | Vec<Item> | Object arrays → Vec<Item> |
[] | Vec<serde_json::Value> | Lege array |
{...} genest object | onafhankelijke struct | Geneste objecten genereren onafhankelijke struct |
Alle bewerkingen van deze JSON naar Rust tool vinden volledig lokaal plaats in de browser: JSON parsing, Rust codegeneratie en bestandsdownloads worden allemaal client-side uitgevoerd via de quicktype-core WebAssembly module; geen JSON-inhoud, geüploade bestanden of gegenereerde code wordt via het netwerk naar servers verzonden.