Difference between calling "panic" and calling "os.Exit(1)" in Go (Golang)

In Go (Golang), both panic and os.Exit(1) are used to terminate a program, but they do so in different ways and have different implications.

Here's a breakdown of the differences:

1. panic

• Purpose: panic is used to indicate that something unexpected or unrecoverable has happened in the program. It is typically used for errors that should not occur during normal execution.
• Behavior:
  • When panic is called, the normal execution of the program is halted.
  • The runtime starts unwinding the stack, running any deferred functions (using defer) along the way.
  • If no recovery is attempted (using recover), the program will terminate and print a stack trace, which includes the point where the panic was called and the call stack.
• Use Case: panic is generally used for programmer errors or unexpected conditions (e.g., accessing a nil pointer, out-of-bounds array access, etc.).
• Example:

  func main() {
      defer fmt.Println("This will be printed before the program exits.")
      panic("Something went wrong!")
  }

Output:

  This will be printed before the program exits.
  panic: Something went wrong!
  goroutine 1 [running]:
  main.main()
      /tmp/sandbox123456/main.go:7 +0x95

2. os.Exit(1)

• Purpose: os.Exit is used to immediately terminate the program with a specified exit code. It is typically used to indicate that the program has failed or completed its task.
• Behavior:
  • When os.Exit is called, the program terminates immediately without running any deferred functions or cleaning up resources.
  • The exit code passed to os.Exit is returned to the operating system. A non-zero exit code (like 1) typically indicates an error or failure.
• Use Case: os.Exit is used when you want to terminate the program immediately, without any further processing (e.g., in command-line tools when an error condition is detected).
• Example:

  func main() {
      defer fmt.Println("This will NOT be printed.")
      os.Exit(1)
  }

Output:

  (No output, program exits immediately with exit code 1)

---

Key Differences:

• Deferred Functions: panic runs deferred functions before terminating, while os.Exit does not.
• Stack Trace: panic generates a stack trace, which can be useful for debugging. os.Exit does not generate a stack trace.
• Exit Code: panic does not allow you to specify an exit code directly (it defaults to 2). os.Exit allows you to specify an exit code.
• Use Case: panic is for unexpected errors, while os.Exit is for controlled program termination.

When to Use Which:

• Use panic when you encounter a situation that should never happen during normal execution (e.g., a bug).
• Use os.Exit when you want to terminate the program immediately, typically in response to a known error condition (e.g., invalid command-line arguments).

---

Recovering from panic:

You can recover from a panic using the recover function, which allows you to handle the panic gracefully and continue execution. This is not possible with os.Exit.

Example of recovering from a panic:

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("Something went wrong!")
}

Output:

Recovered from panic: Something went wrong!