为什么在golang的以下代码示例中switch匹配其他类型

Question

Link: https://play.golang.org/p/69I8PAuoAV

Extract:

package main

import "fmt"

type Stringer interface {
    String() string
}

type fakeString struct {
    content string
}

// function used to implement the Stringer interface
func (s *fakeString) String() string {
    return s.content
}

func printString(value interface{}) {
    switch str := value.(type) {
    case string:
        fmt.Println(str)
    case Stringer:
        fmt.Println(str.String())
    }
}

func main() {
    s := &fakeString{"Ceci n'est pas un string"}
    printString(s)
    printString("Hello, Gophers")

}

The printString(s) function call when reaching case matches the case Stringer part. s is of type *fakeString not Stringer. Why does it match Stringer.

I did a fmt.Println(reflect.TypeOf(str)) and it confirmed the type as *main.fakeString

Answer 1

This is interface satisfaction in golang.

There are two kinds of type in golang: interface type and concrete type.

• concrete type works exactly as you expected in switch: the variable is an instance of the given type
• interface type on the other hand works differently, it checks if the variable satisfies the interface.

Hum, safisfies? How does it work?

A (concrete) type satisfies an interface if it possesses all the methods the interface requires.

-- the golang programming language

In the case, Stringer is an interface, declaring only one method: String() string. And fakeString satisfies it by having its own String() string method.

Two things to note however:

1. concrete type can have many other methods, it still satisfies the interface if it possesses all methods declared in interface
2. the methods order does not matter, all that matters is the set of methods.