[Go]条件语句

package main

import (
    "io/ioutil"
    "fmt"
)

//条件语句
//if的条件语句不需要括号
//if的条件里可以赋值，if的条件里赋值的变量作用域就在这个if语句里
//switch会自动break,除非使用fallthrough

func grade( score int ) string {
    g := ""
    switch  {  //switch里面可以没有表达式
    case score < 0 || score >100:
        panic(fmt.Sprintf( "Wrong score: %d", score) )  //中断程序执行，报错
    case score < 60:
        g = "F"
    case score < 80:
        g = "C"
    case score < 90:
        g ="B"
    case score <= 100:
        g ="A"
    }
    return g
}

func main() {
    const filename = "abc.txt"
/*  contents, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Println(err)
    }else {
        fmt.Printf("%s
", contents)
    }*/
    //或者也可以用写成下面这样
     if contents, err := ioutil.ReadFile(filename); err != nil{   //contents和err 定义在if里，生存期只在if里面才有
         fmt.Println(err)  //open abc.txt: The system cannot find the file specified.
     }else {
         fmt.Printf("%s
", contents)
     }

     fmt.Println(
         grade( 0 ),  //F
         grade( 59),  //F
         grade( 99),  //A
         grade(100),  //A
     )
}

 

上面介绍了switch语句中switch表达式和case表达之间有着怎样的联系？

　　switch表达式的结果值与某个case表达式中任意一个子表达式的结果值相等，该case表达式所属的case子句就会被选中，并且一旦某个case子句被选中，其中的附带在case表达式后边的那些语句就会被执行，同时其他的所以case子句都会被忽略（如果被选中的Case子句附带的语句列表中包含了fallthrough语句，那么紧挨在它下边的那个case子句附带的语句也会被执行） 

　　正因为存在判断相等的操作，switch语句对switch表达式的结果类型，以及各个Case表达式中子表达式的结果类型都是有要求的（Go语言中，只有类型相同的值之间才有可能被允许进行判等操作）

    value1 := [...]int8{0, 1, 2, 3, 4, 5, 6}
    switch 1 + 3 { // 这条语句无法编译通过。
    case value1[0], value1[1]:
        fmt.Println("0 or 1")
    case value1[2], value1[3]:
        fmt.Println("2 or 3")
    case value1[4], value1[5], value1[6]:
        fmt.Println("4 or 5 or 6")
    }

　　上面的代码中，1+3的求值结果是无类型的常量4，这个常量会被自动地转换为此种常量的默认类型的值，比如整数4的默认类型是int，浮点数3.14的默认类型是float64

　　因此上面的switch表达式的结果类型是int，而那些case子表达式的结果类型却是int8，它们类型不同，是无法通过编译的

　　再看下面这段代码的switch表达式的结果值是int8类型的，那些case表达式中的结果值是无类型的常量，却是可以编译的

    value2 := [...]int8{0, 1, 2, 3, 4, 5, 6}
    switch value2[4] {
    case 0, 1:
        fmt.Println("0 or 1")
    case 2, 3:
        fmt.Println("2 or 3")
    case 4, 5, 6:
        fmt.Println("4 or 5 or 6")

　　这是因为如果case表达式中子表达式的结果值是无类型的常量，那么它的类型会被自动地转换为swicth表达式的结果类型，又由于上述那几个整数都可以被转换为int8类型的值么，所以对这些表达式的结果值进行判等操作是没有问题的

　　即Swicth语句会进行有限的类型转换，但不能保证这种转换可以统一它们的类型

switch语句对它的case表达式还有哪些约束？

　　1）switch语句不允许case表达式中的子表达式结果值存在相等的情况

    value3 := [...]int8{0, 1, 2, 3, 4, 5, 6}
    switch value3[4] { // 这条语句无法编译通过。
    case 0, 1, 2:
        fmt.Println("0 or 1 or 2")
    case 2, 3, 4:
        fmt.Println("2 or 3 or 4")
    case 4, 5, 6:
        fmt.Println("4 or 5 or 6")
    }

　　但是这个约束只针对结果值为常量的子表达式，比如1+1和2不能同时出现。但是也就可以想办法绕过这个对子表达式的限制了，下面的代码就可以绕过限制

    value5 := [...]int8{0, 1, 2, 3, 4, 5, 6}
    switch value5[4] {
    case value5[0], value5[1], value5[2]:
        fmt.Println("0 or 1 or 2")
    case value5[2], value5[3], value5[4]:
        fmt.Println("2 or 3 or 4")
    case value5[4], value5[5], value5[6]:
        fmt.Println("4 or 5 or 6")
    }

　　但是上面这种绕过方式对用于类型判断的switch语句无效，因为类型switch语句中的case表达式的子表达式必须直接由类型字面量表示，而无法通过间接的方式表示。

    value6 := interface{}(byte(127))
    switch t := value6.(type) { // 这条语句无法编译通过。
    case uint8, uint16:
        fmt.Println("uint8 or uint16")
    case byte:
        fmt.Printf("byte")
    default:
        fmt.Printf("unsupported type: %T", t)
    }

　　这里byte是uint8类型的别名类型，它们本质上是同一个类型，只是类型名称不同，因此是无法通过编译的