Learn Rust Coding · Aula

Trabalho com JSON

serde_json

Trabalho com JSON é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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 crate serde_json

serde_json é a implementação do formato JSON para serde. Ele fornece funções para converter entre valores Rust e texto JSON.

to_string / from_str para texto
Value para JSON dinâmico

Estrutura para uma string JSON

serde_json::to_string serializa qualquer valor Serialize em uma string JSON.

use serde::Serialize;

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

fn main() {
    let u = User { id: 1, name: "Alice".to_string() };
    let json = serde_json::to_string(&u).unwrap();
    println!("{}", json);
}

String JSON para estrutura

serde_json::from_str analisa JSON e o transforma em um valor tipado, retornando um Result para que você possa lidar com entradas malformadas.

use serde::Deserialize;

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

fn main() {
    let data = r#"{"id":1,"name":"Alice"}"#;
    let u: User = serde_json::from_str(data).unwrap();
    println!("{:?}", u);
}

Impressão formatada

Use to_string_pretty para obter JSON indentado e legível, útil para arquivos de configuração e depuração.

use serde::Serialize;

#[derive(Serialize)]
struct Cfg { debug: bool, level: u8 }

fn main() {
    let c = Cfg { debug: true, level: 3 };
    println!("{}", serde_json::to_string_pretty(&c).unwrap());
}

A macro json!

Crie JSON diretamente no código com a macro json!, que produz um Value sem definir uma estrutura.

use serde_json::json;

fn main() {
    let v = json!({
        "name": "Alice",
        "roles": ["admin", "user"]
    });
    println!("{}", v);
}

O tipo Value

serde_json::Value é um enumerador que representa qualquer nó JSON: nulo, booleano, número, string, matriz ou objeto. Use-o quando o formato for desconhecido.

use serde_json::Value;

fn main() {
    let data = r#"{"name":"Bob","age":30}"#;
    let v: Value = serde_json::from_str(data).unwrap();
    println!("{}", v["name"]);
    println!("{}", v["age"]);
}

Lendo com segurança a partir de Value

O acesso por índice retorna um Value; use métodos de acesso como as_str ou as_i64, que retornam Option, para ler dados tipados com segurança.

use serde_json::Value;

fn name_of(v: &Value) -> Option<&str> {
    v.get("name")?.as_str()
}

Modelando o acesso a JSON em Rust puro

Ler um valor por chave, usando uma alternativa quando ele estiver ausente, reproduz a forma como você consulta um objeto Value. Aqui, isso é feito com um HashMap.

use std::collections::HashMap;

fn main() {
    let mut obj: HashMap<&str, &str> = HashMap::new();
    obj.insert("name", "Alice");
    let name = obj.get("name").copied().unwrap_or("unknown");
    let city = obj.get("city").copied().unwrap_or("unknown");
    println!("name={} city={}", name, city);
}

Bytes e escritores

Para obter desempenho, to_vec serializa em bytes, enquanto to_writer transmite diretamente para qualquer io::Write, como um arquivo ou soquete.

use serde::Serialize;

#[derive(Serialize)]
struct Msg { text: String }

fn to_bytes(m: &Msg) -> Vec<u8> {
    serde_json::to_vec(m).unwrap()
}

Lidando com erros de análise

from_str retorna Result. Faça a correspondência do erro para fornecer uma mensagem útil ao usuário, em vez de causar uma falha.

use serde::Deserialize;

#[derive(Deserialize)]
struct User { id: u32 }

fn parse(s: &str) -> String {
    match serde_json::from_str::<User>(s) {
        Ok(u) => format!("id {}", u.id),
        Err(e) => format!("invalid JSON: {}", e),
    }
}

Convertendo entre Value e estruturas

serde_json::from_value e to_value convertem entre uma estrutura tipada e o Value dinâmico quando você precisa dos dois.

use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize)]
struct User { name: String }

fn main() {
    let v = json!({"name": "Eve"});
    let u: User = serde_json::from_value(v).unwrap();
    println!("{}", u.name);
}

Verificação rápida

Teste sua compreensão do trabalho com JSON.

Recapitulação

Você aprendeu a lidar com JSON usando serde_json:

to_string / from_str convertem estruturas e texto JSON
to_string_pretty formata o conteúdo de modo legível
A macro json! e Value lidam com JSON dinâmico
Use métodos de acesso e Result para ler e analisar dados com segurança

A seguir: personalizando a serialização com atributos de campo.

Perguntas Frequentes

A aula “Trabalho com JSON” é grátis?

Sim — o texto completo de “Trabalho com JSON” é 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 “Trabalho com JSON”?

serde_json 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 2 de 4.

Quanto tempo leva a aula “Trabalho com JSON”?

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