So gehen Sie in Golang elegant mit Fehlern um

In den letzten Jahren hat sich Golang aufgrund seiner vielen hervorragenden Funktionen und seiner perfekten Leistung zu einer der beliebtesten Programmiersprachen entwickelt. Unabhängig davon, ob Sie Golang für die Webentwicklung oder andere Bereiche verwenden, ist das Fehlermanagement immer noch ein unvermeidbares Problem. Wie geht man in Golang elegant mit Fehlern um? Welche Erfahrungen und Anregungen gibt es?

1. Fehlerklassifizierung
In Golang werden Fehler in den Fehlertyp eingeordnet. Der Typ „Error“ ist so definiert, dass er nur eine Error-Methode enthält, die eine Zeichenfolge zurückgibt. Wenn ein Fehler auftritt, wird normalerweise ein neuer Fehlertyp erstellt. In Golang können Sie das integrierte Fehlerpaket oder benutzerdefinierte Fehler verwenden, um Fehlermeldungen darzustellen.

Im Allgemeinen können Fehler in Golang in die folgenden drei Kategorien unterteilt werden:

1 Vordefinierte Fehler
Vordefinierte Fehler sind integrierte Fehlertypen, die normalerweise zur Darstellung von Fehlern auf Systemebene in Golang verwendet werden. Beispielsweise treten beim Lesen von Dateien Fehler wie EOF auf. Die meisten dieser Fehler können mithilfe der integrierten Fehlerfunktionen behandelt werden.

2. Benutzerdefinierte Fehler
Benutzerdefinierte Fehler werden von Programmierern selbst beim Schreiben von Code entworfen und können bestimmte Arten von Fehlern erzeugen. Zum Beispiel Fehler wie ein JSON-Parsing-Fehler. Für diesen Fehlertyp muss der Programmierer den Fehlertyp selbst definieren und beim Aufruf der Funktion zurückgeben.

3. Laufzeitfehler
Laufzeitfehler sind Fehler, auf die der Golang-Interpreter beim Ausführen eines Programms stößt. Zum Beispiel Fehler bei der Division durch 0 usw. Diese Fehler werden normalerweise durch Fehler auf Systemebene verursacht und können nicht vorhergesagt werden. Daher müssen Programmierer auf die Behandlung solcher Fehler achten.

2. Gos Fehlerbehandlungsmethoden
In Golang werden normalerweise die folgenden zwei Methoden zur Fehlerbehandlung verwendet:

1. Rückgabewertverarbeitung
In Golang werden normalerweise Fehlerinformationen im Rückgabewert verwendet. Vor einem Funktionsaufruf wird häufig überprüft, ob der Rückgabewert anderer Funktionsaufrufe vom falschen Typ ist. Wenn ja, wird der aktuelle Funktionsaufruf beendet und der Fehler an den Aufrufer zurückgegeben.

Der folgende Code behandelt beispielsweise Fehler beim Lesen der Datei Greeting.txt. Die Funktion readGreeting gibt den Fehler err zurück. Wenn ein Fehler auftritt, gibt die Funktion einen Nullwert und den Fehlertyp err zurück.

func greet() error {
    contents, err := readGreeting("greeting.txt")
    if err != nil {
        return err
    }
    fmt.Printf("Greetings: %s\n", contents)
    return nil
}

func readGreeting(filename string) (string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer file.Close()

    reader := bufio.NewReader(file)
    greeting, err := reader.ReadString('\n')
    if err != nil {
        return "", err
    }

    return greeting, nil
}

2, Panik und Erholung
Eine andere Möglichkeit, mit Fehlern in Golang umzugehen, ist die Verwendung von Panik und Erholung. Wenn ein Fehler auftritt und nicht erkannt wird, führt dies zum Absturz des Programms. Wenn ein Programmierer jedoch Panic innerhalb einer Funktion verwendet, bedeutet dies, dass ein Fehler aufgetreten ist. Diese Panikinformationen werden nach außen weitergeleitet, bis sie von Recovery erfasst werden.

Das folgende Codebeispiel implementiert beispielsweise ein einfaches Beispiel für Datenbankverbindung und -zugriff sowie für den Umgang mit Fehlersituationen.

func main() {
    conn := openConnection("localhost", "mydb")
    defer closeConnection(conn)

    if err := insertData(conn, "test"); err != nil {
        log.Fatal(err)
    }
}

func openConnection(ip, dbname string) *DB {
    conn, err := openDB(ip, dbname)
    if err != nil {
        panic(err)
    }
    return conn
}

func insertData(db *DB, data string) error {
    if db == nil {
        panic("No database connection!")
    }
    _, err := db.Exec("INSERT INTO data VALUES (?)", data)
    return err
}

func closeConnection(db *DB) {
    if db == nil {
        panic("No database connection!")
    }
    db.Close()
}

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

3. Einige Vorschläge
In Golang muss die Fehlerbehandlung von den Programmierern selbst durchgeführt werden. Einige Erfahrungen und Vorschläge können Programmierern jedoch helfen, besser mit Fehlern umzugehen:

1 Bei Fehlern auf Systemebene können Sie die Verwendung der integrierten Fehlertypen oder des Fehlerpakets in Betracht ziehen, die leicht zu verstehen und zu verwenden sind.

2. Für benutzerdefinierte Fehler können Sie die Fehlertypen selbst im Programm definieren und diese Fehler mit Funktionen zurückgeben, die die erforderlichen Parameter enthalten.

3. Durch die Verwendung des Schlüsselworts „defer“ können Sie sicherstellen, dass Sie die Ressourcen trotzdem korrekt bereinigen können, wenn Sie beim Schreiben von Code vergessen, sie zu bereinigen.

4. Seien Sie vorsichtig, wenn Sie Panic und Recovery in Programmen verwenden, und versuchen Sie, sie in Programmen zu vermeiden.

Kurz gesagt, die Fehlerbehandlung ist in Golang immer noch ein Problem, das Aufmerksamkeit erfordert. Eine korrekte Fehlerbehandlung kann Programmierern helfen, mit verschiedenen im Programm auftretenden Fehlern umzugehen und die Zuverlässigkeit und Robustheit des Programms zu verbessern.

Das obige ist der detaillierte Inhalt vonSo gehen Sie in Golang elegant mit Fehlern um. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!