What is the difference between Go's panic and recover functions for handling runtime errors?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, error handling is a crucial aspect of writing robust and reliable programs. Go provides two powerful mechanisms for dealing with runtime errors: panic and recover. Understanding the differences between these functions and how to use them effectively can help manage unexpected situations and maintain program stability.
Difference Between Go's panic and recover Functions
. panic Function
The panic function is used to trigger a runtime error and abruptly stop the normal execution of a program. When panic is called, the program starts unwinding the stack, executing any deferred functions along the way, and then terminating if the panic is not recovered.

Purpose: To signal a critical error that prevents the program from continuing safely.

Behavior:

Immediately stops execution of the current function and begins unwinding the stack.
Executes deferred functions in the reverse order of their deferral.
If not recovered, the program terminates with an error message.

Example:
package main

import "fmt"

func causePanic() {
    panic("Something went wrong!")
}

func main() {
    causePanic()
    fmt.Println("This line will not be executed.")
}

Output:
panic: Something went wrong!

goroutine 1 [running]:
main.causePanic()
    /path/to/file.go:7 +0x60
main.main()
    /path/to/file.go:11 +0x20
exit status 2

In this example, the panic function stops execution and prints an error message, preventing the subsequent code from running.

recover Function
The recover function is used to regain control of a program after a panic has occurred. It allows the program to continue executing instead of terminating, by catching the panic and preventing the program from crashing. recover can only be used within a deferred function.

Purpose: To handle and recover from a panic, allowing the program to continue executing.

Behavior:

Captures the value passed to panic and stops the unwinding of the stack.
Must be used inside a deferred function to work correctly.
If recover is not called or the panic is not caught, the program will still terminate.

Example:
package main

import "fmt"

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

func riskyOperation() {
    defer handlePanic()
    panic("Something went wrong!")
}

func main() {
    riskyOperation()
    fmt.Println("Program continues after recovery.")
}

Output:
Recovered from panic: Something went wrong!
Program continues after recovery.

Here, recover captures the panic, allowing the program to continue execution and avoid termination.

Key Differences Between **panic** and **recover**
| Feature | Panic | Recover |
| --- | --- | --- |
| Purpose | To signal a critical error and stop execution. | To handle a panic and resume normal execution. |
| Execution Flow | Immediately stops function execution and unwinds the stack. | Captures the panic and prevents the program from terminating. |
| Usage Context | Used to indicate serious problems that cannot be handled. | Used within a deferred function to catch and handle panics. |
| Program Termination | Typically leads to program termination if not recovered. | Allows the program to continue if a panic is caught. |
| Syntax | panic(value) | recover() (must be used inside a deferred function) |
Practical Examples
Example : Using panic to Signal an Error
package main

import "fmt"

func divide(x, y int) int {
    if y == 0 {
        panic("division by zero")
    }
    return x / y
}

func main() {
    fmt.Println(divide(10, 2)) // Output: 5
    fmt.Println(divide(10, 0)) // Causes panic: division by zero
}

In this example, panic is used to handle division by zero, which causes the program to stop if not managed.
Example : Using recover to Handle a Panic
package main

import "fmt"

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

func main() {
    fmt.Println(safeDivide(10, 2)) // Output: 5
    fmt.Println(safeDivide(10, 0)) // Output: Recovered from: division by zero
}

Here, recover is used to handle the panic from division by zero, allowing the program to continue running.
Conclusion
In Go, panic and recover provide mechanisms for managing runtime errors and maintaining program stability. panic is used to signal critical errors that halt execution, while recover allows you to handle these errors and resume normal operation. Understanding and using both appropriately helps create resilient and reliable Go applications.

Feature	Panic	Recover
Purpose	To signal a critical error and stop execution.	To handle a panic and resume normal execution.
Execution Flow	Immediately stops function execution and unwinds the stack.	Captures the panic and prevents the program from terminating.
Usage Context	Used to indicate serious problems that cannot be handled.	Used within a deferred function to catch and handle panics.
Program Termination	Typically leads to program termination if not recovered.	Allows the program to continue if a panic is caught.
Syntax	`panic(value)`	`recover()` (must be used inside a deferred function)

What is the difference between Go's panic and recover functions for handling runtime errors?

Table of Contents

Introduction

Difference Between Go's `panic` and `recover` Functions

. `panic` Function

`recover` Function

Key Differences Between `panic` and `recover`

Practical Examples

Example : Using `panic` to Signal an Error

Example : Using `recover` to Handle a Panic

Conclusion

Similar Questions