Énumérations pour les types personnalisés
Utilisez les énumérations pour définir des types pouvant prendre plusieurs variantes, souvent accompagnées de données associées.
Énumérations pour les types personnalisés est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. 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 3 leçons au total.
Énumérations : choix de types personnalisés
Bienvenue dans les énumérations pour les types personnalisés ! Dans Rust, les énumérations permettent de définir un type qui peut correspondre à l'une de plusieurs variantes distinctes.
Imaginez une énumération comme une façon de dire : « Cet élément peut être A, OR B, OR C. » Elle est extrêmement utile pour représenter différents états ou choix.
Définir une énumération simple
Pour définir une énumération, vous utilisez le mot-clé enum, suivi de son nom et d'accolades contenant ses variantes. Chaque variante représente un choix distinct.
Voici un exemple simple pour les directions cardinales :
enum Direction {
North,
South,
East,
West,
}
fn main() {
let my_direction = Direction::North;
println!("My direction is {:?}", my_direction);
}Énumérations avec données associées
Contrairement aux variantes simples, les variantes d'une énumération peuvent également contenir des données ! Cela rend les énumérations très puissantes, car chaque variante peut transporter son propre ensemble d'informations.
Les données peuvent être un tuple (comme (i32, String)) ou une structure (comme { x: i32, y: i32 }).
Les données associées en action
Examinons une énumération dont chaque variante représente un type différent de Message, certaines contenant des données et d'autres non.
Remarquez que Move utilise une structure, que Write utilise une chaîne et que ChangeColor utilise un 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!");
}L'énumération `Option` : gérer l'absence
L'une des énumérations les plus fondamentales de Rust est Option<T>. Elle sert à représenter des valeurs qui peuvent exister ou non, évitant ainsi les erreurs de pointeur nul courantes dans d'autres langages.
Some(T): la variante qui contient une valeur de typeT.None: la variante qui représente l'absence de valeur.
Utiliser `Option<T>` efficacement
Option<T> vous oblige à traiter explicitement les cas Some et None, ce qui rend votre code plus sûr et plus robuste. Finis les plantages inattendus liés à null !
Voici comment vous pouvez l'utiliser :
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);
}En bref : l'énumération `Result`
Une autre énumération essentielle est Result<T, E>, utilisée pour gérer les erreurs. Elle possède deux variantes :
Ok(T): indique une réussite et contient la valeur obtenue.Err(E): indique un échec et contient une valeur d'erreur.
Nous étudierons Result en détail dans une prochaine leçon, mais retenez qu'il s'agit d'un autre modèle d'énumération très puissant !
Méthodes sur les énumérations
Comme pour les structures, vous pouvez définir des méthodes pour les énumérations à l'aide d'un bloc impl. Ces méthodes peuvent effectuer des actions ou renvoyer des valeurs selon la variante de l'énumération.
Ajoutons une méthode call à notre énumération Message précédente :
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();
}Vérification rapide sur les énumérations
Lesquelles des affirmations suivantes sont vraies à propos des énumérations Rust ?
Récapitulatif : les énumérations pour les types personnalisés
Excellent travail ! Vous avez appris comment les énumérations Rust permettent de définir des types personnalisés pouvant correspondre à plusieurs variantes.
- Les énumérations permettent de modéliser clairement les choix et les états.
- Les variantes peuvent contenir des données associées, ce qui les rend très flexibles.
- L'énumération
Option<T>est essentielle pour gérer l'absence d'une valeur en toute sécurité. - Les énumérations peuvent posséder des méthodes définies dans des blocs
impl.
Ensuite, nous verrons comment travailler avec ces variantes d'énumération grâce à la correspondance de motifs !
Questions Fréquemment Posées
La leçon « Énumérations pour les types personnalisés » est-elle gratuite ?
Oui — le texte complet de « Énumérations pour les types personnalisés » 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 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Énumérations pour les types personnalisés » ?
Utilisez les énumérations pour définir des types pouvant prendre plusieurs variantes, souvent accompagnées de données associées. 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 2 sur 3.
Combien de temps prend la leçon « Énumérations pour les types personnalisés » ?
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 et utiliser des structures
- Énumérations pour les types personnalisés
- Appariement de motifs puissant