Go从入门到放弃之流程控制

概述

流程控制主要用于设定计算执行的次序，建立程序的逻辑结构。Go 语言的流程控制和其他编程语言类似，支持如下几种流程控制语句：

• 条件语句：用于条件判断，对应的关键字有 if、else 和 else if；
• 分支语句：用于分支选择，对应的关键字有 switch、case 和 select（用于通道，后面介绍协程时会提到）；
• 循环语句：用于循环迭代，对应的关键字有 for 和 range；
• 跳转语句：用于代码跳转，对应的关键字有 goto。

一、条件语句

条件语句的示例模板如下：

// if
if condition { 
    // do something 
}

// if...else...
if condition { 
    // do something 
} else {
    // do something 
}

// if...else if...else...
if condition1 { 
    // do something 
} else if condition2 {
    // do something else 
} else {
    // catch-all or default 
}

一个简单的条件语句示例代码如下：

score := 100
if score > 90 {
    fmt.Println("Grade: A")
} else if score > 80 {
    fmt.Println("Grade: B")
} else if score > 70 {
    fmt.Println("Grade: C")
} else if score > 60 {
    fmt.Println("Grade: D")
} else {
    fmt.Println("Grade: F")
}

注意事项

关于 Go 语言的条件语句，需要注意以下几点：

• 条件语句不需要使用圆括号将条件包含起来 ()；
• 无论语句体内有几条语句，花括号 {} 都是必须存在的；
• 左花括号 { 必须与 if 或者 else 处于同一行；
• 在 if 之后，条件语句之前，可以添加变量初始化语句，使用 ; 间隔，比如上述代码可以这么写 if score := 100; score > 90 {

二、分支语句

分支语句会根据传入条件的不同，选择不同的分支代码执行。

Go 语言的分支语句和其他编程语言类似，只是不需要在每个分支结构中显式通过 break 语句退出：

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

通过分支语句改写if语句的示例代码：　　

score := 100
switch {
case score >= 90:
    fmt.Println("Grade: A")
case score >= 80 && score < 90:
    fmt.Println("Grade: B")
case score >= 70 && score < 80:
    fmt.Println("Grade: C")
case score >= 60 && score < 70:
    fmt.Println("Grade: D")
default:
    fmt.Println("Grade: F")
}

注意这个时候，不能把变量 score 放到 switch 关键字后面，否则会报错，只有在与 case 分支值判等的时候，才可以这么做：

score := 100
switch score {
case 90, 100:
    fmt.Println("Grade: A")
case 80:
    fmt.Println("Grade: B")
case 70:
    fmt.Println("Grade: C")
case 60:
case 65:
    fmt.Println("Grade: D")
default:
    fmt.Println("Grade: F")
}

合并分支

 在 Go 语言中，我们可以用逗号分隔不同的分支条件来达到合并分支语句的目的，如 case 90,100，而不能像其它语言那样，通过多个相邻的 case 语句来合并相同的分支语句

func testSwitch() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}

分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量

func switchDemo4() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好学习吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活着真好")
	}
}

fallthrough

fallthrough语法可以执行满足条件的case的下一个case，是为了兼容C语言中的case设计的。

func switchDemo5() {
	s := "a"
	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}
}

输出：
　　a
　　b

注意事项

在 Go 语言中使用 switch...case... 分支语句时，需要注意以下几点：

• 和条件语句一样，左花括号 { 必须与 switch 处于同一行；
• 单个 case 中，可以出现多个结果选项（通过逗号分隔）；
• 与其它语言不同，Go 语言不需要用 break 来明确退出一个 case；
• 只有在 case 中明确添加 fallthrough 关键字，才会继续执行紧跟的下一个 case；
• 可以不设定 switch 之后的条件表达式，在这种情况下，整个 switch 结构与多个 if...else... 的逻辑作用等同。

三、循环语句

for 循环

Go 语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构。关键字 for 的基本使用方法与其他语言类似，只是循环条件不含括号，比如我们要计算 1 到 100 之间所有数字之和，可以这么做：

//for 初始语句;条件表达式;结束语句{
//    循环体语句
//}

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

无限循环

Go 语言不支持 while 和 do-while 循环语句，对于无限循环场景，可以通过不带循环条件的 for 语句实现，下面我们通过无限循环来改写上述计算 1 到 100 以内数字之和的实现如下：

//for {
//    循环体语句
//}
// for循环可以通过break、goto、return、panic语句强制退出循环。

 

sum := 0
i := 0
for {
    i++
    if i > 100 {
        break
    }
    sum += i
}
fmt.Println(sum)

for-range 结构

Go 语言还支持通过 for-range 结构对其进行循环遍历,一下为示例

遍历切片
a := []int{1, 2, 3, 4, 5, 6} 
for k, v := range a {
    fmt.Println(k, v)
}


忽略索引/键
for _, v := range a {
    fmt.Println(v)
}

忽略元素值
for k := range a {
    fmt.Println(k)
}

基于条件判断进行循环

基于条件判断进行循环，只有满足指定的条件才会执行循环体中的代码　　

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

goto

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

func gotoDemo1() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外层for循环判断
		if breakFlag {
			break
		}
	}
}

使用goto语句能简化代码：

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}

四、注意事项

在 Go 语言中使用循环语句时，需要注意以下几点：

• 和条件语句、分支语句一样，左花括号 { 必须与 for 处于同一行；
• 不支持 whie 和 do-while 结构的循环语句；
• 可以通过 for-range 结构对可迭代集合进行遍历；
• 支持基于条件判断进行循环迭代；
• 允许在循环条件中定义和初始化变量，且支持多重赋值；
• Go 语言的 for 循环同样支持 continue 和 break 来控制循环，但是它提供了一个更高级的 break，可以选择中断哪一个循环，如下例：

JLoop: 
for j := 0; j < 5; j++ { 
    for i := 0; i < 10; i++ { 
        if i > 5 { 
            break JLoop
        }
        fmt.Println(i)
    } 
}