Switch和Select

一、两种类型

1）表达式Switch：case包含与switch表达式的值进行比较的表达式
2）类型Switch：case包含与特殊注释的switch表达式的类型进行比较的表达式

二、举例

1.类型Switch【不完整的类型switch】
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break

func main(){
　grade：=“B”
　switch marks:=90;marks{ //初始化switch语句
　case 90:
　　grade = "A"
　case 80:
　　grade = "B"
　case 60,70:
　　grade = "C"
　default:
　　grade = "D"
}
　fmt.printf(grade)
}

1.1）类型switch【完整的类型switch】

func main(){
　grade：=“E”
　marks：= 90
　switch {
　　case marks>90:
　　　grade = "A"
        case marks>=80:
            grade = "B"
        case marks>70:
            grade = "C"
        default:
            grade = "D"
}

switch{
        case grade == "A":
            fmt.printf("成绩优秀")
        case grade == "B":
            fmt.printf("成绩良好")
        【多表达式写法】
        case grade == "C"，grade == "D"：
            fmt.printf("成绩一般")
}
}

注意fallthrough 不会判断下一条 case 的表达式结果是否为 true，它把当前case控制权交由下一个case语句判断．但fallthrough不能用在最后一个分支，即不能用在default之前的一个分支上

*从匹配到的第一个分支开始计算，一直判断到倒数第二个分支*
case grade == "A":
    fmt.printf("成绩优秀")
    fallthrough
case grade == "B":
    fmt.printf("成绩良好")
　fallthrough
default:            
     fmt.Println("6、默认 case")    

1.2）类型Switch【类型switch的初始化自语句需要判断的变量必须是具有接口类型的变量】

var x interface{}
func main(){
    x=1 //修改x的值,查看返回结果的变化
    switch i :=x.(type){
        case nil:
            fmt.printf("这里是nil，x的类型是%T"，i)
        case int:
            fmt.printf("这里是int，x的类型是%T"，i)
        case float64:
            fmt.printf("这里是float64，x的类型是%T"，i)
        default:
            fmt.printf("未知类型")
}

三、select语句【这种选择语句用于配合通道（channel）的读写操作,用于多个channel的并发读写操作】
select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的

func main(){
    a:=make(chan int,1024)
    b:=make(chan int,1024)
    for i:=0;i<10;i++{
        fmt.printf("第%d次"，i)
        a<-1
        b<-1
        select{
            case<-a:
                fmt.println("from a")
            case<-b:
                fmt.println("from b")
        }
    }
}

每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：
如果有 default 子句，则执行该语句。
如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值

func main() {   
　var c1, c2, c3 chan int   
　var i1, i2 int   
　select {      
　　case i1 = <-c1:         
　　　fmt.Printf("received ", i1, " from c1\n")      
　　case c2 <- i2:         
　　　fmt.Printf("sent ", i2, " to c2\n")      
　　case i3, ok := (<-c3):  // same as: i3, ok := <-c3         
　　　if ok {            
　　　　fmt.Printf("received ", i3, " from c3\n")         
　　　} else {            
　　　　fmt.Printf("c3 is closed\n")         
　　　}      
　　　default:         
　　　　fmt.Printf("no communication\n")   
　　}    
}