Aprenda como converter dados entre o formato JSON e objetos Rust sem esforço usando técnicas de serialização e desserialização em Rust.
JSON (JavaScript Object Notation) surgiu como um formato popular de intercâmbio de dados em software desenvolvimento devido à sua simplicidade, legibilidade e amplo suporte em vários programas línguas. JSON é uma alternativa leve ao XML para transmissão de dados entre um servidor e um aplicativo da Web ou entre diferentes componentes do sistema de software.
Um dos principais aspectos do trabalho com JSON é o processo de serialização e desserialização que permite que você converta dados JSON em um formato estruturado que você pode manipular facilmente em seu programas. Na maioria das vezes, se você quiser trabalhar com JSON em outras linguagens, pode ser necessário serializar e desserializar os dados JSON nas estruturas de dados integradas da linguagem.
Introdução ao Serde
Serde (serialização e desserialização) é uma biblioteca Rust amplamente usada que fornece uma estrutura para converter
Rust estruturas de dados em formatos para armazenamento, transmissão, compartilhamento e outros.O Serde permite a conversão perfeita entre tipos de dados Rust e vários formatos de intercâmbio de dados, incluindo JSON, YAML, BSON, CBOR, MessagePack e outros.
O foco principal da Serde é tornar o processo de serialização e desserialização o mais simples e eficiente possível, mantendo fortes recursos de digitação e segurança.
Adicione essas diretivas ao dependências seção do seu Cargo.toml arquivo para instalar e usar serde como um dependência de terceiros com Cargo.
[dependências]
serde = { versão = "1.0.159", características = ["derivar"] }
serde_json = "1.0.96"
Você precisará dos dois serde e serde_json caixas para interagir com JSON. O serde A caixa fornece as principais funcionalidades, e o serde_json crate é uma implementação específica do Serde para trabalhar com JSON.
Veja como você pode importar o serde_json caixote e o serializar e desserializar módulos do serde caixote:
usar serde::{Serialize, Deserialize};
usar serde_json;
No geral, Serde é uma ferramenta poderosa que você precisará em seu arsenal de desenvolvimento se estiver trabalhando com JSON em Rust.
Serialização de dados com Serde
O processo de serialização JSON envolve a conversão de um tipo Rust (personalizado ou integrado) em JSON para outras operações. Serde fornece um conjunto de atributos que você pode usar com Rust struct para permitir controle preciso sobre o processo de serialização, incluindo o #[derivar (serializar)] atributo que permite gerar código de serialização para suas estruturas de dados e converter sua estrutura Rust em JSON.
Considere esta estrutura representando os dados biológicos de uma pessoa; veja como você pode importar e usar o serializar atributo na estrutura:
usar serde::{Serialize, Deserialize};
usar serde_json;
#[derivar (serializar)]
estruturaPessoa {
nome: Corda,
idade: u32,
}
Ao anotar o Pessoa estrutura com o [#derive (Serializar)], você está dizendo ao Serde para gerar o código de serialização necessário para o Pessoa estrutura automaticamente.
Veja como você pode serializar uma instância do Pessoa estrutura para JSON:
usar serde::{Serialize};
usar serde_json;fnprincipal() {
// declaração da instância da struct Person com os campos name e age
deixar pessoa = Pessoa {
nome: "Chukwuemeriwo".para sequenciar(),
idade: 28,
};// serializa a pessoa struct para JSON usando a biblioteca serde_json
deixar json = serde_json:: to_string(&pessoa).expect("Falha na serialização");
// imprime a string JSON serializada
println!("JSON serializado: {}",json);
}
No principal função, o serde_json caixa serializa o pessoa objeto. O para sequenciar função leva uma referência ao pessoa objeto e retorna uma string JSON representando os dados serializados.
finalmente, o principal A função imprime o JSON serializado no console.
O serde e serde_json são versáteis, você também pode serializar arrays com serde.
usar serde::{Serialize, Deserialize};
usar serde_json;#[derivar (serializar)]
estruturaCoordenadas {
x: f32,
você: f32,
}fnprincipal() {
deixar pontos = você![
Coordenadas X: 1.0, você: 2.0 },
Coordenadas X: 3.5, você: 4.5 },
];deixar json = serde_json:: to_string(&points).expect("Falha na serialização");
println!("JSON serializado: {}",json); // Imprime a string JSON serializada
}
O pontos variável é um vetor de Coordenadas structs que representam pontos em um plano. Aplicando o serializar atributo para o Coordenadas struct permite serializar o vetor para JSON sem esforço.
Além disso, você pode serializar enums em JSON com serde como você serializa estruturas e vetores.
usar serde::{Serialize, Deserialize};
usar serde_json;#[derivar (serializar, desserializar)]
enumerarAnimal {
Cachorro(Corda),
Gato(u32),
Pássaro,
}fnprincipal() {
deixar cachorro = Animal:: Cachorro("Oxidado".para sequenciar());deixar json = serde_json:: to_string(&dog).expect("Falha na serialização");
println!("JSON serializado: {}",json);
}
Dependendo da variante, o processo de serialização se adapta de acordo (neste caso, o Animal:: Cão variante inclui um Corda campo que o Serde irá serializar como uma string JSON).
Desserialização de dados com Serde
A desserialização JSON é o processo de transformação de dados JSON em tipos de dados nativos de uma linguagem de programação. Serde fornece uma estrutura abrangente para desserialização JSON que funciona na maioria dos tipos de dados integrados.
Semelhante à serialização, o Serde oferece atributos que você pode usar para anotar suas estruturas Rust para o processo de desserialização. Dois atributos comumente usados para serialização são os #[derivar (Deserialize)] e #[serde (rename = "json_field_name")] atributos.
O #[derivar (Deserialize)] atributo deriva automaticamente a implementação de desserialização para o seu Tipos de estrutura de ferrugem, enquanto o #[serde (rename = "json_field_name")] O atributo permite mapear campos struct para nomes de campo JSON correspondentes.
Veja como você pode desserializar dados JSON em um tipo de struct personalizado com Serde:
usar serde:: Deserialize;
usar serde_json;// define uma struct para Person com o traço Deserialize de Serde
#[derivar (Deserialize)]
estruturaPessoa {
#[serde (renomear = "nome")]// renomeia o campo para "nome"
nome completo: Corda,
idade: u32,
}fnprincipal() {
deixar json_data = r#"
{
"nome": "John Doe",
"idade": 30
}
"#;// desserializa os dados JSON em uma estrutura Person
deixar pessoa: Pessoa = serde_json:: from_str (json_data).unwrap();
// Imprime o nome completo e a idade da pessoa
println!("Nome: {}", person.full_name);
println!("Idade: {}", pessoa.idade);
}
Ao anotar o Pessoa estrutura com o #[derivar (Deserialize)] atributo, você indica que o Serde pode desserializar a estrutura do JSON. O #[serde (renomear = "nome")] atributos mapeiam o nome campo no JSON para o nome completo campo.
O from_str função desserializa o json_data variável no pessoa objeto, e o principal A função imprime os campos no console.
Serde oferece suporte à desserialização em vários tipos de dados Rust, incluindo tipos primitivos, enums, estruturas aninhadas e coleções.
Veja como você pode desserializar um array JSON em uma estrutura Rust contendo um campo vetorial:
usar serde:: Deserialize;#[derivar (Deserialize)]
estruturaDados {
números: vec<u32>,
}fnprincipal() {
deixar json_data = r#"
{
"números": [1, 2, 3, 4, 5]
}
"#;deixar data: Data = serde_json:: from_str (json_data).unwrap();
para número em dados.números {
println!("Número: {}", número);
}
}
O principal função desserializa o json_data conteúdo JSON no dados variável e o loop imprime os elementos no vetor.
Você deve garantir que possui os tipos de dados e identificadores corretos para um processo de desserialização.
Serde interopera com estruturas populares da Web Rust
Serde é uma biblioteca poderosa com muitos recursos e uma API simples para serializar e desserializar dados em diferentes formatos.
Serde é amplamente adotado no ecossistema Rust, e muitas caixas e estruturas populares possuem suporte para Serde, incluindo estruturas populares da web como Actix, Warp e Rocket e ORMs de banco de dados como Diesel.
