Usando 'match' com 'Result'

Parte da seção Lógica & Fluxo do Journey de Rust da Coddy. Lição 43 de 66.

Agora que você entende o que é um Result, vamos aprender a maneira mais explícita e poderosa de lidar com casos de sucesso e falha: usando uma expressão match.

Assim como com Option, match força você a lidar com ambas as variantes de um Result. Você cria um braço para Ok para lidar com o sucesso, e outro braço para Err para lidar com a falha:

let result = divide(10, 2);

match result {
    Ok(value) => println!("Division successful: {}", value),
    Err(error) => println!("Division failed: {}", error),
}

Quando o Result é Ok, o match extrai o valor de sucesso e executa o primeiro braço. Quando é Err, ele extrai a informação de erro e executa o segundo braço. Este padrão garante que você nunca ignore acidentalmente um erro potencial.

Desafio

Fácil

Você receberá duas entradas. A primeira entrada é um número (como uma string), e a segunda entrada é outro número (como uma string). Crie uma função que tente dividir o primeiro número pelo segundo número e retorne um Result<f64, &'static str>. Se o segundo número for zero, retorne um Err com a mensagem "Division by zero". Caso contrário, retorne Ok com o resultado da divisão. Use uma expressão match para lidar com os casos Ok e Err e imprima a mensagem apropriada.

Requisitos:

Leia a primeira entrada (dividendo) e remova os espaços em branco
Converta a primeira entrada para f64
Leia a segunda entrada (divisor) e remova os espaços em branco
Converta a segunda entrada para f64
Crie uma função que aceite dois parâmetros f64 e retorne Result<f64, &'static str>
Dentro da função, verifique se o divisor é 0.0:
- Se sim, retorne Err("Division by zero")
- Se não, retorne Ok(dividend / divisor)
Chame a função com os dois números convertidos
Use uma expressão match para lidar com o Result
No ramo Ok(value), imprima: Result: [value]
No ramo Err(error), imprima: Error: [error]

Entrada:

Primeira linha: um número que representa o dividendo (por exemplo, 10.0)
Segunda linha: um número que representa o divisor (por exemplo, 2.0)

Saída:

Se a divisão for bem-sucedida: Result: [result]
Se houver divisão por zero: Error: Division by zero

Experimente você mesmo

use std::io;

// TODO: Crie sua função divide aqui que retorna Result<f64, &'static str>


fn main() {
    // Lê a primeira entrada (dividendo)
    let mut dividend_input = String::new();
    io::stdin().read_line(&mut dividend_input).expect("Failed to read line");
    let dividend: f64 = dividend_input.trim().parse().expect("Invalid number");
    
    // Lê a segunda entrada (divisor)
    let mut divisor_input = String::new();
    io::stdin().read_line(&mut divisor_input).expect("Failed to read line");
    let divisor: f64 = divisor_input.trim().parse().expect("Invalid number");
    
    // TODO: Chame sua função divide e use match para tratar o Result
    // Imprima "Result: [value]" para o caso Ok
    // Imprima "Error: [error]" para o caso Err
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Lógica & Fluxo

3Lista de Tarefas via Linha de Comando

Configuração do Projeto Adicionando uma Tarefa Visualizando Todas as Tarefas Removendo uma Tarefa Código Final

6Lidando com a Ausência com 'Option'

O que é um 'Option'?Usando 'match' com 'Option'is_some() e is_none()Fazendo o unwrap de um 'Option'O método expect Fornecendo um valor padrão: unwrap_or Recapitulação - Encontrar um Elemento

9Slices de String e Mais

String vs. &str Criando Slices de String Slices como Parâmetros de Função Outros Slices Recapitulação - Encontrar a Primeira Palavra

Pratique por conta própria: Compilador de Rust online