Go és un llenguatge de programació molt popular que ha crescut en popularitat per la seva eficàcia, velocitat i eficiència. Tanmateix, es poden produir errors durant les fases de desenvolupament i execució, igual que amb qualsevol altre llenguatge de programació. Gestionar els errors de manera eficaç és essencial per garantir la fiabilitat i l'estabilitat dels vostres programes Go.
Aquest article examinarà diversos mètodes i procediments recomanats per gestionar els errors a Go.
Gestioneu els errors a Golang
A Go, pots manejar els errors mitjançant els mètodes esmentats a continuació:
- Funció New().
- Funció Errorf().
- Tractament explícit d'errors
- Ajornar, entrar en pànic i recuperar-se
- Error en embolicar
1: Funció Nova ().
L'idioma Go proporciona el Nou() funció per gestionar errors. Aquesta funció, disponible al paquet d'errors integrat, permet als desenvolupadors crear missatges d'error personalitzats per als seus programes. Mitjançant l'ús del Nou() funció, els desenvolupadors poden gestionar els errors de manera eficaç i proporcionar missatges d'error significatius als usuaris.
paquet principal
importar 'errors'
importar 'fmt'
comprovació de funcions ( cadena de nom ) error {
nError := errors.Nou ( 'Nom no vàlid' )
si nom ! = 'Linux' {
tornar nError
}
tornar nil
}
funció principal ( ) {
nom := 'Linux'
err := comproveu ( nom )
si errar ! = nul {
fmt.Println ( errar )
} altra cosa {
fmt.Println ( 'Nom vàlid' )
}
}
El codi anterior utilitza el Nou() checkName funció per veure si la cadena Linux coincideix amb el nom donat. La funció produeix un error amb el missatge Nom no vàlid si el nom no ho és Linux . La funció retorna nil per mostrar que no hi ha hagut cap error si el nom és igual a Linux .
La variable de nom està establerta a Linux a la crida de la funció principal al checkName funció, que també pren la variable de nom com a argument. La funció principal imprimeix el missatge d'error si checkName La funció retorna un error. La funció principal imprimeix el Nom vàlid si el checkName la funció retorna nul.
Sortida
2: Funció Errorf().
El Errorf() La funció de Go també ens permet gestionar els errors. Errorf() ens ofereix l'opció de formatar el missatge d'error. En importar el paquet fmt, els desenvolupadors poden utilitzar-lo per personalitzar els missatges d'error segons les seves necessitats. Errorf() racionalitza i millora l'eficiència de la gestió i la transmissió d'errors a Go.
paquet principalimportar 'fmt'
funció div ( n1, n2 tu ) error {
si n2 == 0 {
tornar fmt.Error ( '%d/%d \n No es pot dividir un nombre per zero' , n1, n2 )
}
tornar nil
}
funció principal ( ) {
err := div ( 42 , 0 )
si errar ! = nul {
fmt.Printf ( 'error: %s' , errar )
} altra cosa {
fmt.Println ( 'Divisió vàlida' )
}
}
En el codi anterior, el div La funció accepta dues entrades senceres, n1 i n2, i si n2 és zero, produeix un error. La funció produeix un error amb un missatge que conté els valors de n1 i n2 si n2 és zero. La funció retorna nil per mostrar que no hi ha hagut cap error si n2 no és zero.
L'error que retorna div es desa a la variable err quan la funció principal executa div amb els valors 42 i 0. La funció principal utilitza fmt.Printf per mostrar el missatge d'error si la funció div retorna un error. La funció principal imprimeix Divisió vàlida si la funció div retorna nil.
Sortida
3: Gestió explícita d'errors
Go fomenta la gestió explícita d'errors en comparació amb altres llenguatges de programació, que sovint es basen en excepcions. Aquest enfocament anima els desenvolupadors a utilitzar les declaracions if per comprovar explícitament si hi ha errors, en lloc de confiar en els blocs try-catch. D'aquesta manera, és més probable que els errors es trobin i es solucionin correctament. Per facilitar-ho, Go ofereix el si s'erra != nul declaració, que permet als desenvolupadors comprovar si hi ha errors després d'executar una funció i prendre les accions adequades en funció del resultat. Amb la gestió explícita d'errors, Go ofereix un enfocament més estructurat i fiable per a la gestió d'errors.
paquet principalimportar 'fmt'
divisió de funcions ( a, b flotant64 ) ( float64, error ) {
si b == 0 {
tornar 0 , fmt.Errorf ( 'no es pot dividir per zero' )
}
tornar a / b, nul
}
funció principal ( ) {
resultat, err := dividir ( 13 , 3 )
si errar ! = nul {
fmt.Printf ( 'Error: %v \n ' , errar )
} altra cosa {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
resultat, err = dividir ( 23 , 0 )
si errar ! = nul {
fmt.Printf ( 'Error: %v \n ' , errar )
} altra cosa {
fmt.Printf ( 'Resultat: %f \n ' , resultat )
}
}
En aquesta il·lustració, la funció de dividir s'utilitza per dividir dos valors. La sortida és el resultat de fer-ho. Si el segon nombre és 0, la funció produeix un error amb un missatge d'error diferent.
Dividir s'anomena dues vegades a la funció principal: una amb entrades vàlides i una altra amb una entrada no vàlida. El, si err != nul s'utilitza per determinar si s'ha produït un error cada vegada que s'utilitza la funció de divisió. S'imprimeix un missatge d'error si es produeix. Si no, s'imprimeix el resultat.
Sortida
4: Ajornar, entrar en pànic i recuperar-se
Golang també ofereix el ajornar sentència, que s'utilitza per executar una funció després de completar un programa o un bloc de codi específic. El ajornar La declaració s'utilitza sovint juntament amb la recuperar funció per detectar i recuperar-se dels errors de pànic en temps d'execució. Quan es produeix un error de pànic en temps d'execució, el fitxer recuperar La funció s'utilitza per recuperar-se de la condició d'error i evitar que el programa es bloquegi. Això és útil per a tasques de neteja, com ara tancar fitxers, tancar connexions de xarxa o alliberar recursos. En ajornar aquestes tasques, us assegureu que s'executen encara que es produeixi un error.
El pànic s'utilitza per aturar l'execució normal del programa quan es produeix un error inesperat, mentre recuperar s'utilitza per gestionar el pànic i continuar l'execució del programa.
paquet principalimportar 'fmt'
func recoverFromPanic ( ) {
si r := recuperar ( ) ; r ! = nul {
fmt.Println ( 'Recuperat del pànic:' , r )
}
}
divisió de funcions ( x, i float64 ) flotar64 {
ajornar recoverFromPanic ( )
si i == 0 {
pànic ( 'no es pot dividir per zero' )
}
tornar x / i
}
funció principal ( ) {
fmt.Println ( dividir ( 13 , 3 ) )
fmt.Println ( dividir ( 23 , 0 ) )
}
Al codi anterior, la funció divideix s'utilitza per dividir dos valors de coma flotant. La sortida és el resultat de fer-ho. La funció emet un missatge d'error personalitzat si el segon nombre és zero. La declaració defer s'utilitza per invocar el recoverFromPanic funció. El recoverFromPanic La funció detectarà un pànic que va passar dins de la funció de divisió i imprimirà un error si es va produir.
Dividir s'anomena dues vegades a la funció principal: una amb entrades vàlides i una altra amb una entrada no vàlida. El fmt.Println La funció imprimeix la sortida de la funció cada vegada que s'executa la funció de divisió. El recoverFromPanic La funció detectarà un pànic si passa i imprimirà un error si ho fa.
Sortida
Després de detectar l'error, el programa es va recuperar del pànic i es va continuar executant. Tanmateix, el codi va entrar en pànic i no va retornar cap valor a la segona trucada per dividir, per això va tornar zero.
5: Error d'embolcall
Go també inclou una funció coneguda com Error en embolicar , que us permet afegir context addicional a un missatge d'error. Això és útil per registrar problemes o proporcionar més detalls en missatges d'error. Això es pot aconseguir creant un tipus d'error que incrusti l'error original i el context addicional.
paquet principalimportar 'errors'
importar 'fmt'
funció principal ( ) {
si err := bar ( ) ; errar ! = nul {
fmt.Println ( errar )
}
}
divisió de funcions ( a, b flotant64 ) ( float64, error ) {
si b == 0 {
tornar 0 , errors.New ( 'divisió per zero' )
}
tornar a / b, nul
}
barra de funcions ( ) ( error error ) {
_, err = dividir ( 42 , 0 )
si errar ! = nul {
tornar fmt.Error ( 'No s'ha pogut calcular: %w' , errar )
}
tornar nil
}
Al codi anterior, la funció de divisió calcula la proporció de dos nombres en aquest exemple i genera un error si el segon valor és zero. La funció de barra crida a la funció de divisió i després embolcalla l'error que dividir retorna un nou error amb un missatge que inclou el missatge d'error original mitjançant la funció fmt.Errorf. La funció principal crida a la funció de barra, que també imprimeix els errors que retorna.
Sortida
Conclusió
El desenvolupament de programari ha d'incloure maneig d'errors , i Golang té diverses funcions i mètodes integrats per fer-ho amb gràcia. Aquests mecanismes permeten als desenvolupadors detectar i recuperar-se dels errors, prevenir els bloquejos del programa i proporcionar missatges d'error informatius als usuaris finals. Mitjançant l'ús eficaç d'aquests mecanismes de gestió d'errors, els desenvolupadors poden crear aplicacions de programari robustes, fiables i eficients.