Exercise 3: Error Handling in Go

Why Doesn't Go Use Exceptions?

Unlike Python or Java, Go does not use `try/catch` for error handling. Instead, it returns `error` values from functions.

This approach makes error handling explicit, improving readability and reducing hidden errors.

Comparison with Other Languages

• Python: Uses `try/except` blocks.
• Java: Uses `try/catch` with exception classes.
• C++: Uses `throw/catch` or `errno`.
• Go: Uses `error` values and checks with `if err != nil`.

How to Handle Errors in Go

Errors are returned from functions and should be checked immediately.

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero is not allowed")
    }
    return a / b, nil
}

Best Practices for Error Handling

• ✅ Always return an error when a function can fail.
• ✅ Always check `if err != nil` before continuing.
• ✅ Use `fmt.Errorf()` for more detailed error messages.
• ✅ Use `errors.Is()` and `errors.As()` for precise error handling.
• ✅ Avoid `panic` unless dealing with critical system failures.

Handling Fatal Errors with `panic` and `recover`

Sometimes, `panic` is necessary for stopping execution immediately.

func main() {
    fmt.Println("Starting the program")
    panic("Critical error!")
    fmt.Println("This will never be printed")
}

However, `recover` can be used to prevent a full crash:

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

func main() {
    defer handleError()
    panic("A fatal error occurred!")
}

⚠️ `recover` should only be used in rare cases to prevent abrupt crashes.

Exercise Instructions

• Create a file errors.go.
• Define a function `openFile(name string) (string, error)`.
• Use `os.Open()` to check if the file exists.
• Return an error message if the file is missing.

package main

import (
    "fmt"
    "os"
)

func openFile(name string) (string, error) {
    file, err := os.Open(name)
    if err != nil {
        return "", fmt.Errorf("Error: cannot open %s - %v", name, err)
    }
    defer file.Close()
    return "File opened successfully!", nil
}

func main() {
    message, err := openFile("myfile.txt")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(message)
    }
}

Expected Output

Error: cannot open myfile.txt - open myfile.txt: no such file or directory

📚 Learn more about error handling in Go:

Official Go Documentation