Go起步:7、流程控制

流程控制是改变程序运行顺序的指令，可能是运行不同位置的指令，或是在二段（或多段）程序中选择一个运行。程序设计语言的流程控制语句，用于设定计算执行的次序，建立程序的逻辑结构。可以说， 流程控制语句是整个程序的骨架。

条件语句

条件判断是依指定变量或表达式的结果，决定后续运行的程序，可以根据指定条件是否成立，决定后续的程序。
对于 Go条件语句，提供了两种方式：

1. 单一条件判断：if-else，也可以组合多个if-else指令，进行较复杂的条件判断。
2. 多选一条件判断：switch-case。

if else

Go的if语句由一个布尔表达式后紧跟一个或多个语句组成。if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
通常格式为：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

其中，Go 的 if 语句表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。同时 {必须紧跟在if语句，不可换行，否则编译或报错–missing condition in if statement。

如下代码：

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    a := 10

    /* 使用 if 语句判断布尔表达式 */
    if a < 20 {
        /* 如果条件为 true 则执行以下语句 */
        fmt.Printf("a 小于 20\n")
    } else {
        /* 如果条件为 false 则执行以下语句 */
        fmt.Printf("a 不小于 20\n")
    }
    fmt.Printf("a 的值为 : %d\n", a)
}

除此之外，Go的 if 或 else if 语句可以嵌入一个或多个 if 或 else if 语句。

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 100
    var b int = 200

    /* 判断条件 */
    if a == 50 {
        fmt.Printf("a 值为: %d\n", a)
    } else if a == 100 {
        /* if 条件语句为 true 执行 */
        if b == 200 {
            /* if 条件语句为 true 执行 */
            fmt.Printf("a 的值为 100 ， b 的值为 200\n")
        }
    }
    fmt.Printf("a 值为 : %d\n", a)
    fmt.Printf("b 值为 : %d\n", b)
}

if 的简短语句

if 语句可以在条件表达式前执行一个简单的语句。

package main

import (
    "fmt"
    "math"
)

func pow(x, n, lim float64) {
    if v := math.Pow(x, n); v < lim {
        fmt.Printf("1.math.Pow(%f, %f):%f \n", x, n, v)
    } else {
        fmt.Printf("2.math.Pow(%f, %f):%f \n", x, n, v)
    }
    fmt.Println(lim)
}

func main() {
    pow(3, 2, 10)
    pow(3, 3, 20)
}

这里在if判断表达式之前定义了一个变量v并初始化赋值。需要说明的是该语句声明的变量作用域仅在 if 之内。

switch case

Go的switch和其他语言功能基本一致，都是用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。
具体语法也有Go的特色：

1. 首先匹配项后面也不需要再加break
2. switch后面的表达式不是必须的
3. case 里可以写表达式
4. 单个case中，可以出现多个结果选项
5. 左花括号{必须与switch处于同一行。这点在Go里很普遍

6. 有一个特殊关键字fallthrough，当且仅当在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case

   一般情况，Go 编程语言中 switch 语句的语法如下：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var grade string = "B"
    var marks int = 90

    switch marks {
    case 90:
        grade = "A"
    case 80:
        grade = "B"
    case 50, 60, 70:
        grade = "C"
    default:
        grade = "D"
    }

    switch {
    case grade == "A":
        fmt.Printf("优秀!\n")
    case grade == "B", grade == "C":
        fmt.Printf("良好\n")
    case grade == "D":
        fmt.Printf("及格\n")
    case grade == "F":
        fmt.Printf("不及格\n")
    default:
        fmt.Printf("差\n")
    }
    fmt.Printf("你的等级是 %s\n", grade)
}

上面第一个switch中，和其他常见语言中的语法上switch基本一致。在第二个中就比较具有Go的特色。switch后面没有表达式，case语句也可以使用表达式来判断

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var grade string = "B"

    switch {
    case grade == "A":
        fmt.Printf("优秀!\n")
        fallthrough
    case grade == "B", grade == "C":
        fmt.Printf("良好\n")
        fallthrough
    case grade == "D":
        fmt.Printf("及格\n")
    case grade == "F":
        fmt.Printf("不及格\n")
        fallthrough
    default:
        fmt.Printf("差\n")
    }
    fmt.Printf("你的等级是 %s\n", grade)
}

可以看出，语句成立后，如果加了fallthrough，下一条case就会被执行。

循环语句

Go语言中的循环语句只支持for关键字，不支持while和do-while 结构，可是有些写法却可是实现类似功能。关键字for的基本使用方法与C和C++中非常接近。
基本的 for 循环由三部分组成，它们用分号隔开：

• 初始化语句：在第一次迭代前执行
• 条件表达式：在每次迭代前求值
• 后置语句：在每次迭代的结尾执行

基本形式

Go语言的for循环有3中形式

1、for init; condition; post { }

注意条件语句也是不需要（）的。

package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i <= 100; i++ {
        sum += i
    }
    fmt.Println(sum)
}

上面代码实现了1加到100的运算。

2、for condition { }

这个实现的有些像 while ，只要条件成立就一直执行。

package main

import "fmt"

func main() {

    var b int = 15
    var a int = 10

    for a < b {
        a++
        fmt.Printf("a 的值为: %d\n", a)
    }

}

3、for { }

这样定义，实际上就是无限循环了。如果省略循环条件，该循环就不会结束。
对于for的条件，还可以使用range 格式可以对 slice、map、数组、字符串等进行迭代循环。

for的range

for key, value := range oldMap {
    newMap[key] = value
}

package main

import "fmt"

func main() {

    numbers := [6]int{1, 2, 3, 5}

    for i, x := range numbers {
        fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
    }

}

循环控制语句

GO 语言支持以下几种循环控制语句：

• break 语句 经常用于中断当前 for 循环或跳出 switch 语句

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 10

    /* for 循环 */
    for a < 20 {
        fmt.Printf("a 的值为 : %d\n", a)
        a++
        if a > 15 {
            /* 使用 break 语句跳出循环 */
            break
        }
    }
}

- continue 语句 跳过当前循环的剩余语句，然后继续进行下一轮循环。

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 10

    /* for 循环 */
    for a < 20 {
        if a == 15 {
            /* 跳过此次循环 */
            a = a + 1
            continue
        }
        fmt.Printf("a 的值为 : %d\n", a)
        a++
    }
}

可以看到，15没有被打出来。
- goto 语句 将控制转移到被标记的语句。也称成为跳转语句。
但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 10

    /* 循环 */
LOOP:
    for a < 20 {
        if a == 15 {
            /* 跳过迭代 */
            a = a + 1
            goto LOOP
        }
        fmt.Printf("a的值为 : %d\n", a)
        a++
    }
}