What is recover in Go: Explanation and Usage

recover in Go is a built-in function that lets you regain control of a program after a panic occurs. It stops the panic and allows the program to continue running instead of crashing.

How It Works

Imagine your Go program is like a car driving smoothly. A panic is like suddenly hitting a big obstacle that makes the car stop immediately. Normally, the program crashes and stops running when a panic happens.

recover acts like an emergency brake that you can use inside a special safety zone called a defer function. When you use recover inside a deferred function, it catches the panic and stops the crash, letting your program keep going safely.

This mechanism helps you handle unexpected errors without stopping everything, similar to how a seatbelt protects you in a sudden stop.

Example

This example shows how recover catches a panic and prevents the program from crashing.

go

package main

import "fmt"

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

    fmt.Println("Result:", a/b) // This will panic if b is 0
}

func main() {
    safeDivide(10, 2) // Normal division
    safeDivide(10, 0) // Causes panic but recovered
    fmt.Println("Program continues running")
}

Output

Result: 5
Recovered from panic: runtime error: integer divide by zero
Program continues running

When to Use

Use recover when you want to handle unexpected errors gracefully without stopping your whole program. It is useful in servers, long-running processes, or libraries where crashing would be bad.

For example, a web server can use recover to catch panics caused by bad user input and respond with an error message instead of crashing the server.

However, recover should be used carefully and only inside deferred functions, because catching panics everywhere can hide real bugs.

Key Points

• recover only works inside deferred functions.
• It stops a panic and returns the panic value.
• Use it to keep your program running after unexpected errors.
• Do not overuse it; it can hide bugs if used improperly.

Key Takeaways

recover catches panics and prevents program crashes when used inside deferred functions.

It helps handle unexpected errors gracefully in long-running or critical programs.

Always use recover carefully to avoid hiding real bugs.

Panics are like sudden crashes; recover acts like an emergency brake.

Use recover mainly in places where program stability is important, like servers.