Enum e Pattern Matching in Rust

Rust fornisce vari tipi di dati per eseguire operazioni, da tipi di dati di base come stringhe, numeri interi e floating puntare i numeri a tipi di dati composti come vettori e array a tipi di dati compositi come struct ed enumerazioni.

Enum (enumerazioni) è un tipo di dati che consente la rappresentazione di un insieme fisso di valori, come i giorni della settimana e il colore dell'arcobaleno. Le enum sono utili quando i possibili valori per una variabile sono limitati e noti.

Definizione di enum in Rust

La dichiarazione di enum in Rust è simile a dichiarare enum in C#. Userai il enum parola chiave che segue il nome e una serie di parentesi graffe per definire le enumerazioni. È possibile definire le possibili varianti (entità) all'interno delle parentesi graffe con una virgola come separatore.

Ecco un enum per i giorni della settimana:

enumGiorno feriale {
 Lunedi,
 Martedì,
 Mercoledì,
 Giovedì,
 Venerdì,
 Sabato,
 Domenica,
}

IL Giorno feriale enum rappresenta i giorni della settimana. IL varianti sono i nomi del giorno e non hanno valori associati. Inoltre, le varianti del tuo enum possono essere qualsiasi Tipo di dati ruggine.

È possibile accedere alle varianti specificando il nome della variante utilizzando l'operatore separatore di percorso (::) sull'enumerazione.

permettere giorno = giorno della settimana:: lunedì;
// versione tipizzata staticamente della variabile `day`
permettere giorno: feriale = feriale:: lunedì;

Il codice specifica che si desidera accedere a Lunedi variante dell'enumerazione Weekday.

Varianti e discriminanti delle enumerazioni

Le varianti di un enum sono associate a valori interi chiamati discriminante. Per impostazione predefinita, i valori discriminanti iniziano da zero e vengono incrementati di 1 per le varianti successive; tuttavia, è possibile specificare valori discriminanti personalizzati per ciascuna variante.

Di seguito è riportato un esempio dell'enumerazione Weekday con varianti assegnate al valore.

enumGiorno feriale {
 lunedì = 1,
 Martedì = 2,
 mercoledì = 3,
 giovedì = 4,
 Venerdì = 5,
 Sabato = 6,
 domenica = 7,
}

L'enumerazione Weekday ha sette varianti che rappresentano ogni giorno della settimana e a ogni giorno è assegnato un valore (chiamato discriminante). Le varianti sono nell'ordine dal primo all'ultimo giorno della settimana.

È possibile accedere al valore discriminante utilizzando il nome della variante.

fnprincipale() {
stampa!("Lunedi: {}", Giorno feriale:: lunedì COMEio32);
stampa!("Martedì: {}", Giorno feriale:: Martedì COMEio32);
stampa!("Mercoledì: {}", Giorno feriale:: mercoledì COMEio32);
stampa!("Giovedì: {}", Giorno feriale:: Giovedì COMEio32);
stampa!("Venerdì: {}", Giorno feriale:: venerdì COMEio32);
stampa!("Sabato: {}", Giorno feriale:: sabato COMEio32);
stampa!("Domenica: {}", Giorno feriale:: Domenica COMEio32);
}

IL stampa! macro viene utilizzato per stampare i discriminanti. Ogni stampa! l'invocazione della macro accetta due argomenti: una stringa di formato e un valore. La stringa di formato specifica come formattare l'output; il valore è il valore effettivo che viene stampato.

In questo caso, la stringa di formato è una stringa letterale che contiene il nome del giorno della settimana e il valore è la variante enum con un cast esplicito al io32 tipo intero.

Il cast esplicito a i32 è necessario perché gli enum di Rust sono rappresentati come interi, ma il tipo di intero specifico dipende dalla dimensione dell'enum. Per impostazione predefinita, Rust assegna il tipo intero più piccolo che può rappresentare tutti i discriminanti nell'enumerazione. Ma in questo caso, vuoi stampare i valori come interi i32, quindi devi eseguirne il cast in modo esplicito.

Ecco il risultato dell'esecuzione del file principale funzione:

Corrispondenza dei modelli in ruggine

Il pattern matching è un costrutto della struttura di controllo di Rust utile per identificare i pattern di dati. La corrispondenza dei modelli consente di scrivere codice conciso ed efficiente mentre si opera con strutture dati avanzate o eseguire operazioni complesse.

Userai il incontro parola chiave seguita dal => separatore per il modello e l'operazione per il modello, rispettivamente. Il modello può essere qualsiasi espressione di Rust, inclusi valori letterali, variabili e chiamate di funzione.

Ecco un esempio di dichiarazione di corrispondenza:

fnprincipale(){
permettere x = 5;
incontro X {
1 => stampa!("uno"),
2 => stampa!("due"),
3 => stampa!("tre"),
// viene eseguito se nessuno dei modelli corrisponde
 _ => stampa!("qualcos'altro"),
 }
}

IL principale la funzione corrisponde X rispetto a diversi modelli e quindi stampa il valore in base al valore di x. Il modello di sottolineatura (_) è un modello di caratteri jolly utilizzato come catch-all per i casi che non vengono gestiti in modo esplicito.

Enum e Pattern Matching

Le enumerazioni e la corrispondenza dei modelli sono utili per esprimere e lavorare con strutture di dati avanzate in modo indipendente dai tipi ed efficiente. È possibile utilizzare le enumerazioni per definire un insieme fisso di valori e criteri di ricerca per lavorare con tali valori.

Ecco un enum per i colori in un arcobaleno:

enumArcobaleno {
 Rosso,
 Arancia,
 Giallo,
 Verde,
 Blu,
 Indaco,
 Viola,
}

Ogni variante del Arcobaleno enum rappresenta un colore dell'arcobaleno. È possibile utilizzare la corrispondenza del modello con l'istruzione match per confrontare i modelli con la variante per controllare il flusso del programma in base al colore dell'arcobaleno.

Ecco una funzione che prende la variante di colore dall'enumerazione Rainbow e stampa un messaggio basato sul colore.

fnstampa_colore(colore: Arcobaleno) {
incontro colore {
 Arcobaleno:: Rosso => stampa!("Il colore è rosso!"),
 Arcobaleno:: Arancione => stampa!("Il colore è arancione!"),
 Arcobaleno:: Giallo => stampa!("Il colore è giallo!"),
 Arcobaleno:: Verde => stampa!("Il colore è verde!"),
 Arcobaleno:: Blu => stampa!("Il colore è blu!"),
 Arcobaleno:: Indaco => stampa!("Il colore è indaco!"),
 Arcobaleno:: Viola => stampa!("Il colore è viola!"),
 }
}
fnprincipale() {
permettere colore = Arcobaleno:: Blu;
 print_color (colore);
}

Potresti ottenere le varianti non sono mai costruite o avvisi simili quando proverai a eseguire il codice sopra perché le altre varianti oltre alla variante Blue non sono mai state costruite in questo codice. Pertanto, in questo caso, puoi tranquillamente ignorare questi avvisi poiché è intenzionale.

IL stampa_colore La funzione accetta un parametro di colore del tipo Rainbow enum. L'istruzione match corrisponde al colore di una suite di colori a cui si accede tramite i nomi delle varianti. Infine, il messaggio viene stampato in base al colore abbinato.

Puoi utilizzare la corrispondenza del modello per operazioni complesse come più valori restituiti in base a una condizione.

fncalcola_lunghezza d'onda(colore: Arcobaleno) -> u32 {
incontro colore {
 Arcobaleno:: Rosso => 700,
 Arcobaleno:: Arancione => 590,
 Arcobaleno:: Giallo => 570,
 Arcobaleno:: Verde => 510,
 Arcobaleno:: Blu => 475,
 Arcobaleno:: Indaco => 445,
 Arcobaleno:: Viola => 400,
 }
}

IL calcola_lunghezza d'onda La funzione accetta una variante di colore del tipo enum Rainbow come parametro e restituisce un numero intero senza segno a 32 bit che è la lunghezza d'onda del colore che corrisponde al motivo.

Rust fornisce anche strutture per la creazione di tipi personalizzati

Le enum sono utili per definire tipi personalizzati per diverse operazioni, specialmente nei casi in cui i campi sono noti e definiti.

Rust fornisce anche struct che puoi usare per creare tipi personalizzati con campi denominati. A differenza degli enum, gli struct consentono di definire campi di tipi diversi a cui è possibile accedere e modificare individualmente.