流程控制

    也许是各种编程语言中最常见的了，它的语法概括起来就是：如果满足条件就做某事，否则做另一件事。

    Go里面if条件判断语句中不需要括号，如下代码所示

    Go的if还有一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了，如下所示

    1. // 计算获取值x,然后根据x返回的大小，判断是否大于10。
    2. if x := computedValue(); x > 10 {
    3.     fmt.Println("x is greater than 10")
    4. } else {
    5.     fmt.Println("x is less than 10")
    6. }
    7. //这个地方如果这样调用就编译出错了，因为x是条件里面的变量
    8. fmt.Println(x)

    多个条件的时候如下所示：

    1. if integer == 3 {
    2.     fmt.Println("The integer is equal to 3")
    3. } else if integer < 3 {
    4.     fmt.Println("The integer is less than 3")
    5. } else {
    6.     fmt.Println("The integer is greater than 3")
    7. }

    Go有goto语句——请明智地使用它。用goto跳转到必须在当前函数内定义的标签。例如假设这样一个循环：

    1. func myFunc() {
    2.     i := 0
    3. Here:   //这行的第一个词，以冒号结束作为标签
    4.     println(i)
    5.     i++
    6.     goto Here   //跳转到Here去
    7. }

    标签名是大小写敏感的。

    1. for expression1; expression2; expression3 {
    2.     //...
    3. }

    expression1、expression2和expression3都是表达式，其中expression1和expression3是变量声明或者函数调用返回值之类的，expression2是用来条件判断，expression1在循环开始之前调用，expression3在每轮循环结束之时调用。

    一个例子比上面讲那么多更有用，看看下面的例子吧：

    有些时候需要进行多个赋值操作，由于Go里面没有,操作符，那么可以使用平行赋值i, j = i+1, j-1

    有些时候如果忽略expression1和expression3：

    1. sum := 1
    3. }

    其中;也可以省略，那么就变成如下的代码了，这就是while的功能。

    1. sum := 1
    2. for sum < 1000 {
    3.     sum += sum
    4. }

    在循环里面有两个关键操作break和continue ,break操作是跳出当前循环，continue是跳过本次循环。当嵌套过深的时候，break可以配合标签使用，即跳转至标签所指定的位置，详细参考如下例子：

    1. for index := 10; index>0; index-- {
    2.     if index == 5{
    3.         break // 或者continue
    4.     }
    5.     fmt.Println(index)
    6. }
    7. // break打印出来10、9、8、7、6
    8. // continue打印出来10、9、8、7、6、4、3、2、1

    for配合range可以用于读取slice和map的数据：

    1. for k,v:=range map {
    2.     fmt.Println("map's key:",k)
    3.     fmt.Println("map's val:",v)
    4. }

    由于 Go 支持 “多值返回”, 而对于“声明而未被调用”的变量, 编译器会报错, 在这种情况下, 可以使用_来丢弃不需要的返回值

    例如

    有些时候需要写很多的if-else来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候switch就能很好的解决这个问题。它的语法如下

    1. switch sExpr {
    2. case expr1:
    3.     some instructions
    4. case expr2:
    5.     some other instructions
    6. case expr3:
    7.     some other instructions
    8. default:
    9.     other code
    10. }

    sExpr和expr1、、expr3的类型必须一致。Go的switch非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；而如果switch没有表达式，它会匹配true。

    1. i := 10
    2. switch i {
    3.     fmt.Println("i is equal to 1")
    4. case 2, 3, 4:
    5.     fmt.Println("i is equal to 2, 3 or 4")
    6. case 10:
    7.     fmt.Println("i is equal to 10")
    8. default:
    9.     fmt.Println("All I know is that i is an integer")
    10. }

    在第5行中，把很多值聚合在了一个case里面，同时，Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码。

    1. integer := 6
    2. switch integer {
    3. case 4:
    4.     fmt.Println("The integer was <= 4")
    5.     fallthrough
    6. case 5:
    7.     fmt.Println("The integer was <= 5")
    8.     fallthrough
    9. case 6:
    10.     fmt.Println("The integer was <= 6")
    11.     fallthrough
    12. case 7:
    13.     fmt.Println("The integer was <= 7")
    14.     fallthrough
    15. case 8:
    16.     fmt.Println("The integer was <= 8")
    17.     fallthrough
    18. default:
    19.     fmt.Println("default case")
    20. }
    1. The integer was <= 6
    2. The integer was <= 7
    3. default case