Go Error Handling

Error Handling

Now that you understand how to create custom errors and extract as much information as possible from errors, let's look at how to handle errors in functions.

Check For The Error

Most errors are not handled directly in functions but are instead returned as a return value. We can use the fact that Golang supports multiple return values for a function. As a result, you can return your error alongside the normal result of the function - errors are always returned as the last argument.

Example: 

package main
 
import (
    "fmt"
    "errors"
)


// function to return an error
func demonstrateErrorHandling( val int) (int, error) {  // declare return type here
    return val, errors.New("There seems to be an error!")  // return it here
}


//main function
func main(){
    getVal, ErrorOccurred := demonstrateErrorHandling(20) // call demonstrateErrorHandling(), it returns an error
    
    // ErrorOccurred value is not nil
    if ErrorOccurred != nil{
        // print the value of ErrorOccurred
        fmt.Println(ErrorOccurred)
    }else{
        fmt.Println("No error has occurred", getVal, ErrorOccurred)
    }
}

Output: 

There seems to be an error!

If the returned error is not nil, it usually indicates that there is a problem and that you must handle the error properly. Depending on the situation, this could mean using a log message to warn the user, retrying the function until it works, or closing the application entirely. The only disadvantage is that Go does not enforce handling returned errors, which means you could simply ignore handling errors entirely.

Defer

Defer statements in Go delay the execution of the function or method or an anonymous method until the nearby functions return. Defer statements are commonly used to ensure that files are closed when their use is no longer required, to close the channel, or to catch panics in the program.

Example: 

// Go program to illustrate the
// concept of the defer statement
package main


import "fmt"


// create three different functions to demonstrate defer
// the first function
func first(){
    fmt.Println("Printing from the first function...")
}


// the second function
func second(){
    fmt.Println("Printing from the second function...")
}


// This is the function which we wish to defer
func third(){
    fmt.Println("This is the critical section. I want to defer this.")
}
func main() {


defer third()
second()
first()
}

Output: 

Printing from the second function...
Printing from the first function...
This is the critical section. I want to defer this.

Explanation:

Although we call the third() function before the second() and first() in the main function, using defer statements will defer the execution of the third() function because of which the statement inside the third() function is printed at the end.

Panic and Recover

Panic is similar to exceptions in programming languages like Java. Panic is used to exit a program when it detects abnormal conditions. We use defer and recover to deal with panic.

Example of panic:

package main
import "fmt"


func main() {
    fmt.Println("Before Panic.")
    panic("panic occurred")
    fmt.Println("After panic")
}

Output: 

Before Panic.
panic: panic occurred

goroutine 1 [running]:
main.main()
/home/main.go:5 +0x96

For recovering from a panic, Go has a built-in function called recover. From the above example, we can see that the print statement after the panic keyword is not executed. The only function that gets executed after the panic is the deferred function. Therefore we must put our recover() function inside the deferred function to ensure that it gets executed.

Example of panic with recover:

package main


import (  
    "fmt"
)


// function to recover f2()
func recoverf2() {  
    if r := recover(); r!= nil {
        fmt.Println("recovered from ", r)
    }
}


// f2() function 
//it defers recoverf2()
// panic keyword is used to create a panic inside f2()
func f2() {  
    defer recoverf2()
    panic("Creating panic inside f2")
    fmt.Println("returned normally from f2")
}


// the main() function
func main() {  
    defer fmt.Println("deferred call in main")
    f2()
    fmt.Println("returned normally from main")
}

Output: 

recovered from  Creating panic inside f2
returned normally from main
deferred call in main

FAQs

1.What are errors in Go?

Errors are defined as unwelcome and unusual conditions that occur in the program. It can be at the compile or run time.

2. What are the two simple ways to create an error in Go?

The two ways are:

i. Using the New() function.

ii. Using fmt.Errorf() function.

3. Why is it important to handle the errors?

If the errors are not handled appropriately, the program will be very buggy resulting in an abrupt halting in execution.

4. What is defer?

Defer statements in Go delay the execution of the function or method or an anonymous method until the nearby functions return.

5. What is panic and recover() in Go?

Panic is used to exit a program when it detects abnormal conditions. The recover() function is a built-in Go function that is used inside a deferred function. It helps in recovering from panic.

Key Takeaways

In this article, we have extensively discussed errors and their handling in Go.

• Errors are defined as unwelcome and unusual conditions that occur in the program. It can be at the compile or run time.
• Most errors are not handled directly in functions but are instead returned as a return value.
• The only function that gets executed after the panic is the deferred function. Therefore we must put our recover() function inside the deferred function to ensure that it gets executed.

We hope that this blog has helped you enhance your knowledge regarding error handling and if you would like to learn more, check out our articles here. Do upvote our blog to help other ninjas grow. Happy Coding!