Learn Rust Coding · Aula

Enums com dados

Associe valores às variantes.

Enums com dados é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 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.

Variantes podem conter dados

Até agora, nossas variantes eram apenas nomes. No Rust, uma variante também pode conter dados dentro de parênteses.

Isso permite que uma única enumeração descreva tanto o tipo de valor quanto o próprio valor.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Uma variante com um valor

Coloque um tipo entre parênteses para anexar um dado a uma variante.

Aqui, Celsius(f64) significa que a variante Celsius contém um número f64. Você fornece esse número ao criar o valor.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(21.5);
    println!("Created a temperature");
}

Variantes com vários valores

Uma variante pode conter vários valores, separados por vírgulas.

Move(i32, i32) armazena dois números inteiros, talvez uma coordenada x e uma coordenada y. Você passa ambos ao criá-la.

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

fn main() {
    let r = Shape::Rectangle(3.0, 4.0);
    println!("Made a rectangle");
}

Extraindo dados com match

Para ler os dados dentro de uma variante, dê-lhes um nome no padrão. Os nomes se tornam variáveis que você pode usar nesse braço.

Aqui, Shape::Circle(r) associa o raio armazenado a r.

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

fn main() {
    let s = Shape::Circle(2.0);
    match s {
        Shape::Circle(r) => println!("radius {}", r),
        Shape::Rectangle(w, h) => println!("{} x {}", w, h),
    }
}

Usando os valores associados

Depois que os dados são associados a um nome, você pode fazer cálculos com eles como faria com qualquer variável.

Este programa usa uma correspondência com uma forma e calcula sua área, retornando o resultado de match.

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

fn main() {
    let s = Shape::Rectangle(3.0, 4.0);
    let area = match s {
        Shape::Circle(r) => 3.14 * r * r,
        Shape::Rectangle(w, h) => w * h,
    };
    println!("area = {}", area);
}

Dados diferentes por variante

Cada variante pode conter uma estrutura de dados diferente, e algumas podem não conter dado algum.

Essa flexibilidade é o que torna as enumerações tão expressivas: um tipo representa muitos casos distintos.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Variantes semelhantes a estruturas

Uma variante pode usar campos nomeados com chaves, assim como uma estrutura. Isso torna claro o significado de cada campo.

Você a cria nomeando cada campo e faz a correspondência da mesma maneira.

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
}

fn main() {
    let e = Event::Click { x: 10, y: 20 };
    match e {
        Event::Click { x, y } => println!("click at {},{}", x, y),
        Event::KeyPress(c) => println!("key {}", c),
    }
}

Cadeias de caracteres em variantes

As variantes podem conter dados próprios, como um String. A correspondência dá acesso ao texto.

Observação: fazer a correspondência por valor move os dados para fora, o que funciona aqui porque os usamos imediatamente.

enum Message {
    Write(String),
    Quit,
}

fn main() {
    let m = Message::Write(String::from("hello"));
    match m {
        Message::Write(text) => println!("text: {}", text),
        Message::Quit => println!("bye"),
    }
}

A enumeração Option padrão

O Option<T> integrado ao Rust é uma enumeração com dados: Some(T) contém um valor e None não contém nada.

É assim que o Rust representa "talvez um valor" sem usar nulo. Você faz a correspondência com ele da mesma forma que com suas próprias enumerações.

fn main() {
    let maybe: Option<i32> = Some(5);
    match maybe {
        Some(n) => println!("got {}", n),
        None => println!("nothing"),
    }
}

Juntando tudo

Este programa completo representa temperaturas e depois converte uma leitura Celsius para Fahrenheit dentro de um match.

Tente mudar a variante ou seu valor e executá-lo novamente.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(25.0);
    let f = match t {
        Temperature::Celsius(c) => c * 9.0 / 5.0 + 32.0,
        Temperature::Fahrenheit(f) => f,
    };
    println!("{} F", f);
}

Quando usar variantes com dados

Escolha variantes que carregam dados quando cada caso naturalmente vier acompanhado de informações adicionais.

Um Circle precisa de um raio.
Uma mensagem Write precisa de seu texto.
Um Move precisa de coordenadas.

Agrupar os dados com a variante mantém as informações relacionadas juntas e com segurança de tipos.

Verificação rápida

Verifique sua compreensão das enumerações que contêm dados.

Recapitulação

Você aprendeu que as variantes de uma enumeração podem conter dados: um único valor, vários valores, campos nomeados semelhantes aos de uma estrutura ou nenhum dado.

Você lê esses dados nomeando-os em um padrão de match, como Circle(r). O tipo padrão Option funciona da mesma maneira. Em seguida, você aprimorará as correspondências com guardas e associações.

Perguntas Frequentes

A aula “Enums com dados” é grátis?

Sim — o texto completo de “Enums com dados” é 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 “Enums com dados”?

Associe valores às variantes. 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 3 de 4.

Quanto tempo leva a aula “Enums com dados”?

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