Go 语言的 Type Switch 语句解析

Tags:

讲述了Go语言中 Type Swith 的用法以及获取对应变量的一些特殊情况。

Type Switch 的基本用法

Type Switch 是 Go 语言中一种特殊的 switch 语句，它比较的是类型而不是具体的值。它判断某个接口变量的类型，然后根据具体类型再做相应处理。注意，在 Type Switch 语句的 case 子句中不能使用fallthrough。

它的用法如下。

switch x.(type) {
case Type1:
	doSomeThingWithType1()
case Type2:
	doSomeThingWithType2()
default:
	doSomeDefaultThing()
}

其中，x必须是一个接口类型的变量，而所有的case语句后面跟的类型必须实现了x的接口类型。

为了便于理解，我们可以结合下面这个例子来看:

package main

import (
    "fmt"
    "reflect"
)

type Animal interface {
    shout() string
}

type Dog struct {}

func (self Dog) shout() string {
    return fmt.Sprintf("wang wang")
}

type Cat struct {}

func (self Cat) shout() string {
    return fmt.Sprintf("miao miao")
}

func main() {
    var animal Animal = Dog{}

    switch animal.(type) {
    case Dog:
        fmt.Println("animal'type is Dog")
    case Cat:
        fmt.Println("animal'type is Cat")
    }
}

在上面的例子中，Cat和Dog类型都实现了接口Animal，所以它们可以跟在case语句后面，判断接口变量animal是否是对应的类型。

在Switch的语句表达式中声明变量

如果我们不仅想要判断某个接口变量的类型，还想要获得其类型转换后的值的话，我们可以在 Switch 的语句表达式中声明一个变量来获得这个值。

其用法如下所示:

package main

import (
	"fmt"
	"reflect"
)

type Animal interface {
	shout() string
}

type Dog struct {
	name string
}

func (self Dog) shout() string {
	return fmt.Sprintf("wang wang")
}

type Cat struct {
	name string
}

func (self Cat) shout() string {
	return fmt.Sprintf("miao miao")
}

type Tiger struct {
	name string
}

func (self Tiger) shout() string {
	return fmt.Sprintf("hou hou")
}

func main() {
	// var animal Animal = Tiger{}
	// var animal Animal  // 验证 case nil
	// var animal Animal = Wolf{} // 验证 default
	var animal Animal = Dog{}

	switch a := animal.(type) {
	case nil: // a的类型是 Animal
		fmt.Println("nil", a)
	case Dog, Cat: // a的类型是 Animal
		fmt.Println(a) // 输出 {}
		// fmt.Println(a.name) 这里会报错，因为 Animal 类型没有成员name
	case Tiger: // a的类型是 Tiger
		fmt.Println(a.shout(), a.name) // 这里可以直接取出 name 成员
	default: // a的类型是 Animal
		fmt.Println("default", reflect.TypeOf(a), a)
	}
}

在上述代码中，我们可以看到a := animal.(type)语句隐式地为每个case子句声明了一个变量a。

变量a类型的判定规则如下:

  • 如果case后面跟着一个类型，那么变量a在这个case子句中就是这个类型。例如在case Tiger子句中a的类型就是Tiger
  • 如果case后面跟着多个类型，那么变量a的类型就是接口变量animal的类型，例如在case Dog, Cat子句中a的类型就是Animal
  • 如果case后面跟着nil，那么变量a的类型就是接口变量animal的类型Animal，通常这种子句用来判断未赋值的接口变量
  • default子句中变量a的类型是接口变量animal的类型

为了更好地理解上述规则，我们可以用if语句和类型断言来重写这个switch语句，如下所示：

	v := animal   // animal 只会被求值一次
	if v == nil { // case nil 子句
		a := v
		fmt.Println("nil", a)
	} else if a, isTiger := v.(Tiger); isTiger { // case Tiger 子句
		fmt.Println(a.shout(), a.name)
	} else {
		_, isDog := v.(Dog)
		_, isCat := v.(Cat)
		if isDog || isCat { // case Dog, Cat 子句
			a := v
			fmt.Println(a)
			// fmt.Println(a.name)
		} else { // default 子句
			a := v
			fmt.Println("default", reflect.TypeOf(a), a)
		}
	}

参考链接

2018年02月03日 / 00:17