Learn Rust Coding · Lección

Enums con datos

Asocie valores a las variantes

Lección 3 de 413 pasos

Enums con datos es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Las variantes pueden contener datos

Hasta ahora, nuestras variantes eran solo nombres. En Rust, una variante también puede contener datos entre paréntesis.

Esto permite que un solo enum describa tanto el tipo de valor como el valor en sí.

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

Una variante con un valor

Coloque un tipo entre paréntesis para asociar un dato a una variante.

Aquí, Celsius(f64) indica que la variante Celsius contiene un número f64. Debe proporcionar ese número al crear el valor.

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

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

Variantes con varios valores

Una variante puede contener varios valores, separados por comas.

Move(i32, i32) almacena dos enteros, quizá una coordenada x y otra y. Debe proporcionar ambos al crearla.

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

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

Extraer datos con match

Para leer los datos contenidos en una variante, asígneles un nombre en el patrón. Esos nombres se convierten en variables que puede usar en ese brazo.

Aquí, Shape::Circle(r) vincula el radio almacenado con 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),
    }
}

Usar los valores vinculados

Una vez que los datos están vinculados a un nombre, puede operar con ellos como con cualquier variable.

Este programa aplica matching a una figura y calcula su área, devolviendo el 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);
}

Datos diferentes en cada variante

Cada variante puede contener una estructura de datos diferente, y algunas pueden no contener ninguna.

Esta flexibilidad es lo que hace que los enums sean tan expresivos: un solo tipo puede modelar muchos casos distintos.

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

Variantes similares a structs

Una variante puede usar campos con nombre entre llaves, igual que una struct. Esto aclara el significado de cada campo.

Se crea indicando el nombre de cada campo y se aplica matching de la misma forma.

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),
    }
}

Cadenas en las variantes

Las variantes pueden contener datos propios, como un String. El matching le permite acceder al texto.

Nota: hacer matching por valor mueve los datos fuera de la variante, lo cual está bien aquí porque los usamos inmediatamente.

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"),
    }
}

El enum Option estándar

El Option<T> integrado en Rust es un enum con datos: Some(T) contiene un valor y None no contiene nada.

Es la forma en que Rust representa «quizá haya un valor» sin usar null. Se aplica matching igual que con sus propios enums.

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

Cómo integrarlo todo

Este programa completo modela temperaturas y después convierte una lectura en Celsius a Fahrenheit dentro de un match.

Pruebe a cambiar la variante o su valor y vuelva a ejecutarlo.

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);
}

Cuándo usar variantes con datos

Use variantes con datos cuando cada caso incluya naturalmente información adicional.

Un Circle necesita un radio.
Un mensaje Write necesita su texto.
Un Move necesita coordenadas.

Agrupar los datos con la variante mantiene la información relacionada unida y con seguridad de tipos.

Comprobación rápida

Compruebe su comprensión de los enums que contienen datos.

Responde en la lección interactiva

Resumen

Ha aprendido que las variantes de un enum pueden contener datos: un solo valor, varios valores, campos con nombre similares a los de una struct o ningún valor.

Puede leer esos datos indicando su nombre en un patrón de match, como Circle(r). El tipo estándar Option funciona de la misma forma. A continuación, aprenderá a perfeccionar los matchers con guardas y bindings.

Gratis para empezar

Aprende Rust con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 39
Lecciones: 144

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Enums con datos» es gratis?

Sí — el texto completo de «Enums con datos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Enums con datos»?

Asocie valores a las variantes Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Enums con datos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding