Learn Rust Coding · Lección

Enums para tipos personalizados

Utilice enums para definir tipos que puedan ser una de varias variantes, a menudo con datos asociados.

Enums para tipos personalizados es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 de 3. 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 3 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Enums: Custom Type Choices

Welcome to Enums for Custom Types! In Rust, enums (enumerations) let you define a type that can be one of several possible, distinct variants.

Think of an enum as a way to say, "This item can be A, OR B, OR C." It's incredibly useful for representing different states or choices.

Defining a Simple Enum

To define an enum, you use the enum keyword followed by its name and curly braces containing its variants. Each variant is a distinct choice.

Here's a simple example for cardinal directions:

enum Direction {
  North,
  South,
  East,
  West,
}

fn main() {
  let my_direction = Direction::North;
  println!("My direction is {:?}", my_direction);
}

Enums with Associated Data

Unlike simple variants, enum variants can also hold data! This makes enums very powerful, as each variant can carry its own distinct set of information.

The data can be a tuple (like (i32, String)) or a struct (like { x: i32, y: i32 }).

Associated Data in Action

Let's see an enum where each variant represents a different type of message, some carrying data and some not.

Notice how Move uses a struct, Write uses a String, and ChangeColor uses a tuple.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn main() {
  let m1 = Message::Quit;
  let m2 = Message::Move { x: 10, y: 20 };
  let m3 = Message::Write(String::from("hello"));
  let m4 = Message::ChangeColor(255, 0, 128);

  // We can't directly print enums with associated data using {:?}
  // without deriving Debug, which we'll cover later.
  // For now, just know these instances are created.
  println!("Messages created!");
}

The `Option` Enum: Handling Absence

One of Rust's most fundamental enums is Option<T>. It's used to represent values that might or might not exist, preventing null pointer errors common in other languages.

Some(T): The variant that holds a value of type T.
None: The variant that represents no value.

Using `Option<T>` Effectively

Option<T> forces you to explicitly handle both the Some and None cases, making your code safer and more robust. No more unexpected null crashes!

Here's how you might use it:

fn find_item(id: i32) -> Option<String> {
  if id == 7 {
    Some(String::from("Found item 7!"))
  } else {
    None
  }
}

fn main() {
  let item1 = find_item(7);
  let item2 = find_item(5);

  println!("Item 1: {:?}", item1);
  println!("Item 2: {:?}", item2);
}

Briefly: The `Result` Enum

Another vital enum is Result<T, E>, used for error handling. It has two variants:

Ok(T): Indicates success and contains the successful value.
Err(E): Indicates failure and contains an error value.

We'll dive deep into Result in a later lesson, but it's good to know it's another powerful enum pattern!

Methods on Enums

Just like structs, you can define methods for enums using an impl block. These methods can perform actions or return values based on the enum's variant.

Let's add a call method to our Message enum from before:

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

impl Message {
  fn call(&self) {
    println!("A message was called!");
  }
}

fn main() {
  let m = Message::Write(String::from("hello"));
  m.call();
}

Quick Check on Enums

Which of the following statements are true about Rust enums?

Recap: Enums for Custom Types

Great job! You've learned how Rust enums provide a powerful way to define custom types that can be one of several variants.

Enums allow you to model choices and states clearly.
Variants can carry associated data, making them highly flexible.
The Option<T> enum is key for handling the absence of a value safely.
Enums can have methods defined with impl blocks.

Next, we'll explore how to work with these enum variants using powerful pattern matching!

Preguntas frecuentes

¿La lección «Enums para tipos personalizados» es gratis?

Sí — el texto completo de «Enums para tipos personalizados» 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 3 lecciones en total.

¿Qué aprenderé en «Enums para tipos personalizados»?

Utilice enums para definir tipos que puedan ser una de varias variantes, a menudo con datos asociados. 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 2 de 3.

¿Cuánto tiempo toma la lección «Enums para tipos personalizados»?

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