Golang Defer Panic Recover With Examples Read it later

One of the features that sets Go apart from other programming languages is its support for defer, panic, and recover. These mechanisms provide a way to handle errors and perform cleanup tasks in a clean and efficient way. In this blog, we will explore and learn about Golang defer, panic and recover features and how they work.

What is Defer in Go?

Defer is a keyword in Go that allows you to delay the execution of a function until the surrounding function returns. It’s a way to ensure that some cleanup tasks are performed regardless of what happens in the function. The syntax is simple, you just need to add the defer keyword before the function call.

Here’s an example:

func main() {
    defer cleanup()
    // Do some work here
}

func cleanup() {
    // Perform cleanup tasks here
}

In this example, the cleanup function will be called when the main function returns, regardless of how it returns. This is useful for releasing resources, closing files, or any other cleanup tasks that need to be performed before the function returns.

It’s important to note that defer works in a last-in-first-out (LIFO) order, so if multiple defer statements are used, they will be executed in reverse order.

What is Panic in Golang?

Panic is another keyword in Go that causes a program to crash. It’s similar to throwing an exception in other programming languages. When a panic occurs, the program will stop executing and display an error message. This is usually not what you want to happen, but panic can be useful in some situations.

Here’s an example:

func main() {
    panic("Something went wrong!")
}

In this example, the program will crash and display the error message “Something went wrong!”. This can be useful for detecting unexpected errors and stopping the program before it causes more problems.

What is Recover in Go?

Recover is a built-in function in Go that allows you to recover from a panic. It’s similar to catching an exception in other programming languages. When a panic occurs, the program will stop executing, but if a recover function is called, the program will continue executing normally.

Here’s an example:

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

In this example, the defer statement creates an anonymous function that calls recover. If a panic occurs, the anonymous function will catch it and print the error message. The program will then continue executing normally and print “This code will never execute”.

It’s important to note that recover can only be called from within a deferred function. If it’s called from anywhere else, it will not catch the panic.

Putting it all Together

Now that we’ve covered the basics of defer, panic, and recover, let’s see how they can be used together in a practical example.

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from:", r)
        }
    }()
    file, err := os.Open("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    // Do some work with the file here
}

In this example, we open a file and perform some work with it. We use defer to ensure that the file is closed before the function returns, regardless of what happens. If an error occurs while opening the file, we use panic to stop the program and display the error message. The deferred function then catches the panic and prints the error message, allowing the program to continue executing normally.

Best Practices

While Golang defer, panic, and recover can be useful features, they should be used sparingly and with caution. Here are some best practices to keep in mind:

• Only use panic for unrecoverable errors. If an error can be handled, use an error return value instead.
• Only use recover in deferred functions. If it’s called from anywhere else, it will not catch the panic.
• Avoid using panic and recover in performance-critical code. They can have a significant impact on performance.
• Use defer to ensure that resources are released and cleanup tasks are performed.