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)
        }
    }
}

输出：

1
3
4
5

指定标签跳出 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)
        }
    }
}

输出：

1

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()
    }
}