Nessun contenuto
Strumento online gratuito JSON in Rust. Incolla JSON di risposta API per generare automaticamente struct con derive Serde, oggetti annidati suddivisi indipendentemente, Vec e Option dedotti intelligentemente, conversione locale pura nel browser, nessuna registrazione richiesta.
JSON in Rust è il processo di conversione dei dati in formato JSON in definizioni di tipo struct Rust.
Questo strumento viene eseguito localmente nel browser basato su quicktype-core.
L'inferenza dei tipi è il cuore di JSON in Rust.
Tutti i calcoli avvengono nel browser, nessun dato viene inviato a server.
Il codice generato viene tipicamente utilizzato in progetti Cargo.
Il codice generato automaticamente è un punto di partenza, non un punto di arrivo.
Usa Actix-web 4.x con la struct generata come parametro web::Json<T>.
// 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
}Server axum usa estrattore Json<T>, client reqwest usa .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();
}Incolla JSON nell'editor a sinistra, lo strumento genera automaticamente il codice Rust.
Sì, include #[derive(Serialize, Deserialize)] e le istruzioni use.
Tutte le strutture JSON valide: tipi primitivi, array, oggetti annidati.
Stringhe→String, interi→i64, float→f64, booleani→bool, array→Vec<T>, oggetti annidati→struct indipendente, null→Option<serde_json::Value>.
I valori null generano Option<serde_json::Value>.
Sì, gli array JSON diventano Vec<T>.
Ogni oggetto annidato genera una struct indipendente.
Sì, modifica manualmente i nomi dopo la generazione.
Sì, aggiungi serde e serde_json a Cargo.toml.
Sì, direttamente come parametro web::Json<T> o Json<T>.
Sì, usa come tipo parametro #[tauri::command].
Sì, modifica manualmente i tipi dopo la generazione.
No, tutto viene eseguito localmente nel browser.
No, completamente gratuito senza registrazione.
Lo strumento deduce automaticamente i tipi Rust corrispondenti:
| Esempio JSON | Tipo Rust generato | Descrizione |
|---|---|---|
null | Option<serde_json::Value> | Valore null, Option come fallback |
true / false | bool | Booleani JSON → bool |
42 | i64 | Interi JSON → i64 |
3.14 | f64 | Float JSON → f64 |
"hello" | String | Stringhe JSON → String |
["a","b"] | Vec<String> | Array di stringhe → Vec<String> |
[1,2,3] | Vec<i64> | Array di interi → Vec<i64> |
[{...},{...}] | Vec<Item> | Array di oggetti → Vec<Item> |
[] | Vec<serde_json::Value> | Array vuoto |
{...} oggetto annidato | struct indipendente | Oggetti annidati generano struct indipendenti |
Tutte le operazioni di questo strumento JSON in Rust avvengono completamente localmente nel browser: parsing JSON, generazione codice Rust e download file sono eseguiti tutti lato client tramite il modulo WebAssembly quicktype-core; nessun contenuto JSON, file caricati o codice generato viene inviato in rete a server.