Benutzerdefinierte Fehler in Go (Benutzerdefinierter Fehler)

Benutzerdefinierte Fehler In Go Benutzerdefinierter Fehler



Auch wenn Fehlermeldungen in der Entwicklung vielleicht nicht besonders verlockend oder motivierend sind, spielen sie doch eine entscheidende Rolle bei der Festlegung der nächsten Vorgehensweise und, was noch wichtiger ist, bei der Verhinderung eines vorzeitigen Abbruchs der Programme.

In Go, wie in allen anderen Programmiersprachen auch, stellen Fehler einen Mechanismus zur Antizipation und Bewältigung potenziell unerwarteter Situationen dar und bieten dem Benutzer gleichzeitig hilfreiches und aussagekräftiges Feedback.







Glücklicherweise haben wir in Go Zugriff auf eine Fülle von Tools und Funktionen für eine effektive Fehlerbehandlung. Es kann jedoch vorkommen, dass die integrierten Fehlermeldungen und Funktionen nicht Ihren tatsächlichen App-Anforderungen entsprechen.



Hier kommen benutzerdefinierte Fehler ins Spiel. Wie der Name schon sagt, ermöglichen uns benutzerdefinierte Fehler, präzise und spezifische Informationen für Fehlermeldungen zu definieren, die zur Anwendung passen.



In diesem Tutorial führen wir Sie durch den Prozess der Einrichtung der benutzerdefinierten Fehler in Go, erklären, warum Sie sie möglicherweise benötigen, und entdecken nebenbei Beispiele für die Arbeit mit benutzerdefinierten Fehlern.





Grundlagen der Fehlerbehandlung

Bevor wir uns daran machen, zu lernen, wie man benutzerdefinierte Fehler in Go erstellt und verwendet, sollten wir uns mit den Grundlagen der Fehlerbehandlung in Golang vertraut machen.

Go präsentiert Fehler über die Fehlerschnittstelle. Die Fehlerschnittstelle verfügt über eine einzige Methode namens Error() string. Jeder Typ, der diese Methode implementiert, ermöglicht es Go, sie als Fehler zu behandeln.



Schauen Sie sich hier den folgenden Beispielcode an:

Paket main
importieren (
„Fehler“
„fmt“
)

Funktion teilen ( a, b int ) ( im Terror ) {
Wenn b == 0 {
zurückkehren 0 , Fehler.Neu ( 'Durch Null teilen' )
}
zurückkehren A / b, null
}
Funktion main ( ) {
Ergebnis, Fehler := dividieren ( 10 , 0 )
Wenn irren ! = Null {
fmt.Println ( 'Fehler:' , irren )
zurückkehren
}
fmt.Println ( 'Ergebnis:' , Ergebnis )
}

Im gegebenen Beispiel verwenden wir die Funktion „errors.New()“, die es uns ermöglicht, einen neuen Fehler mit einer beschreibenden Meldung zu erstellen, wenn wir versuchen, durch Null zu dividieren.

Benutzerdefinierte Golang-Fehler

Wie der Name schon sagt, handelt es sich bei benutzerdefinierten Fehlern grundsätzlich um benutzerdefinierte Fehlertypen, die die Fehlerschnittstelle implementieren. Die Rolle benutzerdefinierter Fehler besteht darin, uns die Erstellung der Fehlerobjekte mit benutzerdefinierten Feldern und Verhaltensweisen zu ermöglichen. Dies trägt dazu bei, der Fehlermeldung mehr Kontext und Spezifität zu verleihen und so die Fehlerbehandlung zu verbessern.

Verwendung benutzerdefinierter Fehler

Sie fragen sich vielleicht, warum Sie die benutzerdefinierten Fehlertypen benötigen, während Sie die grundlegenden Protokollierungstechniken mithilfe der integrierten Funktionen verwenden können.

Während die integrierten Fehlertypen für eine Vielzahl von Fällen mehr als ausreichend sind, bieten benutzerdefinierte Fehlertypen mehrere Vorteile, wie zum Beispiel:

  1. Expliziter Kontext – Benutzerdefinierte Fehler bieten eine zusätzliche Kontextebene zum Fehler, die das Verstehen und Debuggen erleichtert. Zu den zusätzlichen Informationen zu benutzerdefinierten Fehlern gehören die Funktion, bei der der Fehler aufgetreten ist, alle damit verbundenen relevanten Daten und mehr.
  2. Typensicherheit – Da benutzerdefinierte Fehler selbst Typen sind, ermöglichen sie uns, die Methoden für sie zu definieren, was uns die Erstellung einer strukturierten und typsicheren Fehlerbehandlungslogik ermöglicht.
  3. Kapselung – Benutzerdefinierte Fehler ermöglichen es uns, bestimmte Domänenregeln zu kapseln, was zu einem saubereren Code führen kann.

Erstellen Sie die benutzerdefinierten Fehlertypen

Um die benutzerdefinierten Fehler in Go zu erstellen, müssen wir grundsätzlich unsere eigenen benutzerdefinierten Fehlertypen definieren, die die Fehlerschnittstelle implementieren.

Das Folgende zeigt eine Grundstruktur zum Definieren eines benutzerdefinierten Fehlers in Go:

Typ CustomError-Struktur {
Nachrichtenzeichenfolge
Code int
}
Funktion ( Es ist * Benutzerdefinierter Fehler ) Fehler ( ) Zeichenfolge {
zurückkehren e.Msg
}

Im angegebenen Beispielcode definieren wir einen benutzerdefinierten Fehlertyp namens „CustomError“ mit den Feldern für die „Msg“-Nachricht und dem „Code“-Fehlercode als Ganzzahl.

Anschließend implementieren wir die Methode Error() auf „CustomError“, die die Fehlermeldung zurückgibt.

Schließlich können wir mit diesem Fehlertyp einen benutzerdefinierten Fehler erstellen, wie im folgenden Beispiel gezeigt:

Arbeit Arbeit ( ) Fehler {
zurückkehren & Benutzerdefinierter Fehler { Nachricht: 'Etwas ist schief gelaufen' , Code: 42 }
}

Verwenden Sie die benutzerdefinierten Fehler in Go

Sobald wir die benutzerdefinierten Fehler erstellt haben, können wir sie wie jeden anderen integrierten Fehler im Code verwenden.

Das folgende Beispiel zeigt, wie Sie den „CustomError“ verwenden, den wir im vorherigen Schritt definiert haben:

Funktion main ( ) {
err := func ( )
Wenn irren ! = Null {
Wenn ähm, ok := ähm. ( * Benutzerdefinierter Fehler ) ; OK {
fmt.Printf ( „Benutzerdefinierter Fehler: %s (Code: %d) \N ' , err.Msg, err.Code )
} anders {
fmt.Println ( 'Allgemeiner Fehler:' , irren )
}
} anders {
fmt.Println ( „Es ist kein Fehler aufgetreten.“ )
}
}

Im gegebenen Beispiel rufen wir eine Funktion namens „func“ auf und prüfen, ob sie einen Fehler zurückgibt. Wenn dies der Fall ist, verwenden wir die Golang-Typ-Assertion, um zu prüfen, ob es sich um den Typ „CustomError“ handelt. Wenn es wahr ist, greifen wir auf die benutzerdefinierten Felder „Msg“ und „Code“ zu.

Abschluss

In diesem Tutorial haben wir Ihnen alles beigebracht, was Sie über benutzerdefinierte Fehler in Go wissen müssen. Wir haben etwas über die Fehlerschnittstelle und die Methode Error() gelernt, wie man sie implementiert, wie man die benutzerdefinierten Fehlertypen erstellt und wie man die benutzerdefinierten Fehlertypen verwendet.