Google erross의 Is와 As를 조사했습니다.

erross의 Is, As는?

errors.Is란?

package main  
  
import (  
   "errors"  
 "fmt")  
  
type myError struct {  
   s string  
}  
  
func (obj *myError) Error() string {  
   return ""  
}  
  
type myErrorImplementedIs struct {  
   s string  
}  
  
func (obj *myErrorImplementedIs) Is(err error) bool {  
   return true  
}  
  
func (obj *myErrorImplementedIs) Error() string {  
   return ""  
}  
  
func main() {  
   // 比較可能で同じオブジェクトを返す場合は真  
 {  
      err := &myError{s:"hoge"}  
      fmt.Println(errors.Is(err, err))  
   }  
  
   // 比較可能でもオブジェクトが違えば偽  
 {  
      err := &myError{s:"hoge"}  
      target := errors.New("hoge")  
      fmt.Println(errors.Is(err, target))  
   }  
  
  // オブジェクトが違っていてもerrにIsが実装されていればそれを返す  
  {  
      err := &myErrorImplementedIs{s:"hoge"}  
      target := errors.New("hoge")  
      fmt.Println(errors.Is(err, target))  
   }  
  
  // Unwrapが実装されていれば返り値が比較可能かIsで判定する  
  // errのwrapのどれかに同一のオブジェクトか真を返すIsがあれば通る  
  {  
      target := &myError{s:"hoge"}  
      err := fmt.Errorf("%w",target)  
      fmt.Println(errors.Is(err, target))  
   }  
}

errors.Is의 내용

func Is(err, target error) bool {  
   if target == nil {  
      return err == target  
   }  
  
   isComparable := reflectlite.TypeOf(target).Comparable()  
   for {  
	  if isComparable && err == target {  
		 return true  
	  }  
	  if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {  
		 return true  
	  }  
    　if err = Unwrap(err); err == nil {  
	   　return false  
	　}
   }  
}

비교 가능한 판단

isComparable := reflectlite.TypeOf(target).Comparable() 

if isComparable && err == target {  
	return true  
}  

err Is 메소드 보유 시

if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {  
	return true  
}  

err Unwrap, nil을 반납하면 끝이에요.

if err = Unwrap(err); err == nil {
	return false
}

func Unwrap(err error) error {  
   u, ok := err.(interface { Unwrap() error })  
   if !ok {  
      return nil  
   }  
   return u.Unwrap()  
}

error.As란 무엇입니까?

package main

import (
	"errors"
	"fmt"
)

type myError struct {}

func (obj *myError) Error() string {
	return "myError"
}

type myErrorAs struct {}

func (obj *myErrorAs) Error() string {
	return "myErrorAs"
}

func (obj *myErrorAs) As(_ interface{}) bool {
	return true
}


func main() {
	// targetがinterfaceだと全てにmatchするので真
	{
		err := &myError{}
		var target interface{}
		fmt.Println(errors.As(err,&target))
	}

	// targetが同一の型なら代入可能なので真
	{
		err := &myError{}
		var target *myError
		fmt.Println(errors.As(err,&target))
	}

	// errがAsを実装されている場合はそこで判定
	// この場合err.Asが常に真
	{
		err := &myErrorAs{}
		var target *myError
		fmt.Println(errors.As(err,&target))
	}
}

errors.As의 내용

func As(err error, target interface{}) bool {  
   if target == nil {  
      panic("errors: target cannot be nil")  
   }  
   val := reflectlite.ValueOf(target)  
   typ := val.Type()  
   if typ.Kind() != reflectlite.Ptr || val.IsNil() {  
      panic("errors: target must be a non-nil pointer")  
   }  
   targetType := typ.Elem()  
   if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {  
      panic("errors: *target must be interface or implement error")  
   }  
   for err != nil {  
      if reflectlite.TypeOf(err).AssignableTo(targetType) {  
         val.Elem().Set(reflectlite.ValueOf(err))  
         return true  
 }  
      if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {  
         return true  
 }  
      err = Unwrap(err)  
   }  
   return false  
}

if target == nil {  
   panic("errors: target cannot be nil")  
}

val := reflectlite.ValueOf(target)  
typ := val.Type()  
if typ.Kind() != reflectlite.Ptr || val.IsNil() {  
   panic("errors: target must be a non-nil pointer")  
}

targetType := typ.Elem()  
if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {  
   panic("errors: *target must be interface or implement error")  
}

대입 가능 여부를 판단하다

for err != nil {  
   if reflectlite.TypeOf(err).AssignableTo(targetType) {  
      val.Elem().Set(reflectlite.ValueOf(err))  
      return true  
   }  
   if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target)  {  
      return true  
   }  
   err = Unwrap(err)  
}

총결산