The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Panic and Recover

Next ►
►

In Go, error handling is typically done using the error type. However, there are situations where you might encounter severe errors that you cannot handle gracefully. In such cases, Go provides the panic and recover mechanisms. This section will cover how to use panic and recover to handle such situations.

What is Panic?

A panic in Go is a built-in function that stops the normal execution of the current goroutine. When a function calls panic, the program will start to unwind the stack, executing any deferred functions along the way. If the program does not recover from the panic, it will terminate.

When to Use Panic

  • When you encounter an unrecoverable error.
  • When you detect a condition that should never happen (e.g., a logic error).
  • When you want to abort the program immediately.

Example of Panic

package main

import "fmt"

func main() {
    fmt.Println("Starting the program")
    panic("Something went wrong!")
    fmt.Println("This line will not be executed")
}

In this example, the program will print "Starting the program" and then panic with the message "Something went wrong!". The line after the panic call will not be executed.

What is Recover?

The recover function allows you to regain control of a panicking goroutine. It can only be used inside deferred functions. If recover is called and a panic is in progress, recover will stop the panic and return the value passed to panic. If no panic is in progress, recover returns nil.

Example of Recover

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    fmt.Println("Starting the program")
    panic("Something went wrong!")
    fmt.Println("This line will not be executed")
}

In this example, the deferred function will recover from the panic and print "Recovered from panic: Something went wrong!". The program will not terminate abruptly.

Practical Example: Panic and Recover in a Function

Let's see a more practical example where panic and recover are used in a function.

package main

import "fmt"

func divide(a, b int) int {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    if b == 0 {
        panic("division by zero")
    }
    return a / b
}

func main() {
    fmt.Println("Result:", divide(10, 2))
    fmt.Println("Result:", divide(10, 0))
    fmt.Println("Program continues...")
}

Explanation

  1. Deferred Function: The defer statement ensures that the anonymous function is executed when divide returns, either normally or due to a panic.
  2. Recover: Inside the deferred function, recover is called to check if a panic occurred. If so, it prints the panic message.
  3. Panic: If b is zero, the function panics with the message "division by zero".

Output

Result: 5
Recovered from panic: division by zero
Program continues...

Exercises

Exercise 1: Basic Panic and Recover

Write a function safeDivide that takes two integers and returns their division. If the divisor is zero, the function should panic and then recover, returning zero.

package main

import "fmt"

func safeDivide(a, b int) int {
    // Your code here
}

func main() {
    fmt.Println("Result:", safeDivide(10, 2)) // Should print: Result: 5
    fmt.Println("Result:", safeDivide(10, 0)) // Should print: Result: 0
}

Solution

package main

import "fmt"

func safeDivide(a, b int) int {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    if b == 0 {
        panic("division by zero")
    }
    return a / b
}

func main() {
    fmt.Println("Result:", safeDivide(10, 2)) // Should print: Result: 5
    fmt.Println("Result:", safeDivide(10, 0)) // Should print: Result: 0
}

Exercise 2: Nested Panic and Recover

Write a function nestedPanic that calls another function innerFunction which panics. Use recover in nestedPanic to handle the panic.

package main

import "fmt"

func innerFunction() {
    // Your code here
}

func nestedPanic() {
    // Your code here
}

func main() {
    nestedPanic()
    fmt.Println("Program continues...")
}

Solution

package main

import "fmt"

func innerFunction() {
    panic("inner function panic")
}

func nestedPanic() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    innerFunction()
}

func main() {
    nestedPanic()
    fmt.Println("Program continues...")
}

Common Mistakes

  • Not Using Defer: recover only works inside deferred functions. Forgetting to use defer will result in recover not catching the panic.
  • Ignoring Panics: Overusing recover to ignore panics can lead to hidden bugs. Use it judiciously.
  • Panic in Libraries: Avoid using panic in library code. Instead, return errors to the caller.

Conclusion

In this section, you learned about panic and recover in Go. You now understand how to use these mechanisms to handle severe errors and regain control of your program. Remember to use panic and recover judiciously, as they can make your code harder to understand and maintain. In the next section, we will delve into Go's concurrency model with goroutines.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved