Go este un limbaj de programare foarte apreciat, care a crescut în popularitate datorită eficienței, vitezei și eficienței sale. Totuși, greșelile pot apărea în timpul fazelor de dezvoltare și execuție, la fel ca în orice alt limbaj de programare. Gestionarea eficientă a erorilor este esențială pentru a asigura fiabilitatea și stabilitatea programelor dvs. Go.
Acest articol va examina mai multe metode și proceduri recomandate pentru gestionarea erorilor în Go.
Gestionați erorile în Golang
În Go, poți gestionează erorile prin metodele de mai jos:
- Funcția New().
- Funcția Errorf().
- Tratarea explicită a erorilor
- Amânați, intrați în panică și recuperați-vă
- Eroare la împachetare
1: Funcția New().
Limbajul Go oferă Nou() funcția de gestionare a erorilor. Această funcție, disponibilă în pachetul de erori încorporat, permite dezvoltatorilor să creeze mesaje de eroare personalizate pentru programele lor. Prin utilizarea Nou() Funcție, dezvoltatorii pot gestiona erorile în mod eficient și pot furniza mesaje de eroare semnificative utilizatorilor.
pachet principal
import 'erori'
import 'fmt'
verificare func ( șir de nume ) eroare {
nEroare := erori.Nou ( 'Nume invalid' )
dacă Nume ! = 'Linux' {
întoarcere nEroare
}
întoarcere zero
}
func principal ( ) {
nume := 'Linux'
err := verifica ( Nume )
dacă a greșit ! = zero {
fmt.Println ( a greșit )
} altfel {
fmt.Println ( 'Nume valid' )
}
}
Codul de mai sus folosește Nou() checkName funcția pentru a vedea dacă șirul Linux se potrivește cu numele dat. Funcția produce o eroare cu mesajul Nume invalid dacă numele nu este Linux . Funcția returnează nil pentru a arăta că nu a existat nicio eroare dacă numele este egal cu Linux .
Variabila nume este setată la Linux în apelul funcției principale la checkName funcția, care ia și variabila nume ca argument. Funcția principală imprimă mesajul de eroare dacă checkName funcția returnează o eroare. Funcția principală imprimă Nume valid dacă checkName funcția returnează zero.
Ieșire
2: Funcția Errorf().
The Errorf() funcția din Go ne permite să gestionăm și erorile. Errorf() ne oferă opțiunea de formatare a mesajului de eroare. Importând pachetul fmt, dezvoltatorii îl pot utiliza pentru a personaliza mesajele de eroare în funcție de nevoile lor. Errorf() eficientizează și îmbunătățește eficiența gestionării și transmiterii erorilor în Go.
pachet principalimport 'fmt'
func div ( n1, n2 tu ) eroare {
dacă n2 == 0 {
întoarcere fmt.Eroare ( „%d/%d \n Nu se poate împărți un număr la zero' , n1, n2 )
}
întoarcere zero
}
func principal ( ) {
err := div ( 42 , 0 )
dacă a greșit ! = zero {
fmt.Printf ( „eroare: %s” , greșeală )
} altfel {
fmt.Println ( „Diviziune valabilă” )
}
}
În codul de mai sus, div funcția acceptă două intrări întregi, n1 și n2, iar dacă n2 este zero, produce o eroare. Funcția produce o eroare cu un mesaj care conține valorile lui n1 și n2 dacă n2 este zero. Funcția returnează nil pentru a arăta că nu a existat nicio eroare dacă n2 nu este zero.
Eroarea pe care o returnează div este salvată în variabila err când funcția principală rulează div cu valorile 42 și 0. Funcția principală folosește fmt.Printf pentru a afișa mesajul de eroare dacă funcția div returnează o eroare. Funcția principală se imprimă Diviziune valabilă dacă funcția div returnează zero.
Ieșire
3: Gestionarea explicită a erorilor
Go încurajează gestionarea explicită a erorilor în comparație cu alte limbaje de programare, care se bazează frecvent pe excepții. Această abordare încurajează dezvoltatorii să folosească instrucțiuni if pentru a verifica în mod explicit erorile, în loc să se bazeze pe blocurile try-catch. Procedând astfel, este mai probabil ca erorile să fie găsite și remediate în mod corespunzător. Pentru a facilita acest lucru, Go oferă daca greseste != nul declarație, care permite dezvoltatorilor să verifice erorile după executarea unei funcții și să ia măsurile adecvate în funcție de rezultat. Cu gestionarea explicită a erorilor, Go oferă o abordare mai structurată și mai fiabilă a gestionării erorilor.
pachet principalimport 'fmt'
func divide ( a, b float64 ) ( float64, eroare ) {
dacă b == 0 {
întoarcere 0 , fmt.Errorf ( 'nu se poate imparti la zero' )
}
întoarcere A / b, zero
}
func principal ( ) {
rezultat, err := divide ( 13 , 3 )
dacă a greșit ! = zero {
fmt.Printf ( „Eroare: %v \n ' , greșeală )
} altfel {
fmt.Printf ( „Rezultat: %f \n ' , rezultat )
}
rezultat, err = împărțire ( 23 , 0 )
dacă a greșit ! = zero {
fmt.Printf ( „Eroare: %v \n ' , greșeală )
} altfel {
fmt.Printf ( „Rezultat: %f \n ' , rezultat )
}
}
În această ilustrație, funcția de împărțire este utilizată pentru a împărți două valori. Rezultatul este rezultatul unei astfel de operațiuni. Dacă al doilea număr este 0, funcția produce o eroare cu un mesaj de eroare distinct.
Împărțirea este apelată de două ori în funcția principală: o dată cu intrări valide și o dată cu intrări nevalide. Cel, dacă err != nil instrucțiunea este utilizată pentru a determina dacă a avut loc o eroare de fiecare dată când este utilizată funcția de divizare. Dacă apare unul, este tipărit un mesaj de eroare. Dacă nu, rezultatul este tipărit.
Ieșire
4: Amânați, intrați în panică și recuperați-vă
Golang oferă, de asemenea, amâna instrucțiune, care este folosită pentru a executa o funcție după finalizarea unui program sau a unui anumit bloc de cod. The amâna declarația este adesea folosită împreună cu recupera funcție pentru a detecta și a recupera din erorile de panică la timpul de rulare. Când apare o eroare de panică la runtime, recupera funcția este utilizată pentru a recupera starea de eroare și pentru a preveni prăbușirea programului. Acest lucru este util pentru activități de curățare, cum ar fi închiderea fișierelor, închiderea conexiunilor de rețea sau eliberarea de resurse. Amânând aceste sarcini, vă asigurați că sunt executate chiar dacă apare o eroare.
The panică este folosit pentru a opri execuția normală a programului atunci când apare o eroare neașteptată, în timp ce recupera este folosit pentru a gestiona panica și a continua execuția programului.
pachet principalimport 'fmt'
func recoverFromPanic ( ) {
dacă r := recupera ( ) ; r ! = zero {
fmt.Println ( „Recuperat din panică:” , r )
}
}
func divide ( x,y float64 ) float64 {
amână recoverFromPanic ( )
dacă și == 0 {
panică ( 'nu se poate imparti la zero' )
}
întoarcere X / și
}
func principal ( ) {
fmt.Println ( divide ( 13 , 3 ) )
fmt.Println ( divide ( 23 , 0 ) )
}
În codul de mai sus, funcția de împărțire este utilizată pentru a împărți două valori în virgulă mobilă. Rezultatul este rezultatul unei astfel de activități. Un mesaj de eroare personalizat este transmis de funcție dacă al doilea număr este zero. Declarația defer este folosită pentru a invoca recoverFromPanic funcţie. The recoverFromPanic Funcția va detecta o panică care a avut loc în cadrul funcției de diviziune și va imprima o eroare dacă s-a întâmplat.
Împărțirea este apelată de două ori în funcția principală: o dată cu intrări valide și o dată cu intrări nevalide. The fmt.Println funcția imprimă rezultatul funcției de fiecare dată când funcția de divizare este rulată. The recoverFromPanic Funcția va detecta o panică dacă se întâmplă și va imprima o eroare dacă se întâmplă.
Ieșire
După detectarea erorii, programul a revenit din panică și a continuat să ruleze. Cu toate acestea, codul a intrat în panică și nu a returnat o valoare la al doilea apel de împărțire, motiv pentru care a returnat zero.
5: Error Wrapping
Go include, de asemenea, o caracteristică cunoscută ca Eroare la împachetare , care vă permite să adăugați context suplimentar unui mesaj de eroare. Acest lucru este util pentru înregistrarea problemelor sau pentru furnizarea de detalii suplimentare în mesajele de eroare. Acest lucru poate fi realizat prin crearea unui tip de eroare care încorporează eroarea originală și contextul suplimentar.
pachet principalimport 'erori'
import 'fmt'
func principal ( ) {
dacă err := bar ( ) ; a greșit ! = zero {
fmt.Println ( a greșit )
}
}
func divide ( a, b float64 ) ( float64, eroare ) {
dacă b == 0 {
întoarcere 0 , erori.Nou ( 'impartirea cu zero' )
}
întoarcere A / b, zero
}
bară de funcții ( ) ( eroare eroare ) {
_, err = împărți ( 42 , 0 )
dacă a greșit ! = zero {
întoarcere fmt.Erorf ( „Nu s-a putut calcula: %w” , greșeală )
}
întoarcere zero
}
În codul de mai sus, funcția de împărțire calculează raportul dintre două numere din acest exemplu și aruncă o eroare dacă a doua valoare este zero. Funcția bar apelează funcția de împărțire și apoi înfășoară eroarea care divide returnează o nouă eroare cu un mesaj care include mesajul de eroare original folosind funcția fmt.Errorf. Funcția bar este apelată de funcția principală, care afișează și eventualele erori pe care le returnează.
Ieșire
Concluzie
Dezvoltarea software trebuie să includă eroare de manipulare , iar Golang are diverse funcții și metode încorporate pentru a face acest lucru cu grație. Aceste mecanisme permit dezvoltatorilor să detecteze și să recupereze erorile, să prevină blocările programului și să furnizeze mesaje de eroare informative utilizatorilor finali. Folosind aceste mecanisme de tratare a erorilor în mod eficient, dezvoltatorii pot construi aplicații software robuste, fiabile și eficiente.