Nenhum conteúdo ainda
Ferramenta online gratuita JSON para Rust. Cole JSON de resposta de API para gerar automaticamente structs com derive Serde, objetos aninhados divididos independentemente, Vec e Option deduzidos inteligentemente, conversão local pura no navegador, sem registro necessário.
JSON para Rust é o processo de converter dados no formato JSON em definições de tipo struct Rust.
Esta ferramenta executa localmente no navegador baseada em quicktype-core.
Inferência de tipos é o coração de JSON para Rust.
Todos os cálculos acontecem no navegador, nenhum dado é enviado para servidores.
O código gerado é tipicamente usado em projetos Cargo.
Código gerado automaticamente é um ponto de partida, não um ponto final.
Use Actix-web 4.x com a struct gerada como parâmetro 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
}Servidor axum usa extrator Json<T>, cliente 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();
}Cole JSON no editor à esquerda, a ferramenta gera automaticamente o código Rust.
Sim, inclui #[derive(Serialize, Deserialize)] e as instruções use.
Todas as estruturas JSON válidas: tipos primitivos, arrays, objetos aninhados.
Strings→String, inteiros→i64, floats→f64, booleanos→bool, arrays→Vec<T>, objetos aninhados→struct independente, null→Option<serde_json::Value>.
Valores null geram Option<serde_json::Value>.
Sim, arrays JSON se tornam Vec<T>.
Cada objeto aninhado gera uma struct independente.
Sim, modifique manualmente os nomes após a geração.
Sim, adicione serde e serde_json ao Cargo.toml.
Sim, diretamente como parâmetro web::Json<T> ou Json<T>.
Sim, use como tipo de parâmetro #[tauri::command].
Sim, modifique manualmente os tipos após a geração.
Não, tudo executa localmente no navegador.
Não, completamente gratuito sem registro.
A ferramenta deduce automaticamente os tipos Rust correspondentes:
| Exemplo JSON | Tipo Rust gerado | Descrição |
|---|---|---|
null | Option<serde_json::Value> | Valor null, Option como fallback |
true / false | bool | Booleanos JSON → bool |
42 | i64 | Inteiros JSON → i64 |
3.14 | f64 | Floats JSON → f64 |
"hello" | String | Strings JSON → String |
["a","b"] | Vec<String> | Array de strings → Vec<String> |
[1,2,3] | Vec<i64> | Array de inteiros → Vec<i64> |
[{...},{...}] | Vec<Item> | Array de objetos → Vec<Item> |
[] | Vec<serde_json::Value> | Array vazio |
{...} objeto aninhado | struct independente | Objetos aninhados geram struct independente |
Todas as operações desta ferramenta JSON para Rust acontecem completamente localmente no navegador: parsing JSON, geração de código Rust e download de arquivos são executados no lado do cliente através do módulo WebAssembly quicktype-core; nenhum conteúdo JSON, arquivos carregados ou código gerado é enviado pela rede para servidores.