Definindo seu primeiro enum
Crie tipos enumerados simples.
Definindo seu primeiro enum é 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 que é uma enumeração?
Um enum (enumeração) permite definir um tipo listando seus possíveis valores, chamados de variantes. Um valor desse tipo só pode ser uma dessas variantes.
As enumerações são ideais quando algo tem um conjunto fixo de estados, como os pontos cardeais ou os naipes de um baralho.
enum Direction {
North,
South,
East,
West,
}Declarando uma enumeração
Você declara uma enumeração com a palavra-chave enum, um nome e uma lista de variantes separadas por vírgulas dentro de chaves.
Por convenção, os nomes das enumerações usam PascalCase (como Direction), assim como os nomes das variantes (como North).
enum TrafficLight {
Red,
Yellow,
Green,
}Criando um valor de enumeração
Para criar um valor, escreva o nome da enumeração, dois-pontos duplos :: e, em seguida, a variante.
Por exemplo, Direction::North cria um valor do tipo Direction. O :: informa ao Rust a qual enumeração a variante pertence.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let heading = Direction::East;
println!("Created a direction value!");
}Enumerações são tipos
Depois de definida, uma enumeração é um tipo real, assim como i32 ou bool. Você pode armazenar seus valores em variáveis e passá-los para funções.
Uma função que recebe um Direction aceitará qualquer uma de suas variantes, mas nada além disso.
enum Direction {
North,
South,
}
fn describe(d: Direction) {
println!("Got a direction");
}
fn main() {
describe(Direction::North);
}Por que não usar apenas números?
Você poderia representar um semáforo com 0, 1 e 2, mas nada impediria que você usasse 7 por engano.
Uma enumeração torna os estados inválidos impossíveis: o compilador garante que o valor seja sempre uma das variantes listadas. Isso é mais seguro e muito mais fácil de ler.
Derivando Debug para imprimir
Por padrão, o Rust não sabe como imprimir uma enumeração. Adicionar #[derive(Debug)] acima da enumeração permite imprimi-la com o formatador {:?}.
Isso é ótimo para depurações rápidas enquanto você aprende.
#[derive(Debug)]
enum Direction {
North,
South,
}
fn main() {
let d = Direction::South;
println!("{:?}", d);
}Comparando valores de enumeração
Adicione #[derive(PartialEq)] para poder comparar variantes com ==.
Isso é útil para verificações simples, embora, para comportamentos mais elaborados, a expressão match (que será apresentada em breve) geralmente seja a melhor ferramenta.
#[derive(PartialEq)]
enum Light {
Red,
Green,
}
fn main() {
let l = Light::Red;
if l == Light::Red {
println!("Stop!");
}
}Muitas variantes são permitidas
Uma enumeração pode ter quantas variantes forem necessárias. Todas fazem parte do mesmo tipo.
Listar estados relacionados em conjunto mantém seu código organizado e torna as opções possíveis evidentes de imediato.
enum Suit {
Hearts,
Diamonds,
Clubs,
Spades,
}Enumerações na biblioteca padrão
A própria biblioteca padrão do Rust usa enumerações em toda parte. Duas famosas são Option (um valor que pode estar presente ou ausente) e Result (sucesso ou erro).
Aprender enumerações agora prepara você para entender esses tipos fundamentais mais tarde.
// Option is an enum in std:
// enum Option<T> {
// Some(T),
// None,
// }Copiando enumerações simples
Enumerações cujas variantes não contêm dados podem derivar Clone e Copy. Assim, os valores são copiados automaticamente em vez de serem movidos.
Isso faz com que pequenas enumerações de estado se comportem como valores simples, como números inteiros.
#[derive(Clone, Copy)]
enum Coin {
Heads,
Tails,
}
fn main() {
let a = Coin::Heads;
let b = a; // a is still usable
}Juntando tudo
Aqui está um programa completo: defina uma enumeração, crie um valor e imprima-o usando Debug.
Execute-o e tente mudar Green para outra variante para ver a saída ser atualizada.
#[derive(Debug)]
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let current = TrafficLight::Green;
println!("Light is {:?}", current);
}Verificação rápida
Teste sua compreensão dos fundamentos das enumerações.
Recapitulação
Você aprendeu que uma enum define um tipo a partir de uma lista fixa de variantes, declarada com a palavra-chave enum.
Você cria valores com EnumName::Variant e pode derivar Debug, PartialEq ou Copy para imprimi-los, compará-los e copiá-los. Em seguida, você aprenderá a reagir a cada variante com match.
Perguntas Frequentes
A aula “Definindo seu primeiro enum” é grátis?
Sim — o texto completo de “Definindo seu primeiro 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 “Definindo seu primeiro enum”?
Crie tipos enumerados simples. 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 “Definindo seu primeiro 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