Associando variantes de enum
Use match para tratar cada caso.
Associando variantes de enum é 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.
Conheça a expressão match
A expressão match compara um valor com uma série de padrões e executa o código do primeiro padrão compatível.
Ela é a parceira natural das enumerações: você pode tratar cada variante em seu próprio braço.
enum Light {
Red,
Green,
}
fn action(l: Light) {
match l {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}
}Anatomia de um braço de match
Cada braço tem a forma pattern => expression, e os braços são separados por vírgulas.
O padrão é aquilo que deve ser correspondido, e a expressão após => é executada quando há correspondência. Aqui, o padrão é uma única variante de enumeração.
match light {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}Um programa completo com match
Aqui está um programa completo que usa match com um semáforo e imprime uma instrução.
Execute-o e depois mude a variante em main para observar um braço diferente ser executado.
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let light = TrafficLight::Yellow;
match light {
TrafficLight::Red => println!("Stop"),
TrafficLight::Yellow => println!("Slow down"),
TrafficLight::Green => println!("Go"),
}
}match precisa ser exaustivo
O Rust exige que match cubra todas as variantes possíveis. Se você esquecer uma, o programa não será compilado.
Esse é um recurso poderoso de segurança: se você adicionar uma nova variante mais tarde, o compilador lembrará você de todos os lugares que precisam tratá-la.
// This would FAIL to compile because
// the Green case is missing:
// match light {
// Light::Red => println!("Stop"),
// }O padrão abrangente com _
Quando você não quiser listar todas as variantes, use o sublinhado _ como padrão abrangente. Ele corresponde a qualquer coisa que não tenha sido tratada acima.
Coloque-o por último, pois os braços são testados em ordem.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Dime;
match c {
Coin::Penny => println!("1 cent"),
_ => println!("Some other coin"),
}
}match retorna um valor
match é uma expressão, portanto produz um valor que você pode armazenar em uma variável.
Todo braço deve retornar o mesmo tipo. Observe que não há ponto e vírgula após a expressão de cada braço aqui.
enum Coin {
Penny,
Quarter,
}
fn main() {
let coin = Coin::Quarter;
let cents = match coin {
Coin::Penny => 1,
Coin::Quarter => 25,
};
println!("{} cents", cents);
}Corpos de braços em várias linhas
Um braço pode executar várias instruções quando você as envolve em chaves { ... }.
A última expressão dentro das chaves é o valor produzido pelo braço.
match light {
Light::Red => {
println!("Caution!");
println!("Stop the car");
}
Light::Green => println!("Go"),
}Combinando padrões com |
Use a barra vertical | para corresponder a várias variantes em um único braço. Ela significa "ou".
Isso evita repetir o mesmo corpo para variantes que devem se comportar de forma idêntica.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Nickel;
match c {
Coin::Penny | Coin::Nickel => println!("Small coin"),
_ => println!("Bigger coin"),
}
}match versus if/else
Você poderia encadear if / else if para verificar variantes, mas match é mais claro e seguro.
Com match, o compilador verifica se você tratou todos os casos. Uma cadeia de instruções if não oferece essa garantia.
Correspondendo e imprimindo em conjunto
Um padrão comum é transformar uma variante em uma cadeia de caracteres amigável e imprimi-la.
Execute este programa e mude a direção escolhida para ver a mensagem correspondente.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let d = Direction::West;
let name = match d {
Direction::North => "North",
Direction::South => "South",
Direction::East => "East",
Direction::West => "West",
};
println!("Heading {}", name);
}A ordem é importante
Os braços são verificados de cima para baixo, e a primeira correspondência vence. Os demais são ignorados.
É por isso que o padrão abrangente _ deve vir por último: se viesse primeiro, absorveria todos os valores antes que os braços específicos pudessem ser executados.
Verificação rápida
Verifique sua compreensão de match.
Recapitulação
Você aprendeu que match compara um valor com padrões e executa o primeiro braço correspondente.
Ele precisa ser exaustivo, pode usar _ como padrão abrangente, pode combinar variantes com | e retorna um valor porque é uma expressão. Em seguida, você dará dados próprios às variantes de enumeração.
Perguntas Frequentes
A aula “Associando variantes de enum” é grátis?
Sim — o texto completo de “Associando variantes de enum” é 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 “Associando variantes de enum”?
Use match para tratar cada caso. 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 “Associando variantes de enum”?
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