JSON Swiss

JSON Swiss

Gerador de JSON para Rust

Entrada JSON

Carregando editor…

Rust Gerado

Configuration

Insira dados JSON para gerar structs Rust

Structs com suporte a serde e type safety

Como converter JSON para Rust – guia passo a passo

Use este gerador JSON para Rust para criar estruturas Rust a partir de amostras JSON para serviços e ferramentas CLI com suporte serde.

  1. Passo 1 – Cole uma amostra JSON

    • Cole um objeto ou matriz JSON representativo no editor esquerdo.
    • Inclua objetos aninhados, matrizes e campos anuláveis para que os tipos sejam inferidos corretamente.
    • Use Import para carregar JSON de um arquivo, URL ou dados de amostra.

  2. Passo 2 – Escolha as opções de estrutura Rust

    • Defina uma raiz Struct Name (por exemplo Root).
    • Decida como lidar com campos opcionais (Option<T>) e valores desconhecidos (serde_json::Value).
    • Confirme os atributos de nomenclatura e serde para que as chaves JSON sejam mapeadas corretamente.

  3. Passo 3 – Revise o código gerado

    • Verifique nomes de campos, tipos e como matrizes/objetos são modelados.
    • Ajuste opções como Root Type Name, tratamento nulo e estruturas, se disponíveis.
    • Se um campo for inferido incorretamente, ajuste seu JSON de amostra e gere-o novamente.

  4. Passo 4 – Use as estruturas com serde

    • Adicione serde e serde_json às suas dependências e habilite derivar macros.
    • Desserialize JSON em sua estrutura raiz usando serde_json::from_str.
    • Adicione validação após a desserialização quando precisar de garantias mais fortes.

  5. Passo 5 – Copiar ou baixar

    • Copie a saída em seu projeto ou baixe-a como um arquivo.
    • Execute seu formatador/linter para corresponder ao seu estilo de código.
    • Adicione bibliotecas de análise/serialização JSON se sua linguagem exigir.

Dicas rápidas

  • Use Option<T> para campos que podem estar ausentes ou nulos.
  • Prefira os tipos chrono somente quando o formato do carimbo de data/hora for estável.
  • Mantenha as estruturas DTO separadas dos tipos de domínio interno para maior flexibilidade.
Saída de exemplo (simplificada)
// Entrada JSON
{
  "id": 123,
  "name": "Maeve Winters",
  "email": "[email protected]",
  "active": true,
  "roles": ["admin", "editor"],
  "metadata": { "plan": "pro" },
  "createdAt": "2024-03-01T10:15:00Z",
  "score": 99.5,
  "notes": null
}

// Generated Rust structs (simplified)
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct Metadata {
  pub plan: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
  pub id: i64,
  pub name: String,
  pub email: Option<String>,
  pub active: bool,
  pub roles: Vec<String>,
  pub metadata: Metadata,
  pub created_at: String,
  pub score: f64,
  pub notes: serde_json::Value,
}

Ferramentas JSON e Rust relacionadas

Explore mais ferramentas JSON e de esquema que funcionam muito bem junto com este gerador JSON para Rust.

Estrutura Rust para JSON e esquema JSON

Converta estruturas Rust existentes em exemplos JSON e esquema JSON para documentos e validação.

Gerador de esquema JSON

Gere um esquema JSON a partir de amostras JSON para validar cargas e contratos.

Formatador e validador JSON

Formate e valide o JSON antes de gerar estruturas para evitar problemas de tempo de execução.

Gerador JSON para Go

Gere estruturas Go ao também manter serviços Go.

Editor de tabela

Interface visual em tabela com edição de dados JSON em tempo real

Perguntas Frequentes

Quais recursos de Rust são suportados?

O gerador cria definições de structs Rust com derive macros, suporta serde para serialização/deserialização, usa Option para valores null e segue convenções de nomenclatura do Rust.

Como o serde é tratado?

As structs geradas incluem derives Serialize e Deserialize, além de atributos serde para mapear nomes e lidar com campos opcionais.

Como valores opcionais são tratados?

Valores null no JSON são mapeados para Option<T> em Rust. Campos opcionais podem incluir atributos como #[serde(skip_serializing_if = "Option::is_none")].

Como coleções são tratadas?

Arrays JSON são mapeados para Vec<T>, e objetos aninhados geram structs separadas. Estruturas complexas são suportadas com tipos genéricos corretos.