Définir votre premier énuméré
Créez des types énumérés simples.
Définir votre premier énuméré est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
What Is an Enum?
Une énumération (enum) vous permet de définir un type en listant ses valeurs possibles, appelées variantes. Une valeur de ce type ne peut être que l'une de ces variantes.
Les énumérations sont particulièrement utiles lorsqu'une entité possède un ensemble fixe d'états, comme les points cardinaux ou les enseignes d'un jeu de cartes.
enum Direction {
North,
South,
East,
West,
}Declaring an Enum
You declare an enum with the enum keyword, a name, and a comma-separated list of variants inside curly braces.
By convention enum names use PascalCase (like Direction), and so do the variant names (like North).
enum TrafficLight {
Red,
Yellow,
Green,
}Creating an Enum Value
To build a value you write the enum name, two colons ::, then the variant.
For example, Direction::North creates a value of type Direction. The :: tells Rust which enum the variant belongs to.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let heading = Direction::East;
println!("Created a direction value!");
}Enums Are Types
Once defined, an enum is a real type just like i32 or bool. You can store its values in variables and pass them to functions.
A function that takes a Direction will accept any of its variants, but nothing else.
enum Direction {
North,
South,
}
fn describe(d: Direction) {
println!("Got a direction");
}
fn main() {
describe(Direction::North);
}Why Not Just Use Numbers?
You could represent a traffic light with 0, 1, and 2, but nothing stops you from accidentally using 7.
An enum makes invalid states impossible: the compiler guarantees the value is always one of the listed variants. This is safer and far easier to read.
Deriving Debug to Print
By default Rust does not know how to print an enum. Adding #[derive(Debug)] above the enum lets you print it with the {:?} formatter.
This is great for quick debugging while you learn.
#[derive(Debug)]
enum Direction {
North,
South,
}
fn main() {
let d = Direction::South;
println!("{:?}", d);
}Comparing Enum Values
Add #[derive(PartialEq)] so you can compare variants with ==.
This is handy for simple checks, though for richer behavior the match expression (coming soon) is usually the better tool.
#[derive(PartialEq)]
enum Light {
Red,
Green,
}
fn main() {
let l = Light::Red;
if l == Light::Red {
println!("Stop!");
}
}Many Variants Allowed
An enum can have as many variants as you need. They are all part of the same type.
Listing related states together keeps your code organized and makes the possible options obvious at a glance.
enum Suit {
Hearts,
Diamonds,
Clubs,
Spades,
}Enums in the Standard Library
Rust's own standard library uses enums everywhere. Two famous ones are Option (a value that may be present or absent) and Result (success or error).
Learning enums now prepares you to understand these core types later.
// Option is an enum in std:
// enum Option<T> {
// Some(T),
// None,
// }Copying Simple Enums
Enums whose variants hold no data can derive Clone and Copy. Then values are copied automatically instead of moved.
This makes small state enums behave like simple values such as integers.
#[derive(Clone, Copy)]
enum Coin {
Heads,
Tails,
}
fn main() {
let a = Coin::Heads;
let b = a; // a is still usable
}Putting It Together
Here is a complete program: define an enum, create a value, and print it using Debug.
Run it and try changing Green to another variant to see the output update.
#[derive(Debug)]
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let current = TrafficLight::Green;
println!("Light is {:?}", current);
}Quick Check
Test your understanding of enum basics.
Recap
You learned that an enum defines a type from a fixed list of variants, declared with the enum keyword.
You create values with EnumName::Variant, and you can derive Debug, PartialEq, or Copy to print, compare, and copy them. Next you will learn to react to each variant with match.
Questions Fréquemment Posées
La leçon « Définir votre premier énuméré » est-elle gratuite ?
Oui — le texte complet de « Définir votre premier énuméré » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Définir votre premier énuméré » ?
Créez des types énumérés simples. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Définir votre premier énuméré » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Définir votre premier énuméré
- Faire correspondre les variantes d’un énuméré
- Énumérés avec données
- Gardes et liaisons de correspondance