Go - Inspecting Errors

Problem: You want to check for specific errors or specific types of errors.

Solution: Use the errors.Is and errors.As functions. The errors.Is function compares an error to a value and the errors.As function checks if an error is of a specific type.

Using errors.Is
The errors.Is function is essentially an equality check. Let’s say you define a set of customized errors in your codebase — for example, ApiErr — which happens when a connection to an API encounters an error:

var   ApiErr   error   =   errors . New ( "Error  trying  to  get  data  from  API" )

Elsewhere in your code, you have a function that returns this error:

func   connectAPI ()   error   { 
      //  some  other  stuff  happening  here 
      return   ApiErr 
}

You can use errors.Is to check if the error returned is ApiErr :

err   :=   connectAPI () 
if   err   !=   nil   { 
      if   errors . Is ( err ,   ApiErr )   { 
          //  handle  the  API  error 
      } 
}

You can also verify if ApiErr is somewhere along the chain of wrapped errors. Take the example of a connect function that returns a ConnectionError that wraps around ApiErr :

func   connect ()   error   { 
      return   & ConnectionError { 
          Host :   "localhost" , 
          Port :   8080 , 
          Err :    ApiErr , 
      } 
}

This code still works because ConnectionError wraps around ApiErr :

err   :=   connect () 
if   err   !=   nil   { 
      if   errors . Is ( err ,   ApiErr )   { 
          //  handle  the  API  error 
      } 
}

Using errors.As
The errors.As function allows you to check for a specific type of error. Continue with the same example, but this time around, you want to check if the error is of the type ConnectionError :

err   :=   connect () 
if   err   !=   nil   { 
      var   connErr   * ConnectionError 
      if   errors . As ( err ,   & connErr )   { 
          log . Errorf ( "Cannot  connect  to  host  %s  at  port  %d" ,   connErr . Host , 
          connErr . Port ) 
      } 
}