Funzione di scartare per la gestione degli errori in ruggine
Supponiamo di aver bisogno di una base concreta sulla gestione degli errori in ruggine. È necessario comprendere l'opzione e i tipi di risultati. Tengono le basi al downrap e si aspettano funzioni fondamentali per la gestione degli errori.
Vediamo se possiamo darne un senso in questo tutorial.
Tipo di opzione ruggine
Il tipo di opzione Rust è un enum relativamente "semplice" usato per produrre la possibilità di assenza.
Dai un'occhiata alla seguente sintassi dell'opzione:
Opzione enumNessuno,
Alcuni (t),
Potresti notare che ha due varianti: qualcosa (alcuni) e niente (nessuno). La capacità di dire al compilatore come gestire la possibilità di assenza è importante.
In breve, pensa al tipo di opzione come una scatola che può avere qualcosa o niente ma non entrambi.
Tipo di risultato ruggine
Il tipo di risultato è anche definito nella libreria standard. La sintassi è fornita di seguito:
risultato enumOk (t),
Err (e),
Ha due varianti: ok ed err. Si noti che è strettamente simile al tipo di opzione. Questo perché funziona in modo molto simile.
Tuttavia, a differenza del tipo di opzione, il tipo di risultato "anticipa" la possibilità di un errore. Pensaci in questo modo. Se si esegue un'operazione, ci sono solo due cose che possono accadere, o l'operazione ha esito positivo, quindi ok.
O l'operazione non riesce e si ottiene un errore. Quindi, la variante ERR emerge. Quando l'operazione restituisce un errore in ruggine, la variante Err () chiamerà il panico! Macro e uscita.
Ma cosa c'entra questo con la gestione degli errori?
Esistono due modi per gestire la possibilità di assenza. Il primo è la gestione esplicita usando l'operatore di Match e il successivo è la gestione implicita con la funzione di downrap.
Il seguente codice di esempio illustra le informazioni fornite:
#[consenti (dead_code)]fncheck_db (db: opzione)
// Handle esplicito con la partita
matchdb
Alcuni ("mysql") => println!("Server in esecuzione sulla porta: 3306"),
Alcuni ("postgresql") => println!("Server in esecuzione sulla porta: 5432"),
Alcuni (interni) => println!("Lasciami controllare!!!"),
Nessuno => println!("Fornisci un DB:"),
#[consenti (dead_code)]
fndb (db: opzione)
// Handley implicita con scarto
Ifdb.unwrap () == ""
// panico se nessuno
panico!("Abortito")
fnMain ()
letmysql = alcuni ("mysql");
letpostgres = alcuni ("postgresql");
non lasciare nessuno = nessuno;
check_db (mysql);
check_db (postgres);
check_db (alcuni ("MongoDB"));
check_db (nessuno);
db (alcuni ("MongoDB"));
db (nessuno);
L'esempio precedente utilizza due funzioni per illustrare la gestione degli errori espliciti e impliciti in nessuno e alcuni valori di restituzione.
Il primo utilizza l'operatore Match per controllare vari casi, mentre l'altro utilizza il downrap. Se non ne riceve nessuno, la funzione panico.
Il codice precedente fornisce il seguente output:
Conclusione
Questo articolo esamina la gestione degli errori nel linguaggio di programmazione Rust. Questo processo include il downrap e si aspettano funzioni per completare il processo. Inoltre, sono stati discussi il tipo di opzione di ruggine e il tipo di risultato della ruggine. Speriamo che tu abbia trovato questo articolo utile. Controlla altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.