Learn Rust Coding · Aula

Análise aprofundada de match

Padrões e guardas

Análise aprofundada de match é 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.

A expressão match

match compara um valor com uma série de padrões e executa o braço da primeira correspondência. Como é uma expressão, ela retorna um valor.

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

Exaustividade

Um match deve abranger todos os valores possíveis. O curinga _ captura qualquer valor que não tenha correspondido aos braços anteriores, garantindo a exaustividade.

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

Correspondendo vários valores

Use | para corresponder a vários padrões em um único braço.

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

Padrões de intervalo

Faça a correspondência de um intervalo de valores com ..= (inclusivo). Isso é ótimo para agrupar números ou caracteres.

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

Guardas de correspondência

Uma guarda é uma condição if adicional em um braço. O braço só corresponde quando o padrão se encaixa e a guarda é verdadeira.

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

Vinculação em padrões

Os padrões podem vincular partes correspondentes a variáveis para uso no corpo do braço.

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

Correspondendo enumerações

match é especialmente útil com enumerações, principalmente quando as variantes carregam dados.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

Ignorando com _ e ..

Use _ para ignorar um único valor e .. para ignorar o restante de uma tupla ou estrutura.

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

Retornando de match

Como match é uma expressão, você pode atribuir seu resultado ou retorná-lo diretamente. Cada braço deve produzir o mesmo tipo.

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

A ordem dos braços importa

Os braços são verificados de cima para baixo; o primeiro que corresponder vence. Coloque os padrões específicos antes dos gerais e deixe o curinga por último.

Vinculando intervalos com @

Combine um intervalo com o operador @ para testar um valor e manter seu conteúdo exato no mesmo braço.

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

Verificação rápida

Qual é a finalidade de uma guarda de correspondência como (x, y) if x > y?

Recapitulação

Você se aprofundou em match:

É uma expressão exaustiva que retorna um valor
| corresponde a vários padrões; ..= corresponde a intervalos
As guardas adicionam condições if extras
Os padrões vinculam dados; _ e .. ignoram partes
A ordem dos braços importa — a primeira correspondência vence

Perguntas Frequentes

A aula “Análise aprofundada de match” é grátis?

Sim — o texto completo de “Análise aprofundada de match” é 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 “Análise aprofundada de match”?

Padrões e guardas 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 “Análise aprofundada de match”?

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