Error_PHP tutorial on golang error handling

Golang error handling error. In golang error handling, errorgolang does not have an exception handling mechanism such as trycatch. it can only rely on the returned value to determine whether the status is incorrect (of course, it has a panicrecover mechanism, but generally only golang error handling
Golang does not have an exception handling mechanism such as try/catch. it can only rely on the return value to determine whether the status is wrong (of course, it has a panic/recover mechanism, but generally only handles unexpected errors ).

For the return value of a function, the convention is that the last parameter returns an error object to indicate the function running status.
For example:

1. N, err: = func ()
2. If err! = Nil {
3. ... // Process error
4. }

Or write it together

1. If n, err: = func (); err! = Nil {
2. ... // Process error
3. }

The error object can be constructed by errors. New () or fmt. Errorf.
For example:

1. Var pidedErr = errors. New ("Cant pided by 0 ")

Or

1. Err: = fmt. Errorf ("% d cant pided by 0", arg)

Let's take a look at the type of error.
Error is defined as an interface type in the standard library. this interface has only one Error () method:

1. Type error interface {
2. Error () string
3. }

That is to say, the custom structure only requires the Error () method, which is equivalent to implementing the error interface.


We can create a struct and implement the Error () method to construct an error object as needed.
For example:

 
 

  
  
type pision struct {
  
  
 arg int
  
  
 str string
  
  
}
  
  

  
  
func (e *pision) Error() string {
  
  
 return fmt.Sprintf("%d %s", e.arg, e.str)
  
  
}
  
  

  
  
func pideCheck(arg1, arg2 int) (error) {
  
  
 if arg2 == 0 {
  
  
 return &pision{arg1, "can't pided by 0"}
  
  
 }
  
  
 return nil
  
  
}
 
 

Let's look at an example to check whether a group of data cannot be divided (that is, the division number is 0). If yes, an error is returned.
The code is as follows:

 
 

  
  
package main
  
  

  
  
import "fmt"
  
  

  
  
func pideCheck(arg1, arg2 int) (error) {
  
  
 if arg2 == 0 {
  
  
 return fmt.Errorf("%d can't pided by 0", arg1)
  
  
 }
  
  
 return nil
  
  
}
  
  

  
  
func main() {
  
  
 var err error
  
  

  
  
 err = pideCheck(4, 2)
  
  
 if err != nil {
  
  
 fmt.Println(err)
  
  
 return
  
  
 }
  
  

  
  
 err = pideCheck(8, 0)
  
  
 if err != nil {
  
  
 fmt.Println(err)
  
  
 return
  
  
 }
  
  
}
 
 

We have implemented this function, but the code is not elegant. every execution of the evaluate function call should use at least three lines for error handling.

Here we will optimize it. The function we need to implement is that an error is returned as long as one number cannot be divided. You only need to store the status after each check to the internal status variable, and then check the variable after all processing is complete.
The code is as follows:

 
 

  
  
package main
  
  

  
  
import "fmt"
  
  

  
  
type pision struct {
  
  
 err error
  
  
}
  
  

  
  
func (this *pision)DivideCheck(arg1, arg2 int) {
  
  
 if this.err != nil {
  
  
 return
  
  
 }
  
  
 if arg2 == 0 {
  
  
 this.err = fmt.Errorf("%d can't pided by 0", arg1)
  
  
 return
  
  
 }
  
  
}
  
  

  
  
func (this *pision)Err() error {
  
  
 return this.err
  
  
}
  
  

  
  
func main() {
  
  
 d := new(pision)
  
  
 d.DivideCheck(4, 2)
  
  
 d.DivideCheck(8, 0)
  
  
 if d.Err() != nil {
  
  
 fmt.Println(d.Err())
  
  
 }
  
  
}
 
 

This code is much more elegant. before each check, you can determine whether the internal status has encountered an error and immediately return the error, with almost no performance loss.


Golang's error handling is often criticized, but if you know how to program in go mode, you can still do very elegantly ~

Zoogolang does not have an exception handling mechanism such as try/catch. it can only rely on the return value to determine whether the status is wrong (of course, it has a panic/recover mechanism, but generally only...