Enums ruggine

In questo articolo, impareremo in breve enumerazioni o enum. Enums ci consente di definire un tipo personalizzato costituito da varianti. Sono strettamente simili a una struttura e ogni struttura valida è un enum valido.

Rust dichiara enum

Possiamo definire un enum in ruggine usando la parola chiave enum, seguito dal nome dell'enum. Creiamo quindi il corpo enum all'interno di una coppia di parentesi cure.

Il corpo enum è costituito da possibili varianti separate da virgole.

La sintassi è come mostrata:

enumenum_name
variante(),
variante2
variante3
..

La ruggine consiglia di utilizzare Uppercamelcasing per la denominazione delle varianti enum.

Prendiamo un caso in cui gli enum possono essere utili. Un esempio che mi viene in mente sono i tipi di carica. Esistono due tipi di carica:

1. Negativo
2. Positivo

Poiché può esserci solo un tipo di carica in un determinato momento, ha senso usare un enum. Un esempio è come mostrato di seguito:

enumcharge
Negativo,
Positivo

Rust Initialize Enum

Una volta definito un enum, possiamo creare istanze di ciascuna delle varianti. Un esempio è come mostrato:

fnMain ()
Sia p = carica :: positivo;
Sia n = carica :: negativo;

Usando enums con strutture

Un modo per espandere un enum è combinarlo con una struttura. Considera il codice di esempio seguente:

Stristryment
Nome: String,
Valore: i32,
Accusa: addebito,

Una volta che abbiamo una struttura, possiamo creare un'istanza della struttura e passare le proprietà dell'Enum come mostrato nell'esempio seguente:

ENUM CHARME
Negativo,
Positivo

elemento struct
Nome: String,
Valore: i32,
Accusa: addebito,

fn main ()
let Elem1 = elemento
Nome: "Sodio".accordare(),
Valore: 1,
Accusa: carica :: positivo
;
let Elem2 = elemento
Nome: "cloruro".accordare(),
Valore: 1,
Accusa: carica :: negativo
;

Nel codice di esempio sopra, definiamo due istanze dell'elemento struct. Passiamo quindi la proprietà di addebito come valore dall'enum di addebito.

Rust Deriva tratto

Se si tenta di stampare le istanze della struttura sopra, il compilatore restituirà un errore. Per stampare la struttura, dobbiamo "importare" il tratto del debug.

Questo viene fatto usando l'attributo Derive. Questo ci consente di ottenere varie implementazioni di tratti come:

1. Tratto di debug
2. Eq, Partialeq, Ord, Particord
3. Tratto hash,
4. Tratto predefinito
5. Eccetera.

La sintassi per derivare un tratto è come mostrato:

#[Derive (TRAIT_NAME)]

Poiché dobbiamo stampare la struttura sulla console, possiamo derivare il tratto di debug come mostrato:

#[Derive (Debug)]
enumcharge
Negativo,
Positivo

#[Derive (Debug)]
Stristryment
Nome: String,
Valore: i32,
Accusa: addebito,

Possiamo quindi usare questo tratto per stampare la struttura sulla console come:

println!(":#? ", Elem1);

Questo dovrebbe stampare la struttura sulla console come:

È possibile controllare la documentazione Deriva nella risorsa fornita di seguito:

https: // doc.Rust-Lang.org/riferimento/attributi/deriva.html

Conclusione

In questo articolo, abbiamo esplorato come creare, utilizzare e lavorare con i tipi enum in ruggine. Abbiamo anche coperto come usare gli enum con le strutture e come trarre tratti.

Grazie per aver letto!!