Panic behavior in Go - Step-by-Step Execution

Concept Flow - Panic behavior

Start program

↓

Call function

↓

Panic occurs?

No→Continue normal execution

Yes↓

Run deferred functions

↓

Program crashes with panic message

The program runs normally until a panic happens, then it runs deferred functions before crashing.

Execution Sample

Go

package main
import "fmt"
func main() {
  defer fmt.Println("Deferred runs")
  panic("Something went wrong")
}

This code shows a panic happening and a deferred function running before the program crashes.

Execution Table

Step	Action	Output	State
1	Start main function		main started
2	Set defer to print 'Deferred runs'		defer set
3	Call panic with message 'Something went wrong'		panic triggered
4	Run deferred function: print 'Deferred runs'	Deferred runs	deferred function executed
5	Program crashes with panic message	panic: Something went wrong	program stops

💡 Program stops after panic and deferred functions run

Variable Tracker

Variable	Start	After panic	After defer	Final
panic state	false	true	true	program stopped

Key Moments - 2 Insights

Why does the deferred function run even after panic?

Because Go always runs deferred functions before the program crashes due to panic, as shown in step 4 of the execution table.

Does the program continue normal execution after panic?

No, after panic and running deferred functions, the program stops immediately, as shown in step 5.

Visual Quiz - 3 Questions

Look at the execution table, what is printed by the deferred function?

A Deferred runs

B Something went wrong

C panic: Something went wrong

D No output

💡 Hint

Check step 4 in the execution table where the deferred function output is shown.

At which step does the panic get triggered?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in the execution table for when panic is called.

If the defer statement was removed, what would change in the output?

A The panic message would not print

B The program would not panic

C The deferred message 'Deferred runs' would not print

D The program would continue running after panic

💡 Hint

Refer to the output in step 4 where the deferred function prints its message.

Concept Snapshot

panic("message") stops normal execution immediately
Deferred functions run before program crashes
Program prints panic message and exits
Use defer to clean up before panic ends program
Panic is like a run-time error causing crash

Full Transcript

This example shows how panic works in Go. The program starts main, sets a deferred function to print a message, then calls panic with a message. When panic happens, normal execution stops, but deferred functions still run. After running deferred functions, the program crashes and prints the panic message. This behavior ensures cleanup code runs even on errors. The execution table traces each step: starting main, setting defer, triggering panic, running defer, and stopping program. Variables track panic state changing from false to true. Key moments clarify why defer runs after panic and that the program does not continue after panic. The quiz tests understanding of output, panic timing, and effect of removing defer. The snapshot summarizes panic behavior simply and clearly.

Practice

1. What happens when a panic is called in a Go program?

easy

A. The program ignores the panic and continues running.

B. The program restarts automatically.

C. The program stops immediately and prints an error message.

D. The program logs the error but continues execution.

Solution

1. Step 1: Understand panic behavior

   In Go, calling panic immediately stops normal execution and begins panicking.

2. Step 2: Effect on program flow

   The program prints a stack trace and error message, then terminates unless recovered.

3. Final Answer:

   The program stops immediately and prints an error message. -> Option C

4. Quick Check:

   Panic stops program = B [OK]

Hint: Panic always stops the program immediately [OK]

Common Mistakes:

• Thinking panic allows program to continue
• Confusing panic with error return
• Assuming panic restarts the program

2. Which of the following is the correct syntax to cause a panic with the message "error occurred"?

easy

A. panic("error occurred";)

B. panic("error occurred")

C. panic: "error occurred"

D. panic = "error occurred"

Solution

1. Step 1: Recall panic syntax

   Panic is a built-in function called with parentheses and a string argument.

2. Step 2: Check each option

   panic("error occurred") uses correct function call syntax. Others have invalid assignment, colon, or extra semicolon.

3. Final Answer:

   panic("error occurred") -> Option B

4. Quick Check:

   Panic is a function call = D [OK]

Hint: Panic is called like a function with parentheses [OK]

Common Mistakes:

• Using assignment instead of function call
• Adding extra semicolons inside panic call
• Using colon instead of parentheses

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

package main
import "fmt"
func main() {
    fmt.Println("Start")
    panic("something went wrong")
    fmt.Println("End")
}

medium

A. Start
End

B. something went wrong
panic stack trace

C. Start

D. Start
something went wrong
panic stack trace

Solution

1. Step 1: Trace program execution

   The program prints "Start" first, then calls panic with a message.

2. Step 2: Effect of panic on following code

   After panic, the program stops immediately, so "End" is not printed. Panic message and stack trace appear.

3. Final Answer:

   Start something went wrong panic stack trace -> Option D

4. Quick Check:

   Panic stops after printing Start = C [OK]

Hint: Panic prints message and stops; code after panic not run [OK]

Common Mistakes:

• Expecting code after panic to run
• Ignoring panic message output
• Confusing panic output with normal print

4. Identify the error in this Go code snippet:

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

func main() {
    result := divide(10, 0)
    fmt.Println(result)
}

medium

A. Missing import of "fmt" package

B. Cannot panic inside a function

C. Division by zero is allowed, no panic needed

D. Function divide should return error instead of int

Solution

1. Step 1: Check code for syntax errors

   The code uses fmt.Println but does not import "fmt" package.

2. Step 2: Validate panic usage

   Panic is allowed inside functions; division by zero should panic to avoid runtime error.

3. Final Answer:

   Missing import of "fmt" package -> Option A

4. Quick Check:

   Missing import causes compile error = A [OK]

Hint: Check imports when using fmt functions [OK]

Common Mistakes:

• Thinking panic is not allowed in functions
• Ignoring missing imports
• Assuming division by zero returns zero

5. You want to write a Go function that safely divides two integers and returns the result. If the divisor is zero, it should panic with "division by zero". Which of these implementations correctly uses panic and recover to handle the error and return zero instead of crashing the program?

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

func main() {
    fmt.Println(safeDivide(10, 0))
}

hard

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

B. func safeDivide(a, b int) int {
if b == 0 {
panic("division by zero")
}
return a / b
}

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

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

Solution

1. Step 1: Understand panic and recover usage

   Recover must be called inside a deferred function to catch panic and prevent program crash.

2. Step 2: Analyze each option

   func safeDivide(a, b int) int { defer func() { if r := recover(); r != nil { fmt.Println("Recovered from panic") } }() if b == 0 { panic("division by zero") } return a / b } uses defer with recover to catch panic and prints a message, then continues. It returns the division result or panics if divisor is zero. func safeDivide(a, b int) int { defer func() { if r := recover(); r != nil { return 0 } }() if b == 0 { panic("division by zero") } return a / b } tries to return inside defer, which does not affect the outer function's return. func safeDivide(a, b int) int { if b == 0 { panic("division by zero") } return a / b } panics without recovery. func safeDivide(a, b int) int { if b == 0 { return 0 } return a / b } returns 0 without panic.

3. Final Answer:

   Option A correctly uses panic and recover to handle error and avoid crash. -> Option A

4. Quick Check:

   Defer recover catches panic = A [OK]

Hint: Use defer with recover to catch panic safely [OK]

Common Mistakes:

• Returning inside defer does not change function return
• Not using recover causes program crash
• Ignoring panic and returning zero silently