duandu2980
2019-01-23 03:52 阅读 84
已采纳

为什么Golang自定义错误变量具有多种类型

i'm a new gopher and got really confused by variable types, if i'm defining a custom error

    import (
        "fmt"
        "reflect"
    )

    // custom errors
    type myError struct {
        msg string
    }

    func (m *myError) Error() string {
        return m.msg
    }

    func errorGen() error {
        return &myError{"custom error"}
    }

generate a new error and check the type of it

    func main() {
        e := errorGen()
        fmt.Println(reflect.TypeOf(e).Kind()) // type = pointer

        // first type assertion
        _, ok := e.(error)
        if ok {
            fmt.Println("type assertion error") // type = error
        }

        // second type assertion
        _, ok = e.(*myError)
        if ok {
            fmt.Println("type assertion *myError") // type = pointer
        }
    }

so in above code variable 'e' shows 2 types at the same time. What exactly is e's type? and why "error" is an interface and also can be used as return type?

thank you very much

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

2条回答 默认 最新

  • 已采纳
    donglie1898 donglie1898 2019-01-23 06:36

    You have to differentiate between the "static type" and the "dynamic type" of a variable.

    Each and every variable in Go has exactly one static type. Some example:

    • After declaring a := 5 the static type of a is int and that is all to know about a.
    • The static type of e in your code is error(because that is what errorGen returns).
    • You can be explicit about the static type like this: var b uint16 = 9.

    Now there are interface types in Go. error is such an interface type, see Peter's answer. Some variables will have error as their static type; your e is an example. Now, the whole purpose of a variable of interface type is to store values of various types which implement this interface. So a interface variable which is not nil somehow "contains" an other variable (actually a value). The type of this contained value can be any one which implements the interface. The type of the contained value is the "dynamic type". Type assertion let you extract values of this dynamic type.

    点赞 评论 复制链接分享
  • doutun1875 doutun1875 2019-01-23 04:25

    The Go Programming Language Specification

    Errors

    The predeclared type error is defined as

    type error interface {
        Error() string
    }
    

    It is the conventional interface for representing an error condition, with the nil value representing no error.

    Interface types

    An interface type specifies a method set called its interface. A variable of interface type can store a value of any type with a method set that is any superset of the interface. Such a type is said to implement the interface.


    e implements the predeclared interface type error.

        // first type assertion
        _, ok := e.(error)
        if ok {
            fmt.Println("type assertion error") // type = error
        }
    

    e's concrete type is a pointer to type myError.

        // second type assertion
        _, ok = e.(*myError)
        if ok {
            fmt.Println("type assertion *myError") // type = pointer
        }
    

    Both type assertions are true (ok is true).

    点赞 评论 复制链接分享

相关推荐