Recover usage in Go - Mini Project: Build & Apply

Recover Usage in Go

📖 Scenario: Imagine you are writing a Go program that divides two numbers. Sometimes, the divisor might be zero, which causes a program crash. You want to handle this problem gracefully so the program doesn't stop unexpectedly.

🎯 Goal: You will build a Go program that uses recover inside a deferred function to catch a panic caused by division by zero and print a friendly error message instead of crashing.

📋 What You'll Learn

Create a function called divide that takes two integers a and b and returns an integer result.

Inside divide, use defer with an anonymous function that calls recover() to catch panics.

If a panic occurs, print "Recovered from panic: division by zero".

In divide, perform the division a / b which will panic if b is zero.

Call divide twice in main: once with 10 and 2, and once with 10 and 0.

Print the result of the division when no panic occurs.

💡 Why This Matters

🌍 Real World

Handling unexpected errors like division by zero is important in real-world programs to avoid crashes and provide better user experience.

💼 Career

Understanding panic and recover is useful for Go developers to write robust and fault-tolerant applications.

1

Create the divide function with parameters

Write a function called divide that takes two integer parameters a and b and returns an integer.

Go

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

Hint

Start by writing the function header with the correct name and parameters.

2

Add defer with recover to catch panics

Inside the divide function, add a defer statement with an anonymous function that calls recover(). If recover() returns a non-nil value, print "Recovered from panic: division by zero".

Go

package main

func divide(a int, b int) int {
    defer func() {
        // Your code here
    }()
    return 0
}

Hint

Use defer func() { if r := recover(); r != nil { ... } }() to catch panics.

3

Perform division that may panic

In the divide function, replace the return 0 with return a / b to perform the division that may cause a panic if b is zero.

Go

package main

import "fmt"

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

Hint

Replace the return statement with the division expression a / b.

4

Call divide in main and print results

Write a main function that calls divide(10, 2) and prints the result, then calls divide(10, 0) to show the recovered panic message.

Go

package main

import "fmt"

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

func main() {
    // Your code here
}

Hint

Call divide(10, 2), print the result, then call divide(10, 0) to trigger and recover from panic.

Practice

1. What is the main purpose of the recover function in Go?

easy

A. To handle errors returned by functions

B. To start a new goroutine

C. To pause the execution of a function

D. To catch a panic and prevent the program from crashing

Solution

1. Step 1: Understand panic and recover

   Panic causes a program to stop immediately unless recovered.

2. Step 2: Role of recover

   Recover catches the panic inside a deferred function to keep the program running.

3. Final Answer:

   To catch a panic and prevent the program from crashing -> Option D

4. Quick Check:

   recover catches panic = A [OK]

Hint: Recover catches panics only inside deferred functions [OK]

Common Mistakes:

• Thinking recover handles normal errors
• Using recover outside deferred functions
• Confusing recover with panic

2. Which of the following is the correct way to use recover in Go?

easy

A. Call recover directly inside the main function

B. Call recover inside a deferred function

C. Call recover inside a goroutine

D. Call recover after a panic has finished

Solution

1. Step 1: Identify recover usage rules

   Recover must be called inside a deferred function to catch panics.

2. Step 2: Analyze options

   Only Call recover inside a deferred function calls recover inside a deferred function.

3. Final Answer:

   Call recover inside a deferred function -> Option B

4. Quick Check:

   recover inside defer = B [OK]

Hint: Always use recover inside defer to catch panics safely [OK]

Common Mistakes:

• Calling recover directly without defer
• Calling recover after panic ends
• Using recover in goroutines without defer

3. What will be the output of this Go program?

package main
import "fmt"
func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("something went wrong")
    fmt.Println("This will not print")
}

medium

A. Recovered from panic: something went wrong

B. something went wrong

C. This will not print

D. Program crashes with panic message

Solution

1. Step 1: Understand defer and recover behavior

   The deferred function runs after panic starts, calling recover to catch it.

2. Step 2: Output analysis

   Recover prints the panic message, so output is "Recovered from panic: something went wrong".

3. Final Answer:

   Recovered from panic: something went wrong -> Option A

4. Quick Check:

   defer + recover prints panic message = C [OK]

Hint: Recover prints panic message inside deferred function [OK]

Common Mistakes:

• Expecting code after panic to run
• Thinking panic message prints directly
• Ignoring deferred recover function

4. What is wrong with this Go code snippet?

func main() {
    recover()
    panic("error")
}

medium

A. panic() cannot be called without defer

B. panic() must be called before recover()

C. recover() is called outside a deferred function and will not catch panic

D. recover() cannot be called in main function

Solution

1. Step 1: Check recover usage

   Recover only works inside deferred functions to catch panics.

2. Step 2: Analyze code

   Recover is called directly, so it won't catch the panic, causing program to crash.

3. Final Answer:

   recover() is called outside a deferred function and will not catch panic -> Option C

4. Quick Check:

   recover outside defer = no panic catch = D [OK]

Hint: Recover must be inside defer to catch panic [OK]

Common Mistakes:

• Calling recover directly without defer
• Assuming recover catches panic anytime
• Misunderstanding panic and recover order

5. You want to safely handle panics in a function that divides two numbers and returns the result. Which code snippet correctly uses recover to avoid crashing when dividing by zero?

hard

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

B. func safeDivide(a, b int) int {
if b == 0 {
recover()
}
return a / b
}

C. func safeDivide(a, b int) int {
return a / b
defer recover()
}

D. func safeDivide(a, b int) int {
defer recover()
return a / b
}

Solution

1. Step 1: Identify correct recover usage

   Recover must be called inside a deferred anonymous function to catch panics.

2. Step 2: Analyze options

   Only func safeDivide(a, b int) int { defer func() { if r := recover(); r != nil { fmt.Println("Recovered from panic") } }() return a / b } uses defer with an anonymous function calling recover properly.

3. Final Answer:

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

4. Quick Check:

   defer func with recover = safe panic handling = A [OK]

Hint: Use defer with anonymous func calling recover to catch panics [OK]

Common Mistakes:

• Calling recover without defer
• Calling recover outside anonymous function
• Placing defer after return statement