Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of what the error handling method of Go language is, the content is detailed and easy to understand, the operation is simple and fast, and it has a certain reference value. I believe you will gain something after reading this article on error handling of Go language. Let's take a look at it.

Construct error

In the go language, there is a predefined interface: error, which comes with an Error () method that returns a string when called.

Type error interface {Error () string}

Calling this method returns the specific result of the current error. There are generally several ways to generate error.

Errors.New ()

Fmt.Errorf ()

Errors.New ()

Calling errors.New () returns a structure of type error, which implements an Error () method, and the result returned by calling this method is the content passed in when the errors.New () method is called.

Import ("errors"fmt") func divide (a, b int) (error, int) {if b = = 0 {/ / the divisor is 0, then construct an error structure return errors.New ("the divisor cannot be 0"), 0} var result = a / b return nil, result} func main () {var err error / / error type data initial value is nil Similar to null var result int err in js, result = divide (1,0) if err = = nil {/ / if err is nil, normal fmt.Println ("calculation result", result)} else {/ / if err is not nil, run error / / call Error method of error structure, output error reason fmt.Println ("calculation error", err.Error ())}}

As you can see, in the above code, because when the divide division method is called, the divisor passed in is 0. After judgment, a structure of type error constructed by errors.New is thrown.

We output the result returned by calling the error.Error () method to the console, and we can find that the result returned is the value passed in to the New method.

The implementation results are as follows:

Fmt.Errorf ()

The error structure constructed by the fmt.Errorf () method is similar to the result of calling the errors.New () method. The difference is that the fmt.Errorf () method formats the data once.

Func divide (a, b int) (error, int) {if b = = 0 {/ / the parameter is formatted once, and the formatted string is put into error return fmt.Errorf ("data% d is invalid", b), 0} var result = a / b return nil, result} err, result: = divide (1,0) fmt.Println ("calculation error", err.Error ())

The implementation results are as follows:

Panic () and recover ()

Panic ()

Panic () is equivalent to actively stopping the program, and when calling panic (), you need to pass in the interrupt reason. After the call, the reason for the interrupt and the call stack at the time of the interrupt are output on the console. We can modify the previous code:

Func divide (a, b int) (error, int) {if b = = 0 {/ / if the program goes wrong, stop running panic directly ("the divisor cannot be 0")} var result = a / b return nil, result} func main () {err, result: = divide (1,0) fmt.Println ("calculation error", err.Error ())}

When running to panic (), the program is interrupted directly, and the reason for the interruption is printed on the console.

Panic () can be understood as the operation of throw new Error () in the js program. So, is there any way in go to stop panic (), which is similar to try-catch, and get the program back to normal running logic?

Recover ()

Before introducing the recover () method, you need to introduce another keyword in the go language: defer.

Statements after defer are called before the function performs return operations, and are often used for resource release, error trapping, and log output.

Func getData (table, sql) {defer disconnect () db: = establish connection (table) data: = db.select (sql) return data}

The statements after defer are stored in a stack-like data structure. At the end of the function, the defined statements are unstacked sequentially, and the later defined statements are called first.

Func divide (a, b int) int {defer fmt.Println ("divisor", b) defer fmt.Println ("divisor", a) result: = a / b fmt.Println ("result is", result) return result} divide (10,2)

In the above code, when the function starts to run, we first define two output statements through defer, first output the divisor, and then output the divisor.

The actual running result is:

Output the calculation results first

Then output the divisor.

Final output divisor

As mentioned earlier, statements defined by defer will be executed off the stack at the end of the function, defined first and then executed. Defer will not only execute at the end of the function, but also follow the logic of defer when an exception occurs, that is, after we call the panic () method, when the program is interrupted, we will also run the statements in defer first.

Here we redefine the previous divide function, adding a defer statement before execution, followed by a self-executing function in which the recover () method is called.

After the recover () method is called, the exception thrown by the current panic () is caught and returned, or nil is returned if there is no exception.

Before func divide (a, b int) int {/ / is interrupted, the statement defer func () {if err: = recover () defined after calling defer Err! = nil {fmt.Println ("catch error", err)} () if b = 0 {/ / function operation interrupted panic ("Divisor cannot be 0") return 0} return a / b} result: = divide (1,0) fmt.Println ("calculation result", result)

After the above code runs, we find that the program that was interrupted by calling panic () has been restored, and the later calculation results have been output normally.

This is somewhat similar to the logic of try-catch, except that recover needs to be placed in the statement after the defer keyword, more like the combination of catch and finally.

This is the end of the article on "what is the error handling of the Go language?" Thank you for reading! I believe that everyone has a certain understanding of the knowledge of "what is the error handling of Go language". If you want to learn more knowledge, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.