Error Handling: Explicit (val, err), defer, panic & recover()

1Concept

Go uses explicit error returns (if err != nil). defer executes cleanup functions in LIFO order upon function exit. panic unwinds the stack, which can be intercepted via recover() inside deferred functions.

2Architecture Diagram

defer runs in LIFO order on return:
 defer file.Close()
 defer mutex.Unlock()

Panic ──► Unwinds stack ──► Intercepted by recover() in deferred function!

3Code Example

package main

import (
    "errors"
    "fmt"
)

func safeDivide(a, b int) (result int, err error) {
    // Protect against panics
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from runtime panic: %v", r)
        }
    }()

    if b == 0 {
        return 0, errors.New("divisor cannot be zero")
    }
    return a / b, nil
}

func main() {
    fmt.Println("=== Go Explicit Error Handling & Panic Recovery ===")
    
    // Normal Error
    if _, err := safeDivide(10, 0); err != nil {
        fmt.Printf("[Handled Error] %v\n", err)
    }

    // Success Case
    if val, err := safeDivide(100, 5); err == nil {
        fmt.Printf("[Success] 100 / 5 = %d\n", val)
    }
}

4Expected Output

=== Go Explicit Error Handling & Panic Recovery ===
[Handled Error] divisor cannot be zero
[Success] 100 / 5 = 20

5Key Takeaways

• ✓Always check if err != nil immediately after calling fallible functions.
• ✓defer guarantees resource release (files, mutexes, sockets) even during errors.
• ✓Reserve panic and recover for catastrophic, unrecoverable programmer bugs.