Switch 是 Go 语言中一种多路条件语句，一般搭配 case 语句使用。

执行逻辑

一个 switch case 条件结构如下所示：

switch simpleStatement; condition {
	case expression1,expression2:
		statements
	case expression3:
		statements
	default:
		statements
	}

和 if 语句类似，switch 语句也可以在条件语句之前执行一段简短的表达式（可以用于很方便的控制变量的作用域），switch case 开始执行时，会先执行这一个表达式（空也算一种），然后计算出条件语句的值，接着按从上到下，从左到右的顺序一个一个的执行 case 语句的条件表达式，如果值相等的话就会进入执行 case 条件下对应的语句。如果所有的 case 条件都没有能匹配上的话，然后就会尝试执行 default 下对应的逻辑。

case 条件合并

如果有时候多个 case 条件对应的处理逻辑是一样的话，Go 语言中的 case 条件是可以合并的，多个条件用逗号分隔，判断顺序是从左到右。

func main()  {
	switch runtime.GOOS {
	case "linux","darwin" :
		println("unix环境")
	case "windows":
		println("windows环境")
	}
}

支持的类型

不像 Java 只支持整型进行判断（其他类型都是通过转化成整型实现的），Go 里的 switch 的参数是一个表达式，支持任何类型进行比较，甚至 switch 的条件还可以是一个空的，这个时候等价于 switch true，可以用于简化多个 if 条件的场景。

func price(weight int) int  {
	if weight > 10 {
		return 100
	} else if weight > 8 {
		return 110
	} else if weight > 5 {
		return 120
	} else {
		return 150
	}
}

比如上方这个多重 if else 判断逻辑就可以用下方这个无参数的 switch case 语句替代：

func price(weight int) int  {
	switch  {
	case weight>10:
		return 100
	case weight>8:
		return 110
	case weight>5:
		return 120
	default:
		return 150
	}
}

隐式 break & fallthrough

Go 语言中匹配到一个 case 条件执行完对应的逻辑之后就会跳出这个 switch 语句，等价于每个 case 处理逻辑之后都加了一个隐式的 break 语句。如果不想要隐式退出的话可以使用 fallthrough 语句来继续下一个 case 的处理逻辑。隐式 break：

func main()  {
	switch runtime.GOOS {
	case "linux","darwin" :
		println("unix环境")
	case "windows":
		println("window环境")
	default:
		println("什么都不是")
	}
}

输出：

windows环境

强行 fallthrough：

func main()  {
	switch runtime.GOOS {
	case "linux","darwin" :
		println("unix环境")
		fallthrough
	case "windows":
		println("windows环境")
		fallthrough // 会继续执行下一个语句
	default:
		println("什么都不是")
	}
}

输出：

windows环境
什么都不是

不过这一点就和很多其他编程语言正好相反，比如：Java、C++。Java 和 C++ 中的 switch case 都是隐式 fallthrough，而break 则需要显示调用，这两种方式各有利弊吧，还是看不同的使用场景，不过 Java 12 中也加入了对于隐式 break 的支持。另外 Go 语言中也是可以显示调用 break 提前跳出的，用法和循环语句中的 break 是一样的，也可以加标签指定跳出具体哪一段逻辑。 break 显式跳出：

func main() {
	x := []int{1,2,3,4,5}
	for _, i := range x {
		switch  {
		case i>0 :
			if i > 1 && i < 3 {
				break
			}
			println(i)
		}
	}
}

输出：

指定标签跳出 for 循环：

func main() {
	x := []int{1,2,3,4,5}
	a:
	for _, i := range x {
		switch  {
		case i>0 :
			if i > 1 && i < 3 {
				break a
			}
			println(i)
		}
	}
}

输出：

Type Switch

Go 语言中的 switch 条件还可以是一种类型，这个特性在一个变量可能是多种类型时非常有用，虽然也可以 if else 加上类型断言来实现：

func main() {
	i := interface{}(123)
	if _,ok := i.(int);ok{
		println("int")
	}else if _,ok := i.(int64);ok {
		println("int64")
	}else if _,ok := i.(string);ok {
		println("string")
	}
}

但是用 Type Switch 的话代码会更简洁一些，比如上面的逻辑用 Type Switch 重写：

func main() {
	i := interface{}(123)
	switch i.(type) {
	case int:
		println("int")
	case int64:
		println("int64")
	case float64:
		println("float64")
	}
}

输出：

int

（注：这里 123 是 int 类型而不是 int64，因为在申明变量时并没有指定具体类型，编译器会自行推导类型，而 int 是无类型整形的默认类型。）同时 Type Switch 可以给赋值给一个变量，这个变量在不同的 case 中会变成对应 case 条件的类型（在合并了 case 语句之后会失效）

func main() {
	var i interface{}
	switch x := i.(type) {
	case error:
		x.Error()
	case fmt.Stringer:
		x.String()
	}
}

Anonymous' Blog

执行逻辑

case 条件合并

支持的类型

隐式 break & fallthrough

Type Switch