Learn Rust Coding · Aula

Serialização personalizada

Atributos de campos

Serialização personalizada é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 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.

Personalizando o serde

serde oferece um controle preciso sobre como os campos são mapeados para um formato usando atributos. Pode renomear campos, ignorá-los, definir valores padrão e muito mais, tudo por meio de #[serde(...)].

Renomeando um campo

Use rename para mapear o nome de um campo Rust para uma chave diferente na saída, o que é útil quando o JSON usa uma convenção diferente.

use serde::Serialize;

#[derive(Serialize)]
struct User {
    #[serde(rename = "userName")]
    user_name: String,
}

Renomeando tudo

Aplique uma convenção de nomenclatura a todos os campos de uma só vez com rename_all, por exemplo, de snake_case no Rust para camelCase no JSON.

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct User {
    first_name: String,
    last_name: String,
}

Ignorando campos

skip omite completamente um campo. skip_serializing_if o omite condicionalmente, por exemplo, para ocultar opções vazias.

use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    nickname: Option<String>,
}

Valores padrão na desserialização

default fornece um valor quando um campo está ausente na entrada, para que a desserialização não falhe.

use serde::Deserialize;

#[derive(Deserialize)]
struct Config {
    #[serde(default)]
    retries: u32,
}

Função padrão personalizada

Aponte default para uma função que forneça um valor padrão diferente de zero.

use serde::Deserialize;

fn default_port() -> u16 { 8080 }

#[derive(Deserialize)]
struct Config {
    #[serde(default = "default_port")]
    port: u16,
}

Modelando renomeação + valor padrão

A lógica dos atributos consiste apenas no mapeamento de chaves e em um valor alternativo. Este exemplo executável reproduz esse comportamento com um HashMap.

use std::collections::HashMap;

fn main() {
    let mut input: HashMap<&str, &str> = HashMap::new();
    input.insert("userName", "Alice");
    let user_name = input.get("userName").copied().unwrap_or("anon");
    let port = input.get("port").copied().unwrap_or("8080");
    println!("user_name={} port={}", user_name, port);
}

Aliases na desserialização

alias aceita uma chave alternativa durante a leitura, o que é útil ao oferecer suporte a nomes de campos antigos e novos.

use serde::Deserialize;

#[derive(Deserialize)]
struct User {
    #[serde(alias = "username")]
    name: String,
}

Achatar

flatten insere os campos de uma estrutura aninhada no objeto pai, removendo um nível de aninhamento no JSON.

use serde::Serialize;

#[derive(Serialize)]
struct Meta { page: u32 }

#[derive(Serialize)]
struct Resp {
    data: String,
    #[serde(flatten)]
    meta: Meta,
}

Personalização com módulo

Para ter controle total, aponte with para um módulo que exponha funções serialize e deserialize, por exemplo, para formatar um carimbo de data e hora.

use serde::Serialize;

#[derive(Serialize)]
struct Event {
    #[serde(with = "my_date_format")]
    at: i64,
}

Marcação de enumeradores

Controle como os enumeradores são codificados com tag (marcação interna) ou untagged. Isso define a estrutura JSON para tipos variantes.

use serde::Serialize;

#[derive(Serialize)]
#[serde(tag = "type")]
enum Event {
    Click { x: i32, y: i32 },
    Key { code: u8 },
}

Verificação rápida

Teste sua compreensão da serialização personalizada.

Recapitulação

Você aprendeu a personalizar a serialização:

rename e rename_all mapeiam nomes de campos
skip e skip_serializing_if controlam a saída
default e alias facilitam a desserialização
flatten, with e tag de enumeradores lidam com a estrutura

A seguir: formatos além de JSON.

Perguntas Frequentes

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

Sim — o texto completo de “Serialização personalizada” é 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 personalizada”?

Atributos de campos 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 3 de 4.

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

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