So verwenden Sie die Schlüsselwörter „defer“ und „recover“ in der Golang-Funktion zusammen

Golang ist eine effiziente, prägnante und leicht zu erlernende Programmiersprache, die ursprünglich von Google entwickelt und erstmals 2009 veröffentlicht wurde. Es wurde entwickelt, um die Produktivität von Programmierern und die Klarheit des Codes zu verbessern. In Golang werden die Funktionsschlüsselwörter „defer“ und „recover“ oft zusammen verwendet, um Fehler zu behandeln, die im Programm auftreten können. In diesem Artikel wird die Verwendung dieser beiden Schlüsselwörter vorgestellt und ihre praktische Anwendung anhand einiger Beispiele veranschaulicht.

1. Verwendung von defer

defer ist ein Schlüsselwort, das verwendet wird, um die Ausführung eines bestimmten Codes nach der Ausführung der Funktion zu verzögern. Verzögerte Ausführung bedeutet, dass diese Codes einem Stapel hinzugefügt und nacheinander ausgeführt werden, bevor die Funktion zurückkehrt.

Die Syntax der Defer-Anweisung lautet wie folgt:

Defer-Funktionsname(Argument)

wobei Funktionsname der Name der Funktion ist, die verzögert werden muss, und Argument eine optionale Parameterliste ist. Wenn die Ausführung der Funktion abgeschlossen ist und die Return-Anweisung ausgeführt wird, werden alle Defer-Anweisungen nacheinander ausgeführt.

Das Folgende ist ein Beispielprogramm, das die spezifische Verwendung der Defer-Anweisung demonstriert:

package main

import "fmt"

func main() {
    defer fmt.Println("Hello")
    fmt.Println("World")
}

Dieses Programm gibt „World
Hello“ aus, da das Programm nach der Ausführung von fmt.Println(„World“) die Defer-Anweisung ausführt und füge es dem Stapel hinzu. Wenn die Funktion main() zurückkehrt, wird der Stapel nacheinander geöffnet und als letztes wird die print-Anweisung in der defer-Anweisung ausgeführt.

2. So verwenden Sie die Wiederherstellung

Wenn das Programm auf einen Fehler stößt, stoppt es die Ausführung und wird beendet. In einigen Fällen möchten wir jedoch möglicherweise, dass das Programm weiterhin ausgeführt wird und Fehler behandelt. In Golang können wir dazu das Schlüsselwort „recover“ verwenden.

recover ist eine integrierte Funktion, die nur in Defer-Anweisungen verwendet wird und zur Wiederherstellung nach einer Panik verwendet wird. Wenn ein Programm in Panik gerät, stoppt es die Ausführung zwangsweise und setzt die Programmausführung fort, indem es die Wiederherstellungsfunktion in der Defer-Anweisung aufruft.

Das Folgende ist ein Beispielprogramm, das die spezifische Verwendung der Recovery-Anweisung demonstriert:

package main

import (
    "fmt"
    "os"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    fmt.Println("Start")
    panic("Something wrong")
    fmt.Println("End")
    os.Exit(0)
}

In diesem Programm verwenden wir die Recovery-Funktion in der Defer-Anweisung der main()-Funktion. Die anonyme Funktion in der Defer-Anweisung bestimmt, ob eine Panik auftritt, gibt relevante Informationen aus und setzt die Programmausführung fort, wenn eine Panik auftritt.

Beim Ausführen dieses Programms sehen wir zuerst die Ausgabe „Start“, dann löst das Programm eine Panik aus, der Kontrollfluss der Ausführung wird unterbrochen und die Druckanweisung wird nicht ausgeführt. Da wir jedoch die Wiederherstellungsfunktion verwenden, um die Ausführung des Programms fortzusetzen, wird „Wiederhergestellt: Etwas stimmt nicht“ ausgegeben, bevor das Programm beendet wird.

3. Kombinierte Verwendung von „Aufschieben“ und „Wiederherstellen“

Bei der tatsächlichen Programmierung werden „Aufschieben“ und „Wiederherstellen“ normalerweise zusammen verwendet. Wenn ein Programm beispielsweise ein Rollback durchführen muss, wenn eine Operation fehlschlägt, können wir vor dem Start der Operation eine Transaktion erstellen und die Transaktion nach Abschluss der Operation festschreiben. Wenn die Operation jedoch fehlschlägt, können wir die Defer-Anweisung verwenden, um die Operation zurückzusetzen. Wenn gleichzeitig ein ungewöhnlicher Fehler auftritt, können wir die Wiederherstellungsfunktion verwenden, um die Ausführung des Programms fortzusetzen und bestimmte Vorgänge auszuführen.

Das Folgende ist ein Beispielprogramm für Datenbankoperationen, das zeigt, wie Aufschieben und Wiederherstellen zusammen verwendet werden:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "username:password@tcp(host:port)/database")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    tx, err := db.Begin()
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Transaction Rollback:", r)
            tx.Rollback()
        }
    }()
    _, err = tx.Exec("INSERT INTO users(name) VALUES (?)", "Alice")
    if err != nil {
        panic(err)
    }
    _, err = tx.Exec("INSERT INTO users(name) VALUE (?)", "Bob")
    if err != nil {
        panic(err)
    }
    err = tx.Commit()
    if err != nil {
        panic(err)
    }
}

In diesem Programm öffnen wir die Datenbankverbindung und erstellen eine Transaktion, bevor die Operation beginnt. Wenn während der Programmausführung ein ungewöhnlicher Fehler auftritt, wird eine Panik ausgelöst und der Programmkontrollfluss wechselt sofort zur Ausführung der Defer-Anweisung in der anonymen Funktion. In dieser Anweisung verwenden wir die Wiederherstellungsfunktion, um die normale Ausführung des Programms wiederherzustellen und ein Transaktions-Rollback durchzuführen.

Wenn die Programmausführung erfolgreich ist, wird die Transaktion festgeschrieben und die Datenbankverbindung geschlossen. Wenn ein ungewöhnlicher Fehler auftritt, wird die Transaktion nach dem Drucken der Fehlermeldung zurückgesetzt, die Datenbankverbindung wird geschlossen und das Programm wird beendet.

4. Zusammenfassung: Aufschieben und Wiederherstellen sind wichtige Schlüsselwörter in Golang. Sie werden häufig zur Behandlung von Ausnahmefehlern verwendet, die in Programmen auftreten. Wir können das Schlüsselwort defer verwenden, um die Ausführung von Code zu verzögern, der nach Ausführung der Funktion eine spezielle Verarbeitung erfordert. Wenn im Programm ein ungewöhnlicher Fehler auftritt, können wir das Schlüsselwort „recover“ verwenden, um die Ausführung des Programms fortzusetzen und den Fehler zu beheben. In der tatsächlichen Programmierung können wir diese beiden Schlüsselwörter in Kombination verwenden, um abnormale Situationen zu bewältigen, die im Programm auftreten können, und um die Stabilität und Zuverlässigkeit des Programms sicherzustellen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Schlüsselwörter „defer“ und „recover“ in der Golang-Funktion zusammen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!