Learn Rust Coding · Aula

Outros formatos

TOML, YAML, bincode

Outros formatos é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 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.

Além do JSON

O núcleo do serde não depende de um formato específico, portanto a mesma estrutura derivada funciona com vários formatos, bastando trocar o pacote do formato.

TOML para configuração
YAML para dados fáceis de ler
bincode para dados binários compactos

Uma estrutura, muitos formatos

Você define a estrutura uma única vez. Cada pacote de formato fornece seus próprios equivalentes de to_string / from_str sobre as mesmas implementações de Serialize / Deserialize.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Config {
    name: String,
    port: u16,
}

TOML

TOML é popular para configurações (o próprio Cargo.toml o utiliza). O pacote toml serializa e analisa esse formato.

use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String, port: u16 }

fn to_toml(c: &Config) -> String {
    toml::to_string(c).unwrap()
}

Analisando TOML

Leia uma configuração TOML de volta para sua estrutura com toml::from_str.

use serde::Deserialize;

#[derive(Deserialize)]
struct Config { name: String, port: u16 }

fn parse(s: &str) -> Config {
    toml::from_str(s).unwrap()
}

YAML

YAML é adequado para dados editados por pessoas e que contenham aninhamento. Use um pacote como serde_yaml, com a mesma estrutura de API.

use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String, port: u16 }

fn to_yaml(c: &Config) -> String {
    serde_yaml::to_string(c).unwrap()
}

bincode

bincode é um formato binário compacto, excelente para armazenar em cache ou enviar pela rede quando o tamanho e a velocidade são importantes e ninguém precisa ler os dados.

use serde::Serialize;

#[derive(Serialize)]
struct Config { name: String, port: u16 }

fn to_bytes(c: &Config) -> Vec<u8> {
    bincode::serialize(c).unwrap()
}

Escolhendo um formato

Escolha com base no público:

Configuração legível por pessoas e com aninhamento: TOML ou YAML
APIs web: JSON
Armazenamento ou transporte binário interno: bincode

Modelando a escolha do formato

A decisão consiste apenas em mapear o caso de uso para um formato. Este exemplo executável representa essa lógica de seleção.

fn pick_format(use_case: &str) -> &str {
    match use_case {
        "config" => "TOML",
        "api" => "JSON",
        "cache" => "bincode",
        _ => "JSON",
    }
}

fn main() {
    println!("{}", pick_format("config"));
    println!("{}", pick_format("cache"));
    println!("{}", pick_format("api"));
}

Fazendo ida e volta com bytes

Os formatos binários permitem fazer uma ida e volta: serializar em bytes e depois desserializar de volta para a mesma estrutura. Este exemplo executável representa conceitualmente uma ida e volta baseada no comprimento dos bytes.

fn encode(name: &str) -> Vec<u8> {
    name.as_bytes().to_vec()
}

fn decode(bytes: &[u8]) -> String {
    String::from_utf8(bytes.to_vec()).unwrap()
}

fn main() {
    let bytes = encode("Alice");
    println!("len={}", bytes.len());
    println!("back={}", decode(&bytes));
}

Particularidades específicas de cada formato

Os formatos diferem em seus recursos. TOML não permite valores nulos e precisa de tabelas para aninhamento; YAML oferece suporte a âncoras; bincode não é autodescritivo, portanto os dois lados precisam compartilhar o tipo.

Os atributos continuam valendo

Os atributos #[serde(...)] que você aprendeu (rename, default, skip) funcionam em todos os formatos, pois atuam na camada do serde, não na camada do formato.

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
struct Config { max_connections: u32 }

Verificação rápida

Teste sua compreensão de outros formatos.

Recapitulação

Você aprendeu sobre outros formatos do serde:

Uma única estrutura derivada funciona com TOML, YAML, JSON e bincode
Cada pacote de formato oferece APIs familiares no estilo de to_string / from_str
Escolha de acordo com o público: configuração, API ou armazenamento binário
Os atributos do serde se aplicam a todos os formatos

Com isso, o curso de Serde e a série de Rust estão concluídos.

Perguntas Frequentes

A aula “Outros formatos” é grátis?

Sim — o texto completo de “Outros formatos” é 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 “Outros formatos”?

TOML, YAML, bincode 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 4 de 4.

Quanto tempo leva a aula “Outros formatos”?

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