JSON para Rust

Sugestões Relacionadas

Sobre JSON para Rust: Converter dados JSON em structs Rust compiláveis

Casos de uso

• Integração REST API
• Desenvolvimento backend Actix-web
• Desenvolvimento backend axum
• Definição de interface de microsserviços
• Desenvolvimento de ferramentas CLI
• Projetos WebAssembly
• Apps desktop Tauri
• Parsing dados web scraper
• Desenvolvimento de jogos
• IoT e embarcados
• Migração de banco de dados
• Blockchain/Web3
• Construção de dados de teste
• Parsing de logs estruturados
• Migração de centro de configuração
• Colaboração cross-language
• Manutenção SDK open source
• Exemplos didáticos Rust
• Conversão de nomes de campo

Como Usar

1. Cole JSON no editor à esquerda ou carregue um arquivo
2. Aguarde 400ms para conversão automática
3. Se JSON estiver malformado clique «Reparar JSON»
4. Clique «Copiar» ou «Baixar» para salvar arquivo .rs
5. Adicione dependências serde e serde_json ao Cargo.toml
6. (Opcional) Ajuste manualmente os tipos de campo

Recursos

• Conversão local no navegador
• Saída pronta para Serde
• Inferência inteligente de tipos
• Divisão automática de objetos aninhados
• Tratamento automático de Vec e Option
• Pronto para Actix-web/axum/reqwest
• Auto-conversão com debounce de 400ms
• Correção de erros JSON em um clique
• Copiar e baixar
• Histórico localStorage
• Painéis responsivos
• Dados de exemplo + upload de arquivo

Exemplos de Código

// 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
}

// 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();
}

Perguntas frequentes

Solução de Problemas

Glossário

struct

Palavra-chave em Rust para definir tipos de dados compostos.

Serde

Framework de serialização/deserialização mais popular no ecossistema Rust.

Vec<T>

Tipo array dinâmico na biblioteca padrão Rust.

Option<T>

Tipo valor opcional na biblioteca padrão Rust.

Cargo

Sistema de build e gerenciador de pacotes oficial do Rust.

serde_json

Crate do framework Serde específico para processamento JSON.

Serialize

Trait de serialização do Serde.

Deserialize

Trait de deserialização do Serde.

quicktype-core

Biblioteca de inferência de tipos e geração de código multilíngue.

chrono

Biblioteca de data/hora mais popular no ecossistema Rust.

no_std

Modo de compilação Rust que desabilita a biblioteca padrão.

tokio

Runtime assíncrono mais popular no ecossistema Rust.

Tabela de referência tipos JSON → tipos Rust

A ferramenta deduce automaticamente os tipos Rust correspondentes:

Privacy & Security

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.

Authoritative References

• SerdeDocumentação oficial Serde
• RustDocumentação oficial Rust - Capítulo Structs