Learn Rust Coding · Aula

Result e o operador ?

Propague erros

Result e o operador ? é 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 tipo Result

Result<T, E> representa uma operação que pode ser bem-sucedida com Ok(T) ou falhar com Err(E). É o principal tipo de tratamento de erros do Rust.

fn main() {
    let parsed: Result<i32, _> = "42".parse::<i32>();
    println!("{:?}", parsed);
}

Fazendo correspondência em Result

Você pode tratar explicitamente os dois resultados com match.

fn main() {
    match "oops".parse::<i32>() {
        Ok(n) => println!("got {n}"),
        Err(e) => println!("error: {e}"),
    }
}

Retornando Result

Funções que podem falhar retornam um Result, permitindo que quem as chama decida como tratar os erros.

fn halve(n: i32) -> Result<i32, String> {
    if n % 2 == 0 {
        Ok(n / 2)
    } else {
        Err("odd number".to_string())
    }
}

fn main() {
    println!("{:?}", halve(10));
    println!("{:?}", halve(7));
}

O operador ?

O operador ? desembrulha um valor Ok ou retorna Err antecipadamente da função. Ele substitui um código extenso de correspondência e retorno.

fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    println!("{:?}", double_str("21"));
    println!("{:?}", double_str("x"));
}

Encadeando com ?

Várias etapas sujeitas a falha ficam claras quando encadeadas com ?; o primeiro erro interrompe o restante.

fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
    let x = a.parse::<i32>()?;
    let y = b.parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_two("3", "4"));
}

? em main

main pode retornar Result, portanto ? também funciona nela. Um Err retornado encerra o programa com um código de saída diferente de zero.

fn main() -> Result<(), std::num::ParseIntError> {
    let n: i32 = "100".parse()?;
    println!("parsed {n}");
    Ok(())
}

Métodos úteis de Result

Combinadores úteis:

unwrap_or(default) — valor ou uma alternativa
map — transforma o valor Ok
map_err — transforma o erro
is_ok / is_err — verifica a variante

fn main() {
    let n = "x".parse::<i32>().unwrap_or(-1);
    println!("{n}");
}

De Option para Result

Converta um Option em um Result com ok_or para que ? possa propagar um erro significativo.

fn first_char(s: &str) -> Result<char, String> {
    let c = s.chars().next().ok_or("empty string".to_string())?;
    Ok(c)
}

fn main() {
    println!("{:?}", first_char("hi"));
    println!("{:?}", first_char(""));
}

Como ? converte erros

Quando os tipos de erro são diferentes, ? chama From::from para converter o erro no tipo de erro declarado pela função. Isso permite um tratamento de erros prático entre camadas.

Evite unwrap em produção

unwrap e expect entram em pânico com Err. Eles são adequados para exemplos e testes, mas prefira ? ou um tratamento explícito no código real para manter as falhas recuperáveis.

Encadeando and_then

and_then executa a próxima etapa sujeita a falha somente se a anterior tiver sido bem-sucedida, encadeando o valor.

fn main() {
    let result = "8"
        .parse::<i32>()
        .and_then(|n| Ok(n * 2));
    println!("{:?}", result);
}

Verificação rápida

O que o operador ? faz quando aplicado a um Result que é Err?

Recapitulação

Você aprendeu o tratamento de erros baseado em Result:

Result<T, E> representa sucesso ou falha
? desembrulha Ok ou retorna Err antecipadamente
? funciona em funções e em main que retornam Result
Combinadores como map, map_err, unwrap_or e ok_or ajudam
Evite unwrap em produção

Perguntas Frequentes

A aula “Result e o operador ?” é grátis?

Sim — o texto completo de “Result e o operador ?” é 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 “Result e o operador ?”?

Propague erros 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 “Result e o operador ?”?

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

Result e o operador ?
thiserror
anyhow
Conversão de erros

← Voltar para Learn Rust Coding