Guardas e vinculações de match
Adicione condições e capture valores.
Guardas e vinculações de match é 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.
O que é uma guarda de match?
Uma guarda de match é uma condição adicional if adicionada a um braço de correspondência. O braço só é executado quando o padrão corresponde e a condição é verdadeira.
Ela permite dividir uma variante em casos mais específicos com base em seus dados.
match number {
Some(n) if n > 0 => println!("positive"),
Some(n) => println!("zero or negative"),
None => println!("no number"),
}Sintaxe das guardas
Escreva o padrão, depois if condition e, em seguida, =>. A condição pode usar qualquer variável associada pelo padrão.
Se a guarda for falsa, o Rust continua e tenta o próximo braço.
fn main() {
let n = 4;
match n {
x if x % 2 == 0 => println!("even"),
_ => println!("odd"),
}
}Guardas com dados de enumerações
As guardas são mais úteis com enumerações que contêm dados. Você associa o valor interno e depois o testa.
Aqui, um saldo positivo e um saldo negativo recebem mensagens diferentes, embora ambos sejam a mesma variante.
enum Account {
Balance(i32),
Closed,
}
fn main() {
let a = Account::Balance(-5);
match a {
Account::Balance(b) if b < 0 => println!("overdrawn"),
Account::Balance(b) => println!("balance {}", b),
Account::Closed => println!("closed"),
}
}A ordem continua sendo importante
Como os braços são testados de cima para baixo, coloque o braço protegido mais específico antes do geral.
Se o braço simples Balance(b) viesse primeiro, ele corresponderia a tudo e o braço protegido nunca seria executado.
Correspondendo a valores literais
Você também pode corresponder diretamente a literais específicos no padrão, sem uma guarda.
Aqui, 0 e 1 são correspondidos exatamente, e _ trata o restante.
fn main() {
let n = 1;
match n {
0 => println!("zero"),
1 => println!("one"),
_ => println!("many"),
}
}Correspondendo a intervalos
Os padrões podem corresponder a um intervalo de valores com ..=, que inclui ambas as extremidades.
Esta é uma alternativa clara a várias guardas de comparação.
fn main() {
let score = 85;
match score {
0..=59 => println!("fail"),
60..=100 => println!("pass"),
_ => println!("out of range"),
}
}Associando com o operador @
O operador @ permite testar um valor em relação a um padrão e associá-lo a um nome ao mesmo tempo.
Aqui, id @ 1..=5 verifica o intervalo e armazena o valor real em id para que você possa imprimi-lo.
fn main() {
let n = 3;
match n {
id @ 1..=5 => println!("small id {}", id),
other => println!("other {}", other),
}
}Associando o valor inteiro
Um nome simples em um padrão, como other acima, associa o valor inteiro. Ele funciona como um padrão abrangente que você ainda pode usar.
Use _ quando quiser ignorar o valor e um nome quando precisar dele.
fn main() {
let n = 99;
match n {
0 => println!("zero"),
value => println!("got {}", value),
}
}Guardas e associações em conjunto
Você pode combinar uma associação com uma guarda para obter um controle preciso: associe os dados e depois adicione uma condição.
Este programa sinaliza especialmente saldos pares elevados.
enum Account {
Balance(i32),
}
fn main() {
let a = Account::Balance(200);
match a {
Account::Balance(b) if b > 100 && b % 2 == 0 => println!("big even {}", b),
Account::Balance(b) => println!("normal {}", b),
}
}Guardas sobre vários padrões
Uma guarda se aplica ao braço inteiro, mesmo quando o braço combina padrões com |.
A condição é verificada depois que qualquer um dos padrões listados corresponde.
fn main() {
let n = 6;
match n {
2 | 4 | 6 if n > 3 => println!("big even"),
_ => println!("other"),
}
}Juntando tudo
Este programa final combina variantes com dados, uma vinculação, uma guarda e um caso abrangente para classificar uma leitura de temperatura.
Altere o valor e execute novamente para ver diferentes braços serem acionados.
enum Reading {
Temp(i32),
Missing,
}
fn main() {
let r = Reading::Temp(38);
match r {
Reading::Temp(t) if t >= 38 => println!("fever: {}", t),
Reading::Temp(t) => println!("normal: {}", t),
Reading::Missing => println!("no reading"),
}
}Verificação rápida
Verifique sua compreensão sobre guardas e vinculações.
Recapitulação
Você aprendeu a refinar correspondências com guardas (pattern if condition), fazer correspondência com literais e intervalos (..=) e criar vinculações com nomes ou com o operador @.
Combinando isso com tudo o que foi visto antes, agora você pode modelar conjuntos fixos de estados, associar dados a eles e reagir precisamente a cada caso. Excelente trabalho com enums e match!
Perguntas Frequentes
A aula “Guardas e vinculações de match” é grátis?
Sim — o texto completo de “Guardas e vinculações 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 “Guardas e vinculações de match”?
Adicione condições e capture valores. 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 “Guardas e vinculações 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
- Definindo seu primeiro enum
- Associando variantes de enum
- Enums com dados
- Guardas e vinculações de match