这篇文章涵盖了Switch case语句与表达式和类型的各种语法实例。
Golang的Switch case语句
当我们有多个基于条件的代码块时，Switch case被用来执行一个特定的代码块。它是编写if-else块的一种替代语法。不像其他编程语言，如Java和C+，需要用break来停止其执行。Go语言在执行匹配的情况下会自动停止其执行。Break关键字是不需要的。
在Go编程语言中，有两种类型的开关：
- 表达式切换- 在这种情况下，切换表达式与案例表达式进行比较。
- 类型切换--切换表达式的类型与case表达式进行比较。
表达式切换
表达式切换用于比较表达式和case表达式的值。
下面是switch case的语法
switch (variable|boolean-expression|Integer type){
case boolean-expression | integer type
Block of code contains statements
case boolean-expression | integer type
Block of code contains statements
default: // default case and it is optional
Block of code contains statements
}
以下是表达式切换的主要内容：
- switch从上到下执行，当出现匹配的case时停止执行。 它包含任意数量的case语句，每个case语句包含表达式和冒号。当匹配的case没有被执行时，这将被执行。这是最后一个case，不需要break。
- Switch表达式和case表达式必须被评估为同一类型，否则会产生编译错误。例如，Switch表达式评估为float，而case只评估为float。
- case主体的大括号是可选的。
- 如果有许多匹配的案例，则执行第一个匹配的案例。
例子
下面是一个switch case语句的基本例子
在下面的例子中，Number被声明为值1。在switch中，number与所有case语句中的number的值进行比较。这里的案例从上到下进行评估。匹配的首先执行其代码块，在这个例子中，1被匹配，1被匹配的显示在控制台上。switch表达式可以用小括号和没有小括号的方式括起来--switch number或switch（number）都是允许的有效代码。
package main
import "fmt"
func main() {
number := 1
switch number {
case 1:
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
case 3:
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
}
输出是
1 matched
以下是switch情况的各种例子
在下面的代码中，重复的case被声明为相同的值-case 3被声明了两次。编译器给出了编译错误--在switch的前一个案例中重复了案例3。
package main
import "fmt"
func main() {
number := 1
switch number {
case 1:
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
case 3:
fmt.Println("3 matched")
case 3:// duplciate case is declared here - Compilation error
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
}
当匹配的情况没有被声明时的默认情况
当数字为10时，会发生什么呢？ 在同一个例子中，数字的匹配案例没有在代码中定义，因此默认案例将被执行，并打印出默认的匹配文本到控制台输出。
package main
import "fmt"
func main() {
number := 11
switch number {
case 1:
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
case 3:
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
}
上面的程序是
default matched
默认情况是一个可选的情况。它最好是最后一个case语句，但对switch case功能的方式没有影响。
没有表达式或条件的开关
switch也可以在没有表达式或条件的情况下声明。当没有使用表达式时，它将switch case视为一个真值。没有表达式或条件或值的switch总是等于switch true。
package main
import "fmt"
func main() {
number := 11
switch {
case number > 10:
fmt.Println("Number is greater than 10")
case number > 20:
fmt.Println("Number is greater than 20")
case number > 30:
fmt.Println("Number is greater than 30")
default:
fmt.Println("default matched")
}
}
并且程序代码的输出是
the number is greater than 10
当switch case中没有表达式时，case表达式必须为非常量。
package main
import "fmt"
func main() {
number := 11
switch {
case 1:
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
case 3:
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
}
上述代码无法编译 原因是没有表达式的switch代码应该有非常量的case 编译错误是**switch中无效的case 1（int和bool类型不匹配）**该命令的完整错误是go run filename。
.\First.go:8:2: invalid case 1 in switch (mismatched types int and bool)
.\First.go:10:2: invalid case 2 in switch (mismatched types int and bool)
.\First.go:12:2: invalid case 3 in switch (mismatched types int and bool)
.\First.go:14:2: invalid case 4 in switch (mismatched types int and bool)
开关的案例包含多个表达式或条件
案例中包含由逗号分隔的多个表达式
package main
import "fmt"
func main() {
weekday := "tuesday"
switch weekday {
case "monday", "tuesday", "wednesday", "thursday", "friday":
fmt.Println("Working Day")
default:
fmt.Println("Not working day: weekend")
}
}
上述程序的输出是
Working Day
上面的代码，代码检查工作日是否是工作日。案例中定义了多个字符串，这些字符串被声明为工作日。
案例主体中的fallthrough关键字
通常情况下，当switch case找到匹配的case时，匹配的case内的代码就会执行，控制就会从switch case中退出。fallthrough语句是一种特殊的功能，用于从下一个直接可用的case中跳转控制，fallthrough在golang中是一个关键字，因此它不会被用作变量或函数名。
package main
import "fmt"
func main() {
number := 1
switch number {
case 1:
fmt.Println("1 matched")
fallthrough
case 2:
fmt.Println("2 matched")
fallthrough
case 3:
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
}
上述程序的输出是
1 matched
2 matched
3 matched
没有fallthrough语句，输出为
1 matched
在上面的代码中，控制来到匹配的case，case 1被匹配，fallthrough语句存在，控制转移到下一个case 2语句的第一行代码中。
func main() {
number := 1
switch number {
case 1:
fallthrough // not allowed as first or middle - compilation error
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
fallthrough
case 3:
fmt.Println("3 matched")
case 4:
fmt.Println("4 matched")
default:
fmt.Println("default matched")
}
switch case 浮动值
switch和case表达式也可以用浮动值声明，并且是有效的代码。其他语言不支持在switch case表达式中使用。Golang在这方面没有问题。下面的程序包含了浮动的数字，与浮动值匹配的case被评估。在这种情况下，6.5的匹配值被打印到控制台。
func main() {
number := 6.5
switch number {
case 5.5:
fmt.Println("5.5 matched")
case 6.5:
fmt.Println("6.5 matched")
default:
fmt.Println("default matched")
}
}
和上述程序的输出是
6.5 matched
switch case String literals
允许的表达式也可以是字符串字面。字符串是用双引号括起来的一组字符。它检查字符串字面的精确匹配。在下面的代码中，Case包含字符串字面，Switch表达式包含字符串变量，对匹配的Case进行评估，输出为TWO匹配。
func main() {
number := "TWO"
switch number {
case "ONE":
fmt.Println("ONE matched")
case "TWO":
fmt.Println("TWO matched")
default:
fmt.Println("default matched")
}
}
上述程序的输出是
TWO matched
Break语句用于退出循环
break语句也可以用在switch case中。它被用来从switch内部的循环中退出。当你使用for循环和switch case时，break关键字将被使用。下面是一个没有break语句的例子，循环中迭代了3个值，在循环内部，声明了switch，并打印了匹配的case值。
func main() {
var numbArray = [3]int{1, 2, 5}
for _, numb := range numbArray {
switch numb {
case 1:
fmt.Println("1 matched")
case 2:
fmt.Println("2 matched")
break
case 0:
fmt.Println("0 matched")
}
}
}
输出是
1 matched
2 matched
现在我们将重写代码，在switch case语句中使用break和命名标签，在下面的循环代码中，对于第一个匹配的案例，使用break标签，它存在于命名标签中，只输出一个匹配的案例。
func main() {
var numbArray = [3]int{1, 2, 5}
MyLoopName:
for _, numb := range numbArray {
switch numb {
case 1:
fmt.Println("1 matched")
break MyLoopName
case 2:
fmt.Println("2 matched")
break
case 0:
fmt.Println("0 matched")
}
}
}
输出是
1 matched
函数可以在switch和case中作为表达式使用
表达式也可以是一个名为调用的函数，并在go语言中有效 以下是switch表达式中函数的一个例子。在下面的例子中，声明了一个简单的函数，它只是返回传递的参数，没有处理任何值。这被用在Switch表达式和case表达式中。
func myfunction(parameter string) string {
return parameter
}
func main() {
switch myfunction("mon") {
case myfunction("mon"), myfunction("tue"), myfunction("wed"), myfunction("thu"), myfunction("fri"):
fmt.Println("working day")
case myfunction("sat"), myfunction("sun"):
fmt.Println("Not working day: weekend")
}
}
输出是
working day
类型切换
类型切换主要用于接口中。 类型切换是做多重类型检查，并评估第一个匹配的类型案例。这些主要用于类型断言。表达式开关和类型开关之间的区别是：普通开关是比较值和案例值。类型开关比较的是类型而不是值与案例类型。
下面是一个类型转换的语法
switch variable.(type){
case type:
Code block statements
case type:
code block statements
default:
code block statements
}
variable.(type)表示类型断言，它包含特定的类型作为 "type"。 以下是类型切换表达式的关键点
- 你可以定义任意数量的case语句
- 在这个类型中定义的表达式总是界面类型变量的
- 和普通的开关表达式一样，缺省也是可选的，最后声明的时候不需要断句。
- 开关类型和案例类型必须是同一类型，或者遵循is-a原则。
- 当switch类型和case类型匹配时，匹配的case代码体被执行，从switch代码中退出，Break不是必需的。
开关类型断言接口的例子
在下面的例子中，interface()是一个空的接口类型，可以接受任何类型的值。
package main
import "fmt"
func main() {
var interfaceDemo interface{} = 45
switch interfaceDemo.(type) {
case string:
fmt.Println("string type matched")
case int:
fmt.Println("int type matched")
default:
fmt.Println("default type matched")
}
}
其输出是
int type matched
a type switch struct 示例
类型切换情况可用于struct数据类型。struct类型包含自定义类型，其中包含多种类型。
package main
import "fmt"
func main() {
type Employee struct {
ID int
Name string
}
emp := Employee{1, "Kiran"}
var empInterface interface{}
empInterface = emp
switch empInterface.(type) {
case Employee:
fmt.Println("Employee type matched")
case string:
fmt.Println("String type matched")
default:
fmt.Println("default type matched")
}
}
输出
Employee type matched
