Error handling is an essential aspect of robust software development. In Go, error handling is straightforward yet powerful, thanks to the built-in panic and recover mechanisms, along with the ability to wrap errors for improved context. In this article, we’ll explore these error handling strategies in detail, along with comprehensive code examples.

1. Panic and Recover

What is Panic?

panic is a built-in function in Go that stops the ordinary flow of control and begins panicking. When the function panic() is called, the execution of the current function is stopped immediately, and the control passes to its deferred functions. If no deferred functions are present or if none of them recover from the panic, the program terminates.

What is Recover?

recover is another built-in function in Go that is used to regain control of a panicking goroutine. It’s only useful inside deferred functions. When called inside a deferred function, recover stops the panic and returns the value passed to the panic function. If the goroutine is not panicking, recover returns nil.


package main

import "fmt"

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

func example() {
    defer recoverFromPanic()
    fmt.Println("Starting the example function")
    panic("Oops! Something went wrong!")
    fmt.Println("This line will not be executed")

func main() {
    fmt.Println("Continuing after panic")


$ go run error-handling.go 
Starting the example function
Recovered from panic: Oops! Something went wrong!
Continuing after panic

In this example:

  • The example function defers the recoverFromPanic function, which will be executed when a panic occurs.
  • When panic("Oops! Something went wrong!") is encountered, the execution of the example function is immediately stopped.
  • The control passes to the deferred recoverFromPanic function, which prints the message “Recovered from panic” along with the panic value.
  • The program continues to execute after the panic is recovered.

2. Error Wrapping

What is Error Wrapping?

Error wrapping is a technique used to provide additional context to errors by adding more information to them. It allows you to attach context to an error without losing the original error message.


package main

import (

func main() {
    // Original error
    err := errors.New("something went wrong")

    // Wrap the error with additional context
    wrappedErr := fmt.Errorf("additional context: %w", err)

    // Print the wrapped error

    // Unwrap the wrapped error to get the original error
    originalErr := errors.Unwrap(wrappedErr)

    // Check if the error contains the original error
    if errors.Is(wrappedErr, err) {
        fmt.Println("The wrapped error contains the original error")


$ go run error-handling-2.go
additional context: something went wrong
something went wrong
The wrapped error contains the original error

In this example:

  • We create an original error using errors.New("something went wrong").
  • We wrap the original error with additional context using fmt.Errorf("additional context: %w", err).
  • The %w verb is used to wrap the original error. It allows us to attach the original error to the wrapped error.
  • We print the wrapped error and then unwrap it using errors.Unwrap to obtain the original error.
  • Finally, we check if the wrapped error contains the original error using errors.Is.


In Go, error handling strategies such as panic, recover, and error wrapping provide developers with powerful tools to handle exceptional situations gracefully. By understanding these mechanisms and incorporating them into your codebase, you can write more robust and reliable Go applications that gracefully handle errors and provide valuable context when things go wrong.

Debugging is like being the detective in a crime movie where you are also the murderer.
Happy coding! 🚀