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

Question

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

Answer 1

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.