Come usare Enums in Rust

In questo articolo, esploreremo come lavorare con Enums nel linguaggio di programmazione ruggine.

Definizione di un enum

Consideriamo un esempio in cui possiamo usare un tipo enum. Ad esempio, se abbiamo bisogno di archiviare le indicazioni, possiamo usare un enum. In genere, possiamo esprimere la direzione in quattro valori possibili principali: nord -est, sud e ovest.

Se consideriamo la direzione, un veicolo può muoversi in una di tutte le direzioni possibili ma non più una volta allo stesso tempo.

Questo rende un enum fortemente appropriato per tale struttura.

Per dichiarare un enum in ruggine, iniziamo con la parola chiave enum, seguita dall'identificatore enum. Un esempio è fornito di seguito:

ENUM Direction
Nord,
Est,
Sud,
ovest

L'esempio precedente ci consente di definire un tipo personalizzato di direzione del tipo che possiamo riutilizzare nel programma.

Puoi anche definire un enum con una variante senza dati ad esso associati, simile a una struttura simile a unità. Un enum può anche avere varianti con dati denominati e dati senza nome.

Un esempio è come mostrato:

enum persona
Vivo,
Maschio (stringa, f64),
Female Nome: String, Age: I32

Gli enum sono utili durante la creazione di un tipo come mostrato nell'esempio precedente. Se dovessimo usare la definizione struct, dovremmo creare più strutture. Enums ci consente di archiviare tutte le varianti sotto un'unica entità.

Valori enum

Dopo aver dichiarato un enum, possiamo creare un'istanza di un enum usando le possibili varianti disponibili nel tipo.

Per esempio:

fn main ()
Sia N = Direzione :: North;
Sia E = Direzione :: East;
Sia S = Direzione :: South;
Sia W = Direzione :: West;

Per accedere alla variante di un enum, utilizziamo il doppio colon per separare lo spazio dei nomi della variante e il suo identificatore.

Abbinare gli enum

Un uso importante di Enums è la corrispondenza dei pattern. Se hai più potenziali corrispondenze nel tuo programma, l'opzione per un blocco IF-ELSE potrebbe non creare un codice leggibile. Per uno scenario del genere, possiamo usare Enums con l'operatore Match.

L'operatore Match ci consente di confrontare un valore con un elenco di modelli, come nomi di variabili, valori letterali e varianti Enum.

Considera il seguente esempio delle direzioni ENUM che abbiamo creato in precedenza:

fn main ()
Let Direction: Direction = Direction :: North;
Direzione corrispondente
Direzione :: North =>
println!("La direzione è nord");
,
Direzione :: East =>
println!("La direzione è est");
,
Direzione :: South =>
println!("La direzione è sud");
,
Direzione :: West =>
println!("La direzione è ovest");

Nell'esempio precedente, iniziamo con la parola chiave Match seguita dall'espressione che desideriamo valutare. Sebbene la sintassi possa sembrare simile a un'istruzione IF, l'espressione di Match non restituisce un vero o falso. Il tipo di ritorno può essere di qualsiasi tipo. Nel nostro caso, il tipo di ritorno è una direzione enum.

Il blocco successivo è noto come un braccio di abbinamento. Un braccio contiene il modello da abbinare e il blocco di codice da eseguire se viene trovata la corrispondenza.

Nel nostro esempio, il primo braccio contiene il modello di direzione :: North e l'operatore =>. Questo apre il blocco per l'esecuzione del codice quando viene trovata la partita. Per l'esempio precedente, stampiamo il messaggio per la direzione di corrispondenza.

Il compilatore valuterà l'espressione della partita e si confronterà per un modello di abbinamento nel braccio fornito. Se viene trovata una corrispondenza all'interno di un braccio specifico, viene eseguito il codice all'interno del blocco braccio. Altrimenti, il compilatore continua con la valutazione.

Possiamo eseguire il codice precedente come segue:

Rustc Enums.Rs
./enums

Il codice precedente dovrebbe restituire come segue:

$ ./enums
La direzione è nord

Il segnaposto _

Supponiamo che vogliamo solo svolgere funzioni specifiche per modelli particolari in un enum. Quindi, fai un'azione comune per tutti gli altri.

In tal caso, possiamo usare l'operatore _, che corrisponde a tutti gli altri casi non specificati all'interno di un'espressione di corrispondenza.

Prendiamo le indicazioni enum che abbiamo creato prima. Possiamo definire un'azione se la direzione è nord e, in caso contrario, eseguiamo un messaggio globale per tutti gli altri casi. Il codice risultante è come mostrato di seguito:

fn main ()
Let Direction: Direction = Direction :: North;
Direzione corrispondente
Direzione :: North =>
println!("La direzione è nord");
,
_ =>
println!("Altra direzione")

Se cambiamo il valore di "direzione", dovremmo ottenere il seguente output come:

Let Direction: Direction = Direction :: East;
$ cargo run
Altra direzione

Il codice all'interno del blocco _ viene eseguito poiché non abbiamo definito alcun caso di corrispondenza per la direzione est.

Zero Variant Enums

Possiamo anche creare un enum senza varianti. Questi sono noti come enum zero-varianti e non possiamo istanziarli.

Di seguito è riportato un esempio di enum varianti zero-varianti:

enum zeroenum

Non possiamo lanciare enum varianti zero ad altri tipi.

Conclusione

In questo articolo, abbiamo esplorato le basi del lavoro con i tipi ENUM nel linguaggio di programmazione ruggine. Abbiamo messo in evidenza come lavorare con Enums in Rust, che include la definizione di un enum, l'uso dei valori enum e come abbinare su enums. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.