Go ist eine beliebte Programmiersprache, die aufgrund ihrer Effektivität, Geschwindigkeit und Effizienz immer beliebter wird. Allerdings können wie bei jeder anderen Programmiersprache auch in der Entwicklungs- und Ausführungsphase Fehler passieren. Um die Zuverlässigkeit und Stabilität Ihrer Go-Programme sicherzustellen, ist ein effektiver Umgang mit Fehlern unerlässlich.
In diesem Artikel werden verschiedene Methoden und empfohlene Verfahren zum Umgang mit Fehlern in Go untersucht.
Behandeln Sie Fehler in Golang
Mit Go ist das möglich mit Fehlern umgehen durch die unten genannten Methoden:
- Neue Funktion
- Errorf()-Funktion
- Explizite Fehlerbehandlung
- Aufschieben, Panik und Wiederherstellen
- Fehlerumbruch
1: New()-Funktion
Die Go-Sprache bietet die Neu() Funktion zur Fehlerverwaltung. Mit dieser Funktion, die im integrierten Fehlerpaket verfügbar ist, können Entwickler benutzerdefinierte Fehlermeldungen für ihre Programme erstellen. Durch die Nutzung der Neu() Mit dieser Funktion können Entwickler Fehler effektiv behandeln und den Benutzern aussagekräftige Fehlermeldungen bereitstellen.
Paket main
importieren „Fehler“
importieren „fmt“
Funktionsprüfung ( Namenszeichenfolge ) Fehler {
nError := Fehler.Neu ( 'Ungültiger Name' )
Wenn Name ! = „Linux“ {
zurückkehren nFehler
}
zurückkehren Null
}
Funktion main ( ) {
Name := „Linux“
ähm := prüfen ( Name )
Wenn irren ! = Null {
fmt.Println ( irren )
} anders {
fmt.Println ( 'Gültiger Name' )
}
}
Der obige Code verwendet die Neu() checkName Funktion, um zu sehen, ob die Zeichenfolge Linux entspricht dem angegebenen Namen. Die Funktion erzeugt einen Fehler mit der Nachricht Ungültiger Name wenn der Name nicht ist Linux . Die Funktion gibt Null zurück, um anzuzeigen, dass kein Fehler aufgetreten ist, wenn der Name gleich ist Linux .
Die Namensvariable ist auf gesetzt Linux im Aufruf der Hauptfunktion an die checkName Funktion, die auch die Namensvariable als Argument verwendet. Die Hauptfunktion gibt die Fehlermeldung aus, wenn die checkName Funktion gibt einen Fehler zurück. Die Hauptfunktion druckt die Gültiger Name wenn die checkName Funktion gibt Null zurück.
Ausgang
2: Errorf()-Funktion
Der Fehlerf() Mit der Funktion in Go können wir auch Fehler behandeln. Fehlerf() gibt uns die Möglichkeit, die Fehlermeldung zu formatieren. Durch den Import des fmt-Pakets können Entwickler damit Fehlermeldungen an ihre Bedürfnisse anpassen. Fehlerf() Optimiert und verbessert die Effizienz der Verwaltung und Übermittlung von Fehlern in Go.
Paket mainimportieren „fmt“
Funktion div ( n1, n2 du ) Fehler {
Wenn n2 == 0 {
zurückkehren fmt.Errorf ( „%d / %d \N Eine Zahl kann nicht durch Null geteilt werden“ , n1, n2 )
}
zurückkehren Null
}
Funktion main ( ) {
ähm := div ( 42 , 0 )
Wenn irren ! = Null {
fmt.Printf ( „Fehler: %s“ , irren )
} anders {
fmt.Println ( „Gültige Division“ )
}
}
Im obigen Code ist die div Die Funktion akzeptiert zwei ganzzahlige Eingaben, n1 und n2, und wenn n2 Null ist, erzeugt sie einen Fehler. Die Funktion erzeugt einen Fehler mit einer Meldung, die die Werte von n1 und n2 enthält, wenn n2 Null ist. Die Funktion gibt Null zurück, um zu zeigen, dass kein Fehler aufgetreten ist, wenn n2 nicht Null ist.
Der von div zurückgegebene Fehler wird in der Variablen err gespeichert, wenn die Hauptfunktion div mit den Werten 42 und 0 ausführt. Die Hauptfunktion verwendet fmt.Printf, um die Fehlermeldung anzuzeigen, wenn die div-Funktion einen Fehler zurückgibt. Die Hauptfunktion druckt Gültige Division wenn die div-Funktion Null zurückgibt.
Ausgang
3: Explizite Fehlerbehandlung
Im Vergleich zu anderen Programmiersprachen, die häufig auf Ausnahmen basieren, fördert Go ein explizites Fehlermanagement. Dieser Ansatz ermutigt Entwickler, if-Anweisungen zu verwenden, um explizit auf Fehler zu prüfen, anstatt sich auf Try-Catch-Blöcke zu verlassen. Dadurch ist es wahrscheinlicher, dass Fehler gefunden und ordnungsgemäß behoben werden. Um dies zu erleichtern, bietet Go die wenn Fehler != Null -Anweisung, die es Entwicklern ermöglicht, nach der Ausführung einer Funktion nach Fehlern zu suchen und auf der Grundlage des Ergebnisses entsprechende Maßnahmen zu ergreifen. Mit der expliziten Fehlerbehandlung bietet Go einen strukturierteren und zuverlässigeren Ansatz für das Fehlermanagement.
Paket mainimportieren „fmt“
Funktion teilen ( a, b float64 ) ( float64, Fehler ) {
Wenn b == 0 {
zurückkehren 0 , fmt.Errorf ( „Kann nicht durch Null dividieren“ )
}
zurückkehren A / b, null
}
Funktion main ( ) {
Ergebnis, Fehler := dividieren ( 13 , 3 )
Wenn irren ! = Null {
fmt.Printf ( „Fehler: %v \N ' , irren )
} anders {
fmt.Printf ( „Ergebnis: %f \N ' , Ergebnis )
}
Ergebnis, err = dividieren ( 23 , 0 )
Wenn irren ! = Null {
fmt.Printf ( „Fehler: %v \N ' , irren )
} anders {
fmt.Printf ( „Ergebnis: %f \N ' , Ergebnis )
}
}
In dieser Abbildung wird die Divisionsfunktion verwendet, um zwei Werte zu dividieren. Die Ausgabe ist das Ergebnis davon. Wenn die zweite Zahl 0 ist, erzeugt die Funktion einen Fehler mit einer eindeutigen Fehlermeldung.
Divide wird in der Hauptfunktion zweimal aufgerufen: einmal mit gültigen Eingaben und einmal mit ungültigen Eingaben. Das, wenn ähm != null Die Anweisung wird verwendet, um bei jeder Verwendung der Divisionsfunktion zu bestimmen, ob ein Fehler aufgetreten ist. Tritt eine Fehlermeldung auf, wird diese ausgegeben. Wenn nicht, wird das Ergebnis gedruckt.
Ausgang
4: Aufschieben, Panik und Wiederherstellen
Golang bietet auch die verschieben Anweisung, die verwendet wird, um eine Funktion nach Abschluss eines Programms oder eines bestimmten Codeblocks auszuführen. Der verschieben Die Anweisung wird häufig in Verbindung mit verwendet genesen Funktion zum Abfangen und Beheben von Panikfehlern zur Laufzeit. Wenn ein Laufzeit-Panikfehler auftritt, wird der genesen Die Funktion wird verwendet, um den Fehlerzustand zu beheben und einen Programmabsturz zu verhindern. Dies ist nützlich für Bereinigungsaufgaben wie das Schließen von Dateien, das Schließen von Netzwerkverbindungen oder das Freigeben von Ressourcen. Indem Sie diese Aufgaben zurückstellen, stellen Sie sicher, dass sie auch dann ausgeführt werden, wenn ein Fehler auftritt.
Der Panik wird verwendet, um die normale Ausführung des Programms zu stoppen, wenn ein unerwarteter Fehler auftritt genesen wird verwendet, um die Panik zu bewältigen und die Ausführung des Programms fortzusetzen.
Paket mainimportieren „fmt“
Funktion „recoverFromPanic“. ( ) {
Wenn r := erholen ( ) ; R ! = Null {
fmt.Println ( „Von der Panik erholt:“ , R )
}
}
Funktion teilen ( x,y float64 ) float64 {
„recoverFromPanic“ aufschieben ( )
Wenn und == 0 {
Panik ( „Kann nicht durch Null dividieren“ )
}
zurückkehren X / Und
}
Funktion main ( ) {
fmt.Println ( teilen ( 13 , 3 ) )
fmt.Println ( teilen ( 23 , 0 ) )
}
Im obigen Code wird die Divisionsfunktion verwendet, um zwei Gleitkommawerte zu dividieren. Die Ausgabe ist das Ergebnis davon. Wenn die zweite Zahl Null ist, gibt die Funktion eine benutzerdefinierte Fehlermeldung aus. Die defer-Anweisung wird verwendet, um die aufzurufen erholenFromPanic Funktion. Der erholenFromPanic Die Funktion erkennt eine Panik, die innerhalb der Divisionsfunktion aufgetreten ist, und gibt einen Fehler aus, wenn sie aufgetreten ist.
Divide wird in der Hauptfunktion zweimal aufgerufen: einmal mit gültigen Eingaben und einmal mit ungültigen Eingaben. Der fmt.Println Die Funktion gibt die Ausgabe der Funktion jedes Mal aus, wenn die Divisionsfunktion ausgeführt wird. Der erholenFromPanic Die Funktion erkennt eine Panik, wenn sie auftritt, und gibt in diesem Fall einen Fehler aus.
Ausgang
Nachdem der Fehler erkannt wurde, erholte sich das Programm von der Panik und lief weiter. Der Code geriet jedoch in Panik und gab beim zweiten Divisionsaufruf keinen Wert zurück, weshalb er Null zurückgab.
5: Fehlerumbruch
Go enthält auch eine Funktion namens Fehler beim Verpacken , wodurch Sie einer Fehlermeldung zusätzlichen Kontext hinzufügen können. Dies ist hilfreich, um Probleme aufzuzeichnen oder weitere Details in Fehlermeldungen bereitzustellen. Dies kann durch die Erstellung eines Fehlertyps erreicht werden, der den ursprünglichen Fehler und zusätzlichen Kontext einbettet.
Paket mainimportieren „Fehler“
importieren „fmt“
Funktion main ( ) {
Wenn ähm := bar ( ) ; irren ! = Null {
fmt.Println ( irren )
}
}
Funktion teilen ( a, b float64 ) ( float64, Fehler ) {
Wenn b == 0 {
zurückkehren 0 , Fehler.Neu ( 'Durch Null teilen' )
}
zurückkehren A / b, null
}
Funktionsleiste ( ) ( irr fehler ) {
_, err = dividieren ( 42 , 0 )
Wenn irren ! = Null {
zurückkehren fmt.Errorf ( „Berechnung fehlgeschlagen: %w“ , irren )
}
zurückkehren Null
}
Im obigen Code berechnet die Divisionsfunktion in diesem Beispiel das Verhältnis zweier Zahlen und gibt einen Fehler aus, wenn der zweite Wert Null ist. Die Balkenfunktion ruft die Divisionsfunktion auf und umschließt dann den Fehler teilen Gibt mit der Funktion fmt.Errorf einen neuen Fehler mit einer Meldung zurück, die die ursprüngliche Fehlermeldung enthält. Die Funktion bar wird von der Hauptfunktion aufgerufen, die auch alle zurückgegebenen Fehler ausgibt.
Ausgang
Abschluss
Die Softwareentwicklung muss umfassen Fehlerbehandlung , und Golang verfügt über verschiedene integrierte Funktionen und Methoden, um dies elegant zu tun. Mithilfe dieser Mechanismen können Entwickler Fehler erkennen und beheben, Programmabstürze verhindern und Endbenutzern informative Fehlermeldungen bereitstellen. Durch die effektive Nutzung dieser Fehlerbehandlungsmechanismen können Entwickler robuste, zuverlässige und effiziente Softwareanwendungen erstellen.