Die Fehlerbehandlung ist eine der häufigsten Operationen im Softwareentwicklungszyklus. Es ist ein entscheidender Aspekt guter Programmierung. Go verfolgt mit seinem integrierten Mechanismus zur Fehlerbehandlung einen einfachen und benutzerfreundlichen Ansatz. Es basiert auf der Rückgabe von Fehlern von Funktionen und Methoden, sodass Sie sich auf intuitive und leicht lesbare Codefunktionen konzentrieren können.
Sie behandeln Fehler in Go explizit, was zu einem soliden Framework für Feedback führt, mit der Möglichkeit, Wiederholungslogik konsistent zu implementieren. Der Fehler Paket bietet zusätzliche Funktionalität für die Fehlerbehandlung.
Das Fehlerpaket
Das Fehlerpaket ist eines der Pakete in der Standardbibliothek von Go. Das Paket bietet einfache Grundelemente zur Fehlerbehandlung und Funktionen zum konsistenten Erstellen und Manipulieren von Fehlern im gesamten Go-Code.
Das Paket bietet die Neu Funktion zum Erstellen von Fehlern mit benutzerdefinierten Fehlermeldungen, die Sie auf die gleiche Weise wie jeden integrierten Fehlertyp verwenden können, z Null Und Fehler Methode der Fehler Schnittstelle.
Der Fehler Das Paket bietet auch Funktionen zum Ein- und Auspacken von Fehlern, eine Methode für Typzusicherungen bei Fehlern.
Sie können die importieren Fehler Paket mit dem Schlüsselwort import. Geben Sie einfach den Namen des Pakets in Ihrer Importliste an.
importieren"Fehler"
Abfangen und Behandeln von Fehlern in Go
Kenntnisse der grundlegenden Fehlerbehandlung in Go legen den Grundstein für das Verständnis der Fehler Paket. Funktionen und Methoden geben Fehler zurück, die von einer Ressource begleitet werden.
Hier ist ein Beispiel für die Fehlerbehandlung bei einer Dateiöffnungsoperation mit der integrierten os Paket.
Paket hauptsächlichimportieren (
"fmt"
"os"
)Funkhauptsächlich() {
Datei, err := os. Offen("Dateiname.txt")Wenn äh != Null {
fmt. Println (err)
}
// ...
}
Der Offen Methode der os Paket ist nützlich, wenn Arbeiten mit Textdateien in Go. Es öffnet eine Datei und gibt eine offene Dateiinstanz und eine zurück Fehler.
Der Fehlerwert könnte der sein Null Typ, der keine Fehler anzeigt. Sie können jedoch nach einem Nicht-Null-Fall suchen und einen Fehler behandeln, wenn er vorhanden ist. Im obigen Fall gibt der if-Block den Fehler aus.
Sie können auf die zugreifen Fehler Methode eines Fehlers, um weitere Informationen über den Fehler (normalerweise eine Beschreibung) zu extrahieren.
Wenn äh != Null {
fmt. Println (err. Fehler())
}
Wenn die Datei beispielsweise nicht existiert, sehen Sie eine Fehlermeldung, die etwa so aussieht:
Erstellen von Fehlern in Go
Sie können Fehler mit erstellen Neu Methode der Fehler Paket. Diese Methode nimmt eine Zeichenfolgennachricht entgegen und gibt aufgetretene Fehler zurück.
importieren"Fehler"Funkhauptsächlich() {
err := Fehler. Neu("etwas ist schief gelaufen")
Wenn äh != Null {
// Fehlerbehandlungscode kommt hierher
}
}
Der hauptsächlich Funktion erstellt einen neuen Fehler und behandelt mögliche Fehler aus der Fehlererzeugung mit einer Wenn Stellungnahme.
Sie können in Go auch benutzerdefinierte Fehler definieren. Das herkömmliche Verfahren verwendet eine Struktur und eine Fehlerfunktion, um die Struktur basierend auf der Funktionalität des Fehlers zu implementieren.
Paket hauptsächlichimportieren"fmt"
Typ benutzerdefinierter Fehler Struktur {
die Info Schnur
}Funkhauptsächlich() {
// Beispiel-Instanziierung der Struktur
err := customError{
die Info: "Etwas ist schief gelaufen!",
}
// Instanz der Struktur ausgeben
fmt. Println (err)
}
Der benutzerdefinierter Fehler struct ist die Blaupause für den Fehler, und die die Info Das Zeichenfolgenfeld enthält die Fehlermeldung.
Ihre Fehlerfunktionen können die implementieren benutzerdefinierter Fehler struct und gibt eine Fehlerzeichenfolge zurück.
Funk(ce customError)Fehler()Schnur {
zurückkehren fmt. Sprintf("Ein benutzerdefinierter Fehler ist aufgetreten: %v", ce.info)
}
Der Fehler Methode der benutzerdefinierter Fehler struct gibt eine Zeichenkette mit zurück die Sprintf-Formatierungsmethode des fmt-Pakets.
Wrapping- und Unwrapping-Fehler in Go
Sie können Fehlern weitere Kontextinformationen hinzufügen, indem Sie sie umschließen. Sie werden in erster Linie umschlossene Fehler verwenden, um klare Fehlermeldungen für ein präzises Debugging zu erstellen.
Du kannst den... benutzen Fehlerf Methode der fmt Paket, das Funktionen zum Formatieren von Fehlermeldungen zum Umschließen von Fehlern bereitstellt. Der Fehlerf Die Methode nimmt eine Zeichenfolge und ein Verb zur Zeichenfolgenformatierung sowie den Fehler auf und gibt den umschlossenen Fehler zurück.
importieren (
"fmt"
"os"
)Funkhauptsächlich() {
_, äh := os. Offen("Dateiname.txt")
Wenn äh != Null {
wrapErr := fmt. Fehlerf("Fehler beim Öffnen der Datei: %v", irren)
fmt. Println (wrappedErr)
}
}
Der hauptsächlich Funktion öffnet eine Datei mit der os Pakete Offen -Methode und umschließt den Fehler mit der Errorf-Methode der fmt Paket. Anschließend wird der umschlossene Fehler an die Konsole ausgegeben.
Mit dem können Sie umschlossene Fehler in Ihren Programmen auspacken Auspacken Methode der Fehler Paket. Der Auspacken -Methode übernimmt den umschlossenen Fehler und gibt den ausgepackten Fehler zurück.
importieren (
"fmt"
"os"
"Fehler"
)Funkhauptsächlich() {
_, äh := os. Offen("Dateiname.txt")
Wenn äh != Null {
wrapErr := fmt. Fehlerf("Fehler beim Öffnen der Datei: %v", irren)
unwrappedErr := Fehler. Auspacken (wrappedErr)
fmt. Println (unwrappedErr)
}
}
Der hauptsächlich -Funktion umschließt einen Fehler beim Öffnen einer Datei, und die ausgepacktErr Variable enthält den ausgepackten Fehler.
Protokollieren Sie Ihre Fehlerberichte mit diesen Protokollierungspaketen von Drittanbietern
Sie müssen einige Fehler für spätere Überprüfungen, Debugging und andere Vorgänge während Ihres Anwendungsentwicklungsprozesses protokollieren. Du kannst den... benutzen zappen Paket von Uber, Logrus, Zerolog und Log15-Pakete für eine schnelle, strukturierte Protokollierung.
