Créer des enums en Rust

Les Enums sont un moyen de représenter un ensemble de valeurs liées. Dans Rust, ils sont implémentés comme un type intégral avec des variantes.

Le mot-clé enum est utilisé pour créer un type enum, et le mot-clé variant est utilisé pour déclarer des variantes. Le variant peut contenir n’importe quel nombre de constantes appelées énumérateurs, et les variants peuvent également avoir des méthodes, appelées fonctions associées ou constantes associées.

Dans cet article, nous aborderons le concept Rust Enums.

Déclarer un enum en Rust

Le mot clé enum permet de créer une énumération. Il peut être utilisé pour définir un type avec plusieurs valeurs différentes.

1. Créez la définition enum avec le mot-clé enum, suivi du nom du type énuméré, suivi d’une liste de valeurs entre accolades({}).
2. Créez des instances de ce type avec le même nom que le type, puis affectez à chaque instance une valeur de sa liste correspondante.
3. Le mot-clé case est utilisé pour créer des branches dans une définition enum.

Initialiser enum avec des valeurs dans Rust

On affecte un enum avec une valeur à une variable pour l’initialiser avec des valeurs. Le nom enum est écrit en premier, suivi des opérateurs doubles-points et du nom de la valeur enum.

Enfin, une valeur est spécifiée entre parenthèses.

Exemple de code :

#[derive(Debug)]
enum Demo {
    A(i32),
    B(i32)
}
fn main() {
    let hello = Demo::A(1);
    let byew = Demo::B(0);
    println!("Hello: {:?}", hello);
    println!("Bye: {:?}", byew);
}

Production:

Hello: A(1)
Bye: B(0)

Exécuter le code

Avantages de enum dans Rust

Un enum est un type de données contenant un ensemble de valeurs liées. C’est comme un tableau, mais vous n’avez pas à vous soucier de manquer d’espace ou de réallouer de la mémoire lorsque vous ajoutez d’autres éléments.

Les Enums sont meilleures car elles sont plus explicites et moins sujettes aux erreurs que l’utilisation d’une chaîne pour chaque valeur possible. Enums permet également des vérifications au moment de la compilation qui garantissent que vous n’attribuez pas le mauvais type à une variable ou que vous n’épelez pas mal l’une des variantes de votre code.