Go è un linguaggio di programmazione molto apprezzato che è cresciuto in popolarità grazie alla sua efficacia, velocità ed efficienza. Tuttavia, possono verificarsi errori durante le fasi di sviluppo ed esecuzione, proprio come con qualsiasi altro linguaggio di programmazione. Gestire gli errori in modo efficace è essenziale per garantire l'affidabilità e la stabilità dei tuoi programmi Go.
Questo articolo esaminerà diversi metodi e procedure consigliate per la gestione degli errori in Go.
Gestisci gli errori in Golang
In Vai, puoi gestire gli errori attraverso le modalità di seguito indicate:
- Funzione Nuovo()
- Funzione Errorf()
- Gestione esplicita degli errori
- Rimandare, farsi prendere dal panico e recuperare
- Errore di wrapping
1: funzione Nuovo()
Il linguaggio Go fornisce il Nuovo() funzione per la gestione degli errori. Questa funzione, disponibile nel pacchetto di errori integrato, consente agli sviluppatori di creare messaggi di errore personalizzati per i loro programmi. Utilizzando il Nuovo() funzione, gli sviluppatori possono gestire gli errori in modo efficace e fornire messaggi di errore significativi agli utenti.
pacchetto principale
importare 'errori'
importare 'fmt'
controllo funzionale ( stringa del nome ) errore {
nError := errori.Nuovo ( 'Nome non valido' )
Se nome ! = 'Linux' {
ritorno nErrore
}
ritorno zero
}
funzione principale ( ) {
nome := 'Linux'
err := controlla ( nome )
Se errare ! = nullo {
fmt.Println ( errare )
} altro {
fmt.Println ( 'Nome valido' )
}
}
Il codice precedente utilizza il Nuovo() checkName funzione per vedere se la stringa Linux corrisponde al nome dato. La funzione produce un errore con il messaggio Nome non valido se il nome non lo è Linux . La funzione restituisce nil per indicare che non si è verificato alcun errore se il nome è uguale a Linux .
La variabile nome è impostata su Linux nella chiamata della funzione principale a checkName funzione, che accetta anche la variabile nome come argomento. La funzione principale stampa il messaggio di errore se il file checkName la funzione restituisce un errore. La funzione principale stampa il file Nome valido se la checkName la funzione restituisce zero.
Produzione
2: Funzione Errorf()
IL Erroref() funzione in Go ci consente anche di gestire gli errori. Erroref() ci dà la possibilità di formattare il messaggio di errore. Importando il pacchetto fmt, gli sviluppatori possono utilizzarlo per personalizzare i messaggi di errore in base alle proprie esigenze. Erroref() semplifica e migliora l'efficienza della gestione e della trasmissione degli errori in Go.
pacchetto principaleimportare 'fmt'
funzione div ( n1, n2 tu ) errore {
Se n2 == 0 {
ritorno fmt.Errorf ( '%d / %d \N Impossibile dividere un numero per zero' , n1, n2 )
}
ritorno zero
}
funzione principale ( ) {
err := div ( 42 , 0 )
Se errare ! = nullo {
fmt.Printf ( 'errori' , errare )
} altro {
fmt.Println ( 'Divisione valida' )
}
}
Nel codice sopra, il div La funzione accetta due input di numeri interi, n1 e n2, e se n2 è zero, produce un errore. La funzione produce un errore con un messaggio che contiene i valori di n1 e n2 se n2 è zero. La funzione restituisce nil per indicare che non si è verificato alcun errore se n2 non è zero.
L'errore restituito da div viene salvato nella variabile err quando la funzione principale esegue div con i valori 42 e 0. La funzione principale utilizza fmt.Printf per visualizzare il messaggio di errore se la funzione div restituisce un errore. La funzione principale stampa Divisione valida se la funzione div restituisce nil.
Produzione
3: Gestione esplicita degli errori
Go incoraggia la gestione esplicita degli errori rispetto ad altri linguaggi di programmazione, che spesso si basano su eccezioni. Questo approccio incoraggia gli sviluppatori a utilizzare le istruzioni if per verificare esplicitamente la presenza di errori, invece di fare affidamento sui blocchi try-catch. In questo modo, è più probabile che gli errori vengano individuati e corretti correttamente. Per facilitare questo, Go fornisce il se err != zero istruzione, che consente agli sviluppatori di verificare la presenza di errori dopo l'esecuzione di una funzione e intraprendere azioni appropriate in base al risultato. Con la gestione esplicita degli errori, Go offre un approccio più strutturato e affidabile alla gestione degli errori.
pacchetto principaleimportare 'fmt'
funzione dividere ( a, b float64 ) ( float64, errore ) {
Se B == 0 {
ritorno 0 , fmt.Errorf ( 'non si può dividere per zero' )
}
ritorno UN / b, zero
}
funzione principale ( ) {
risultato, err := dividere ( 13 , 3 )
Se errare ! = nullo {
fmt.Printf ( 'Errore: %v \N ' , errare )
} altro {
fmt.Printf ( 'Risultato: %f \N ' , risultato )
}
risultato, err = dividere ( 23 , 0 )
Se errare ! = nullo {
fmt.Printf ( 'Errore: %v \N ' , errare )
} altro {
fmt.Printf ( 'Risultato: %f \N ' , risultato )
}
}
In questa illustrazione, la funzione di divisione viene utilizzata per dividere due valori. L'output è il risultato di ciò. Se il secondo numero è 0, la funzione produce un errore con un messaggio di errore distinto.
Divide viene chiamato due volte nella funzione principale: una volta con input validi e una volta con input non validi. Il, se err != zero L'istruzione viene utilizzata per determinare se si è verificato un errore ogni volta che viene utilizzata la funzione di divisione. Se si verifica un messaggio di errore, viene stampato. In caso contrario, viene stampato il risultato.
Produzione
4: differire, farsi prendere dal panico e recuperare
Golang fornisce anche il differire istruzione, che viene utilizzata per eseguire una funzione dopo il completamento di un programma o di uno specifico blocco di codice. IL differire dichiarazione è spesso usato in combinazione con il recuperare funzione per catturare e recuperare da errori di runtime panic. Quando si verifica un errore di runtime panic, il file recuperare La funzione viene utilizzata per recuperare dalla condizione di errore e impedire il crash del programma. Ciò è utile per attività di pulizia come la chiusura di file, la chiusura di connessioni di rete o il rilascio di risorse. Rinviando queste attività, ti assicuri che vengano eseguite anche se si verifica un errore.
IL panico viene utilizzato per interrompere la normale esecuzione del programma quando si verifica un errore imprevisto, while recuperare viene utilizzato per gestire il panico e continuare l'esecuzione del programma.
pacchetto principaleimportare 'fmt'
func recoveryFromPanic ( ) {
Se r := recuperare ( ) ; R ! = nullo {
fmt.Println ( 'Recuperato dal panico:' , R )
}
}
funzione dividere ( x,y float64 ) galleggiante64 {
differire recoveryFromPanic ( )
Se e == 0 {
panico ( 'non si può dividere per zero' )
}
ritorno X / E
}
funzione principale ( ) {
fmt.Println ( dividere ( 13 , 3 ) )
fmt.Println ( dividere ( 23 , 0 ) )
}
Nel codice precedente, la funzione di divisione viene utilizzata per dividere due valori in virgola mobile. L'output è il risultato di ciò. Un messaggio di errore personalizzato viene emesso dalla funzione se il secondo numero è zero. L'istruzione defer viene utilizzata per richiamare il recoveryFromPanic funzione. IL recoveryFromPanic funzione rileverà un panico che si è verificato all'interno della funzione di divisione e stamperà un errore se si è verificato.
Divide viene chiamato due volte nella funzione principale: una volta con input validi e una volta con input non validi. IL fmt.Println function stampa l'output della funzione ogni volta che viene eseguita la funzione di divisione. IL recoveryFromPanic la funzione rileverà un panico se si verifica e stamperà un errore se lo fa.
Produzione
Dopo aver rilevato l'errore, il programma si è ripreso dal panico e ha continuato a funzionare. Tuttavia, il codice è andato in panico e non ha restituito un valore alla seconda chiamata a dividere, motivo per cui ha restituito zero.
5: Avvolgimento errore
Go include anche una funzionalità nota come Errore nel wrapping , che consente di aggiungere ulteriore contesto a un messaggio di errore. Questo è utile per registrare problemi o fornire ulteriori dettagli nei messaggi di errore. Ciò può essere ottenuto creando un tipo di errore che incorpori l'errore originale e un contesto aggiuntivo.
pacchetto principaleimportare 'errori'
importare 'fmt'
funzione principale ( ) {
Se err := barra ( ) ; errare ! = nullo {
fmt.Println ( errare )
}
}
funzione dividere ( a, b float64 ) ( float64, errore ) {
Se B == 0 {
ritorno 0 , errori.Nuovo ( 'divisione per zero' )
}
ritorno UN / b, zero
}
barra delle funzioni ( ) ( erro errore ) {
_, err = dividere ( 42 , 0 )
Se errare ! = nullo {
ritorno fmt.Errorf ( 'Impossibile calcolare: %w' , errare )
}
ritorno zero
}
Nel codice precedente, la funzione di divisione calcola il rapporto tra due numeri in questo esempio e genera un errore se il secondo valore è zero. La funzione bar chiama la funzione divide e quindi esegue il wrapping dell'errore that dividere restituisce un nuovo errore con un messaggio che include il messaggio di errore originale utilizzando la funzione fmt.Errorf. La funzione bar viene chiamata dalla funzione main, che stampa anche eventuali errori restituiti.
Produzione
Conclusione
Lo sviluppo del software deve includere gestione degli errori e Golang ha varie funzioni e metodi integrati per farlo con garbo. Questi meccanismi consentono agli sviluppatori di rilevare e ripristinare gli errori, prevenire arresti anomali del programma e fornire messaggi di errore informativi agli utenti finali. Utilizzando questi meccanismi di gestione degli errori in modo efficace, gli sviluppatori possono creare applicazioni software robuste, affidabili ed efficienti.