Error Handling in Go

# CHAPTER 16

Error Handling in Go #

1. Introduction #

Go does NOT have try/catch exceptions. Go believes that errors are a normal part of programming, not magical exceptions. In Go, errors are treated as normal values. Functions return errors, and you explicitly check them using if err != nil.

2. Learning Objectives #

• Understand the error interface.

• Check and handle returned errors properly.

• Create custom errors using errors.New().

• Format detailed errors using fmt.Errorf().

• Understand panic and recover.

3. The error Interface #

If the operation succeeds, the error returned is nil. If it fails, it returns an error object containing a message.

4. Checking Errors (if err != nil) #

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Atoi converts string to integer. Returns (int, error)
    price, err := strconv.Atoi("100abc")

    // EXPLICIT ERROR CHECKING
    if err != nil {
        fmt.Println("Failed to parse price:", err)
        return // Stop the program cleanly!
    }

    fmt.Println("The price is:", price)
}

*Note: You will write if err != nil hundreds of times in Go. It forces you to think about failure at every step.*

5. Creating Custom Errors #

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        // Create a basic error
        return 0, errors.New("cannot divide by zero") 
    }
    return a / b, nil // Return nil because there is no error
}

func main() {
    result, err := divide(10, 0)
    
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

6. Formatting Detailed Errors #

func findUser(id int) (string, error) {
    if id != 1 {
        // Generating a detailed, formatted error
        return "", fmt.Errorf("user with ID %d was not found in the database", id)
    }
    return "Alice", nil
}

7. Panic and Recover #

You can trigger a panic manually for completely unrecoverable situations (e.g., the server failed to start because the port is in use).

func main() {
    panic("CRITICAL SYSTEM FAILURE! Shutting down.")
}

Recover: If a Panic happens, you can catch it and prevent the application from crashing using recover() inside a defer statement. *(Note: defer executes a function at the very end, right before the surrounding function exits).*

func safeExecution() {
    // defer runs this anonymous function right before safeExecution() finishes
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()

    fmt.Println("About to panic...")
    panic("Oops!") // This would normally crash the program
}

func main() {
    safeExecution()
    fmt.Println("Program continues because we recovered!")
}

8. Common Mistakes #

• Ignoring Errors using : price, := strconv.Atoi("abc"). If it fails, price becomes 0 and you never know why. Never ignore errors in production code.

• Overusing Panic: Beginners use panic like throw Exception in Java. In Go, panic is strictly for catastrophic, unrecoverable crashes. For normal logic flow (bad password, missing file), always return an error.

9. Best Practices #

• Error messages should be completely lowercase and should not end with punctuation. Go's standard libraries follow this to allow errors to be easily chained together. (e.g., errors.New("user not found") rather than "User not found!").

10. Exercises #

1. 1. Write a function checkPasswordLength(pwd string) error.

1. 2. If the length is less than 8, return an error using fmt.Errorf.

1. 3. Test it in main and print the result.

11. MCQs with Answers & Explanations #

Q1. Does Go use try/catch exception blocks? a) Yes b) No Answer: b) No. *Explanation: Go returns errors as normal values.*

12. Interview Preparation #

1. 1. Why did the Go creators choose to use explicit error checking (if err != nil) over try/catch exceptions?

1. 2. Explain the difference between returning an error and triggering a panic.

1. 3. How do defer, panic, and recover work together?

13. Summary #

14. Next Chapter Recommendation #