La gestione degli errori è una delle operazioni frequenti nel ciclo di sviluppo del software. È un aspetto cruciale di una buona programmazione. Go adotta un approccio semplice e facile da usare con il suo meccanismo integrato per la gestione degli errori. Si basa sulla restituzione di errori da funzioni e metodi, consentendoti di concentrarti sulla funzionalità del codice intuitiva e di facile lettura.
Gestisci gli errori in Go in modo esplicito, il che si traduce in un solido framework per il feedback, con la possibilità di implementare la logica di ripetizione in modo coerente. IL errori Il pacchetto fornisce funzionalità aggiuntive per la gestione degli errori.
Il pacchetto degli errori
Il pacchetto degli errori è uno dei pacchetti nella libreria standard di Go. Il pacchetto fornisce semplici primitive e funzionalità di gestione degli errori per la creazione e la manipolazione degli errori in modo coerente nel codice Go.
Il pacchetto fornisce il Nuovo funzione per la creazione di errori con messaggi di errore personalizzati che è possibile utilizzare allo stesso modo di qualsiasi tipo di errore integrato, come il zero E Errore metodo del errore interfaccia.
IL errori package fornisce anche funzionalità per il wrapping e l'unwrapping degli errori, un metodo per le asserzioni di tipo sugli errori.
Puoi importare il file errori pacchetto con la parola chiave import. Basta specificare il nome del pacchetto nell'elenco delle importazioni.
importare"errori"
Catturare e gestire gli errori in Go
La conoscenza della gestione degli errori di base in Go pone le basi per la comprensione del errori pacchetto. Funzioni e metodi restituiscono errori accompagnati da una risorsa.
Ecco un esempio di gestione degli errori da un'operazione di apertura di un file con il built-in os pacchetto.
pacchetto principaleimportare (
"fmt"
"os"
)funzprincipale() {
file, err := os. Aprire("nomefile.txt")Se errare!= zero {
fmt. Stampaln (err)
}
// ...
}
IL Aprire metodo del os pacchetto è utile quando lavorare con i file di testo in Go. Apre un file, restituendo un'istanza di file aperto e un file errore.
Il valore dell'errore potrebbe essere il zero digitare, indicando l'assenza di errori. Tuttavia, puoi verificare la presenza di un caso non nullo e gestire un errore se presente. Nel caso precedente, il blocco if stampa l'errore.
Puoi accedere al Errore metodo di un errore per estrarre più informazioni sull'errore (di solito una descrizione).
Se errare!= zero {
fmt. Println (err. Errore())
}
Ad esempio, se il file non esiste, verrà visualizzato un messaggio di errore simile a questo:
Creazione di errori in Go
Puoi creare errori con il file Nuovo metodo del errori pacchetto. Questo metodo accetta un messaggio di stringa e restituisce gli errori rilevati.
importare"errori"funzprincipale() {
err := errori. Nuovo("qualcosa è andato storto")
Se errare!= zero {
// il codice di gestione degli errori va qui
}
}
IL principale La funzione crea un nuovo errore e gestisce i possibili errori dalla creazione dell'errore con un Se dichiarazione.
Puoi anche definire errori personalizzati in Go. Il metodo convenzionale utilizza una struttura e una funzione di errore per implementare la struttura in base alla funzionalità dell'errore.
pacchetto principaleimportare"fmt"
tipo customError struct {
informazioni corda
}funzprincipale() {
// esempio di istanziazione della struct
err := errorepersonalizzato{
informazioni: "Qualcosa è andato storto!",
}
// emette l'istanza della struttura
fmt. Stampaln (err)
}
IL customError struct è il progetto per l'errore e il file informazioni campo stringa conterrà il messaggio di errore.
Le tue funzioni di errore possono implementare il customError struct e restituisce una stringa di errore.
funz(ce customError)Errore()corda {
ritorno fmt. Sprintf("Si è verificato un errore personalizzato: %v", ce.info)
}
IL Errore metodo del customError struct restituisce una stringa usando il metodo di formattazione Sprintf del pacchetto fmt.
Errori di wrapping e scarto in Go
È possibile aggiungere ulteriori informazioni contestuali agli errori eseguendo il wrapping. Utilizzerai principalmente gli errori racchiusi per creare messaggi di errore chiari per la precisione nel debug.
Puoi usare il Errore f metodo del fmt pacchetto che fornisce funzionalità per la formattazione dei messaggi di errore per avvolgere gli errori. IL Errore f Il metodo accetta una stringa e un verbo di formattazione della stringa e l'errore e restituisce l'errore racchiuso.
importare (
"fmt"
"os"
)funzprincipale() {
_, err := os. Aprire("nomefile.txt")
Se errare!= zero {
avvoltoErr := fmt. Erroref("Errore durante l'apertura del file: %v", ehm)
fmt. Println (wrappedErr)
}
}
IL principale La funzione apre un file con l'estensione os Pacchetti Aprire e esegue il wrapping dell'errore con il metodo Errorf di fmt pacchetto. Quindi emette l'errore avvolto nella console.
Puoi scartare gli errori racchiusi nei tuoi programmi con il file Scartare metodo del errori pacchetto. IL Scartare Il metodo accetta l'errore avvolto e restituisce l'errore non avvolto.
importare (
"fmt"
"os"
"errori"
)funzprincipale() {
_, err := os. Aprire("nomefile.txt")
Se errare!= zero {
avvoltoErr := fmt. Erroref("Errore durante l'apertura del file: %v", ehm)
unwrappedErr := errori. Unwrap (wrappedErr)
fmt. Println (unwrappedErr)
}
}
IL principale la funzione esegue il wrapping di un errore da un'operazione di apertura di file e la funzione scartatoErr la variabile contiene l'errore di cui non è stato eseguito il wrapping.
Registra i tuoi rapporti di errore con questi pacchetti di registrazione di terze parti
Dovrai registrare alcuni errori per successive revisioni, debug e altre operazioni durante il processo di sviluppo dell'applicazione. Puoi usare il zap pacchetto di pacchetti Uber, Logrus, Zerolog e Log15 per una registrazione rapida e strutturata.
