Learn Rust Coding · Aula

Serialização e desserialização

Macros de derivação

Serialização e desserialização é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que é Serde?

Serde (SERialize/DEserialize) é a estrutura do Rust para converter estruturas de dados de e para formatos como JSON, YAML e outros.

Núcleo independente de formato, além de crates para cada formato
Orientado por macros derive

Adicionando serde

Adicione serde com o recurso derive, além de um crate de formato, como serde_json. Isso edita Cargo.toml.

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Derivando as características

Anote uma estrutura com #[derive(Serialize, Deserialize)] para torná-la conversível. Cada campo também precisa ser serializável.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
}

Serialize significa converter para um formato

Serialize transforma um valor em bytes ou texto em algum formato. A estrutura não sabe qual formato será usado; o crate do formato decide.

Deserialize significa converter de um formato

Deserialize analisa texto ou bytes e os transforma novamente em um valor Rust, validando tipos e campos obrigatórios durante o processo.

Modelando serialize manualmente

Para desenvolver a intuição, veja aqui um serializador escrito manualmente para uma estrutura simples. O serde gera um código semelhante para você.

struct User { id: u32, name: String }

fn serialize(u: &User) -> String {
    format!("id={};name={}", u.id, u.name)
}

fn main() {
    let u = User { id: 7, name: "Alice".to_string() };
    println!("{}", serialize(&u));
}

Modelando deserialize manualmente

E aqui está o processo inverso: analisar o texto e transformá-lo novamente na estrutura. O código gerado pelo serde faz isso de modo robusto em vários formatos.

struct User { id: u32, name: String }

fn deserialize(s: &str) -> User {
    let parts: Vec<&str> = s.split(',').collect();
    let id = parts[0].parse().unwrap();
    let name = parts[1].to_string();
    User { id, name }
}

fn main() {
    let u = deserialize("42,Bob");
    println!("{} {}", u.id, u.name);
}

Derivando em enumeradores

Os enumeradores também funcionam. Por padrão, cada variante é serializada pelo próprio nome, com seus dados aninhados.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { radius: f64 },
    Square { side: f64 },
}

Estruturas aninhadas

O serde faz a recursão automaticamente. Uma estrutura que contenha outras estruturas derivadas ou Vecs funciona diretamente.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Address { city: String }

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    addresses: Vec<Address>,
}

Somente Serialize ou somente Deserialize

Você pode derivar apenas uma característica. Um tipo de resposta de API pode ter somente Serialize; um tipo de requisição recebida pode ter somente Deserialize.

use serde::Serialize;

#[derive(Serialize)]
struct ApiResponse {
    status: u16,
    message: String,
}

Requisitos para derive

O tipo de cada campo precisa implementar a característica que você derivar. Os tipos e coleções padrão já fazem isso; tipos personalizados precisam de seu próprio derive.

use serde::Serialize;

#[derive(Serialize)]
struct Inner { x: i32 }

#[derive(Serialize)]
struct Outer { inner: Inner }

Verificação rápida

Teste sua compreensão de serialize e deserialize.

Recapitulação

Você aprendeu os fundamentos do serde:

serde é uma estrutura de (des)serialização independente de formato
#[derive(Serialize, Deserialize)] gera o código de conversão
Funciona com estruturas, enumeradores e tipos aninhados
Quando apropriado, você pode derivar apenas uma direção

A seguir: trabalhando com JSON usando serde_json.

Perguntas Frequentes

A aula “Serialização e desserialização” é grátis?

Sim — o texto completo de “Serialização e desserialização” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Serialização e desserialização”?

Macros de derivação Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Serialização e desserialização”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding