Grundlagen der Fehlerbehandlung in Golang

Eine der nützlichsten Eigenschaften der Programmiersprache Go ist die Art und Weise, wie sie Fehler behandelt. Anstatt wie andere Programmiersprachen eine Try/Catch-Methodik zu verwenden, behandelt Go Fehler als normale Rückgabewerte.

Durch die Erstellung einfacher Module und die Anwendung einiger Protokollierungsregeln können wir nützliche Fehlermeldungen erzeugen, um alle Arten von Ausnahmen während des Entwicklungsprozesses abzufangen.

In diesem Artikel werden wir einige der grundlegendsten Möglichkeiten behandeln, wie Golang diese Ausnahmen findet und behandelt.

Golang Grundlegende Fehlerbehandlung

Wir können Fehler in Go abfangen, indem wir einfache if/then-Anweisungen verwenden, die auf Bedingungen prüfen, bei denen erforderliche Parameter nicht erfüllt sind.

Lassen Sie uns einen Blick auf ein grundlegendes Modul werfen, das wir erstellen können, um zu prüfen, ob ein String einen Wert enthält oder nicht.

Erstellen Sie ein Paket mit dem Namen „hello“ und importieren Sie die Standardmodule „errors“ und „fmt“, um Fehler und formatierten Text zu erkennen:

package helloimport ("errors""fmt")

Dann können wir ein Modul erstellen, das eine Textzeichenfolge für eine benannte Variable zurückgibt.

func Hello(name string) (string, error) {if name == "" {return "", errors.New("No name was given")}

Das obige Modul prüft, ob eine leere Zeichenkette für die Variable „name“ zurückgegeben wird, die dann einen neuen Fehler mit einem bestimmten Text zurückgibt. Dies ist unsere Fehlerbedingung. Eine Fehlerbedingung prüft, ob der Fehler selbst existiert.
Ist die Bedingung nicht erfüllt (d.h. es liegt kein Fehler vor), geben wir den Wert zurück, der mit der angegebenen „name“-Variablen übereinstimmt:

message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil}

Beachten Sie, dass die Meldung und der Wert „nil“ zurückgegeben werden, was bedeutet, dass es keinen Fehler gibt. Dies teilt dem aufrufenden Programm mit, dass die Funktion ohne Fehler verarbeitet wurde.

Nun werden wir uns ansehen, wie wir dieses Paket in einem tatsächlichen Skript aufrufen können.

Erstellen wir ein neues Skript mit dem Namen test.go

Wie bei Golang üblich, muss ein Skript mit der Definition des Pakets „main“ beginnen. Dann importieren wir die Pakete „fmt“ und „log“ zusammen mit dem von uns erstellten Paket „hello“, wie unten gezeigt:

package mainimport ("fmt""log""yoursite.com/hello")

Nachfolgend definieren wir unsere Hauptfunktion, setzen ein paar Eigenschaften für unseren Logger, um ein leicht verständliches Präfix zu erstellen, und (aus Sicherheitsgründen) erstellen ein Flag, damit wir die Zeit, die Quelldatei und die Zeilennummer nicht anzeigen.

func main() {log.SetPrefix("Hello: ")log.SetFlags(0)

Als nächstes geben wir eine Meldung an, die angezeigt werden soll:

message, err := hello.Hello("")

Schließlich prüfen wir, ob ein Fehler vorliegt, indem wir überprüfen, ob „err“ ungleich „nil“ ist. Wenn dies der Fall ist, geben wir die Meldung auf der Konsole aus und beenden uns.

if err != nil {log.Fatal(err)}

Wenn kein Fehler vorliegt, geben wir einfach die Meldung aus, die in unserem Hallo-Paket definiert wurde.

fmt.Println(message)}

Um dies zu testen, können wir den Code so ausführen, wie er ist. Wenn wir das tun, sollten wir ein Ergebnis erhalten, das wie folgt aussieht:

>go run test.gogreetings: No name was givenexit status 1

Wenn wir unser test.go Skript ändern wollen, geben wir etwas wie das folgende ein:

message, err := hello.Hello("John")

Unsere Ausgabe sollte dann so aussehen:

>go run test.goHi, John. Welcome!

Eine andere Art von Fehlermeldung, die wir zurückgeben können, ist:

fmt.Errorf – dies formatiert eine Zeichenkette nach den Regeln von Printf.

Handling von Integers in Golang

Natürlich sind String-Fehler nur eine Art von Fehler. Mit der Golang-Fehlerbehandlung gibt es mehrere andere Fehler, auf die Sie in Ihrem Code prüfen können. Eine davon ist der numerische Fehler, über den Sie Bescheid wissen sollten.

Der Umgang mit ganzen Zahlen ist für Go einfach. So funktioniert es:

Angenommen, wir haben numerische Fehler, z. B. wenn wir durch Null dividieren müssen. Zuerst erstellen wir eine Funktion „Division“, die zwei Variablen x durch y dividiert. Für den ersten Teil unserer if/then-Bedingung müssen wir sicherstellen, dass y nicht gleich Null ist:

func Division(x int, y int) (int, error) {if y == 0 {return 0, errors.New("Thou shalt not divide by zero!")} else {return (x / y), nil}}

Dies ist die Hauptfunktion. Jetzt können Sie ihr zwei Variablen übergeben. In diesem Beispiel verwenden wir 12 und 0.

func main() {if result, err := Division(12, 0); err != nil {fmt.Println("We got an error: ", err)} else {fmt.Println("The answer is", result)}}

Dann erhältst du eine Meldung, die ungefähr so lautet:

„Wir haben einen Fehler: Thou shalt not divide by zero!“

Dies ist nur ein Beispiel dafür, wie man die Golang-Fehlerbehandlung nutzen kann, um numerische Fehler zu finden. Mit den richtigen Funktionen kann man mit Golang mehrere Fehler selbst finden.

HTTP-Statusfehler finden

Mit Golang kann man HTTP-Statusfehler ausgeben, wenn eine API, die man aufruft, einen liefert.

So geht’s:

Zunächst importieren wir ein neues Paket, „net/http“:

import ( "fmt" "log" "net/http")

In unserer Hauptfunktion rufen wir eine App (z.B. eine Website) auf und protokollieren alle Fehler. Da wir wissen, dass erfolgreiche Anfragen in den 2xx-Bereich fallen, erstellen wir einen entsprechenden Status, der alle HTTP-Fehler findet, die nicht in diesen Bereich fallen. Sie können dies auf folgende Weise tun:

func main() { resp, err := http.Get("https://example.com") if err != nil { log.Fatal(err) } fmt.Println("HTTP Response Status:", resp.StatusCode, http.StatusText(resp.StatusCode)) if resp.StatusCode >= 200 && resp.StatusCode 

Wie Sie sehen, ist unsere Hauptfunktion auf

>= 200 && resp.StatusCode <= 299

gestellt, die prüft, ob eine HTTP-Anfrage in den 2xx-Bereich fällt. Wenn die Anfrage diese Bedingung nicht erfüllt, wird eine Fehlermeldung angezeigt.

Mit nur einem Modul können Sie schnell alle Informationen sammeln, die Sie benötigen, um Ihren Golang-Code zu finden und zu korrigieren.

Zusammenfassung

Dieser Leitfaden kratzt nur an der Oberfläche, wie die Sprache Go mit Fehlern umgeht. Grundlagen wie die Prüfung auf das Vorhandensein einer Zeichenkette, die Auslösung einer Fehlerbedingung bei unlogischen numerischen Anweisungen und die Prüfung der HTTP-Statuscodes einer Antwort sind jedoch ein guter Anfang für die Golang-Fehlerüberwachung.

Sind Sie nicht in der Lage, diese Golang-Fehlerbehandlungstechniken manuell zu prüfen und anzuwenden? Hier kommen Tools wie Airbrake Error Monitoring ins Spiel. Mit Airbrake Error Monitoring können Sie Fehler schnell finden, ohne dass Sie einzelne Module erstellen müssen. Testen Sie Airbrake Error Monitoring 30 Tage lang kostenlos für eine unbegrenzte Anzahl von Fehlern und Leistungsereignissen.