Sense contingut
Eina en línia gratuïta JSON a Rust. Enganxa JSON de resposta d'API per generar automàticament structs amb derive Serde, objectes anidats dividits independentment, Vec i Option deduïts intel·ligentment, conversió local pura al navegador, sense necessitat de registre.
JSON a Rust és el procés de convertir dades en format JSON en definicions de tipus struct Rust.
Aquesta eina s'executa localment al navegador basada en quicktype-core.
La inferència de tipus és el cor de JSON a Rust.
Tots els càlculs passen al navegador, cap dada s'envia a servidors.
El codi generat s'utilitza típicament en projectes Cargo.
El codi generat automàticament és un punt de partida, no un punt final.
Utilitza Actix-web 4.x amb la struct generada com a paràmetre 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
}El servidor axum utilitza l'extractor Json<T>, el client reqwest utilitza .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();
}Enganxa JSON a l'editor de l'esquerra, l'eina genera automàticament codi Rust.
Sí, inclou #[derive(Serialize, Deserialize)] i les instruccions use.
Totes les estructures JSON vàlides: tipus primitius, arrays, objectes anidats.
Cadenes→String, enters→i64, floats→f64, booleans→bool, arrays→Vec<T>, objectes anidats→struct independent, null→Option<serde_json::Value>.
Els valors null generen Option<serde_json::Value>.
Sí, els arrays JSON es converteixen a Vec<T>.
Cada objecte anidat genera una struct independent.
Sí, modifica els noms manualment després de la generació.
Sí, afegeix serde i serde_json a Cargo.toml.
Sí, directament com a paràmetre web::Json<T> o Json<T>.
Sí, utilitza com a tipus de paràmetre #[tauri::command].
Sí, modifica els tipus manualment després de la generació.
No, tot s'executa localment al navegador.
No, completament gratuït sense registre.
L'eina dedueix automàticament els tipus Rust corresponents:
| Exemple JSON | Tipus Rust generat | Descripció |
|---|---|---|
null | Option<serde_json::Value> | Valor null, Option com a fallback |
true / false | bool | Booleans JSON → bool |
42 | i64 | Enters JSON → i64 |
3.14 | f64 | Floats JSON → f64 |
"hello" | String | Cadenes JSON → String |
["a","b"] | Vec<String> | Arrays de cadenes → Vec<String> |
[1,2,3] | Vec<i64> | Arrays d'enters → Vec<i64> |
[{...},{...}] | Vec<Item> | Arrays d'objectes → Vec<Item> |
[] | Vec<serde_json::Value> | Array buit |
{...} objecte anidat | struct independent | Objectes anidats generen struct independent |
Totes les operacions d'aquesta eina JSON a Rust passen completament de forma local al navegador: el parsing JSON, la generació de codi Rust i la descàrrega de fitxers s'executen totes al costat del client mitjançant el mòdul WebAssembly quicktype-core; cap contingut JSON, fitxers carregats o codi generat s'envia per la xarxa a servidors.