Panic, Defer und Recover

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy — Lektion 57 von 107.

Während Go die Rückgabe von Fehlern betont, sind manche Situationen wirklich nicht behebbar. Für diese Fälle bietet Go panic, defer und recover – einen Mechanismus zur Behandlung außergewöhnlicher Umstände.

panic stoppt die normale Ausführung sofort. Es ist für Programmierfehler reserviert, wie den Zugriff auf einen Index außerhalb des gültigen Bereichs, nicht für erwartete Fehler wie ungültige Benutzereingaben:

func MustGetConfig(key string) string {
    value, exists := config[key]
    if !exists {
        panic("missing required config: " + key)
    }
    return value
}

defer plant die Ausführung einer Funktion für den Zeitpunkt, an dem die umgebende Funktion zurückkehrt – sei es regulär oder aufgrund eines Panics. Verzögerte Aufrufe werden in umgekehrter Reihenfolge ausgeführt (Last-In, First-Out):

func ProcessFile() {
    fmt.Println("Opening file")
    defer fmt.Println("Closing file")
    fmt.Println("Processing...")
    // Ausgabe: Opening file, Processing..., Closing file
}

recover fängt eine Panic ab und kehrt zur normalen Ausführung zurück. Es funktioniert nur innerhalb einer deferred-Funktion:

func SafeOperation() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    
    riskyOperation()
    return nil
}

Dieses Muster wandelt ein Panic in einen regulären Fehler um, sodass Ihr Programm fortgesetzt werden kann. Verwenden Sie es sparsam – bevorzugen Sie die Rückgabe von Fehlern für erwartete Fehlerfälle und reservieren Sie Panic/Recover für wirklich außergewöhnliche Situationen wie einen beschädigten Zustand oder nicht behebbare Bedingungen.

Aufgabe

Einfach

Lassen Sie uns einen sicheren Divisionsrechner bauen, der demonstriert, wie man panic, defer und recover verwendet, um Ausnahmesituationen elegant zu handhaben. Ihr Rechner wird riskante Operationen versuchen und Panics in reguläre Fehler umwandeln, die normal verarbeitet werden können.

Sie werden Ihren Code in zwei Dateien organisieren:

calculator.go: Erstellen Sie die Divisionslogik mit Panic-Wiederherstellung.
Implementieren Sie eine Divide-Funktion, die zwei Ganzzahlen entgegennimmt und mit der Nachricht "division by zero" paniziert, wenn der Divisor Null ist. Andernfalls gibt sie das ganzzahlige Ergebnis der Division zurück.

Implementieren Sie eine SafeDivide-Funktion, die zwei Ganzzahlen entgegennimmt und sowohl ein ganzzahliges Ergebnis als auch einen Fehler zurückgibt. Diese Funktion sollte:
- defer mit einer anonymen Funktion verwenden, um sich von jeder Panic zu erholen
- Falls eine Panic abgefangen wird, wandeln Sie diese in einen Fehler mit dem Format "calculation error: [panic message]" um
- Die Divide-Funktion intern aufrufen
- Das Ergebnis und nil bei Erfolg zurückgeben, oder Null und den Fehler, falls eine Panic abgefangen wurde
main.go: Lesen Sie zwei Ganzzahlen aus der Eingabe ein und verwenden Sie SafeDivide, um die Berechnung sicher durchzuführen. Demonstrieren Sie außerdem defer, indem Sie Bereinigungsnachrichten in der richtigen Reihenfolge ausgeben.
Ihre Main-Funktion sollte:
- Zu Beginn Starting calculation ausgeben
- defer verwenden, um die Ausgabe von Cleanup complete zu planen
- Ein weiteres defer verwenden, um die Ausgabe von Releasing resources zu planen
- SafeDivide mit den Eingabewerten aufrufen
- Entweder Result: [value] oder Error: [error message] basierend auf dem Ergebnis ausgeben

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Erste Ganzzahl (Dividend)
Zeile 2: Zweite Ganzzahl (Divisor)

Denken Sie daran, dass verzögerte Aufrufe (deferred calls) in umgekehrter Reihenfolge ausgeführt werden (Last-In, First-Out), sodass Ihre Bereinigungsnachrichten in der entgegengesetzten Reihenfolge erscheinen sollten, in der sie verzögert wurden.

Zum Beispiel sollte Ihre Ausgabe bei 20 und 4 wie folgt aussehen:

Starting calculation
Result: 5
Releasing resources
Cleanup complete

Und bei 10 und 0 sollte Ihre Ausgabe wie folgt aussehen:

Starting calculation
Error: calculation error: division by zero
Releasing resources
Cleanup complete

Spickzettel

Go bietet panic, defer und recover für den Umgang mit außergewöhnlichen Umständen.

panic stoppt die normale Ausführung sofort und ist für nicht behebbare Programmierfehler reserviert:

func MustGetConfig(key string) string {
    value, exists := config[key]
    if !exists {
        panic("missing required config: " + key)
    }
    return value
}

defer plant die Ausführung einer Funktion für den Zeitpunkt, an dem die umgebende Funktion zurückkehrt. Verzögerte Aufrufe werden in umgekehrter Reihenfolge ausgeführt (Last-In, First-Out):

func ProcessFile() {
    fmt.Println("Opening file")
    defer fmt.Println("Closing file")
    fmt.Println("Processing...")
    // Output: Opening file, Processing..., Closing file
}

recover fängt ein Panic ab und kehrt zur normalen Ausführung zurück. Es funktioniert nur innerhalb einer verzögerten Funktion (deferred function):

func SafeOperation() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    
    riskyOperation()
    return nil
}

Dieses Muster wandelt ein Panic in einen regulären Fehler um. Bevorzugen Sie die Rückgabe von Fehlern für erwartete Fehlerfälle und reservieren Sie Panic/Recover für wirklich außergewöhnliche Situationen.

Probier es selbst

package main

import (
	"fmt"
)

func main() {
	// Eingabe lesen
	var dividend, divisor int
	fmt.Scanln(&dividend)
	fmt.Scanln(&divisor)

	// Startmeldung ausgeben
	fmt.Println("Starting calculation")

	// TODO: defer verwenden, um die Nachricht "Cleanup complete" zu planen

	// TODO: defer verwenden, um die Nachricht "Releasing resources" zu planen
	// Zur Erinnerung: Verzögerte Aufrufe (deferred calls) werden in LIFO-Reihenfolge ausgeführt (last-in, first-out)

	// TODO: SafeDivide mit den Eingabewerten aufrufen

	// TODO: Entweder "Result: [value]" oder "Error: [error message]" ausgeben,
	// basierend darauf, ob ein Fehler zurückgegeben wurde
}