Golang开发之流程控制
1. 条件判断(if)
Go语言if条件判断格式如下：
if 表达式1 {
分支1
} else if 表达式2 {
分支2
} else {
分支3
}
Go 规定与 if 匹配的左括号 “{” 必须与 if 和表达式放在同一行，如果尝试将“{”放在其它位置，将会触发编译错误，同理else也是。
举例：
var ten int = 11
if ten > 10 {
fmt.Println(">10")
} else {
fmt.Println("<=10")
}
特殊写法：
可以在if表达式之前添加一个执行语句，再根据变量值进行判断：
if err := Connect(); err != nil {
fmt.Println(err)
return
}
err != nil 才是 if 的判断表达式，当 err 不为空时，打印错误并返回。
2. 构建循环(for)
for 循环格式如下：
for 初始语句;条件表达式;结束语句{
循环体代码
}
结束语句为最后执行。
2.1. for 中的初始语句一一开始循环时执行的语句
初始语句是在第一次循环前执行的语句，其作用域将被局限在这个for的范畴内。
初始语句可以被忽略，但是初始语句之后的分号必须要写：
step := 2
for ; step > 0; step-- {
fmt.Println(step)
}
这段代码for中没有初始语句，此时step的作用域就比在初始语句声明step要大。
2.2. for 中的条件表达式－一控制是否循环的开关
2.2.1. 结束循环时带可执行语句的无限循环
var i int
for ; ; i++ {
if i > 10 {
break
}
}
2.2.2. 无限循环
var i int
for {
if i > 10 {
break
}
i++
}
2.2.3. 只有一个循环条件的循环
var i int
for i <= 10{
i++
}
3. 示例：九九乘法口诀表
for y := 1; y <= 9; y++ {
for x := 1; x <= y; x++ {
fmt.Printf("%d * %d = %d ", x, y, x*y)
}
fmt.Println()
}
4. 键值循环（ for range ）一一直接获得
Go 语言可以使用 for range 遍历数组、切片、 字符串 map 及通道（ channel ）。通过 for range 遍历的返回值有一定的规律：
- 数组、切片、字符串返回索引和值。
- map返回键和值。
- 通道(channel)只返回通道内的值。
4.1. 遍历数组、切片一一获得索引和元素
在遍历代码中， key value 分别代表切片的下标、下标对应的值。
func main() {
for key, value := range []int{1,2,3,4} {
fmt.Printf("key:%d value:%d
", key, value)
}
}
//代码输出如下：
//key : 0 value:1
//key : 1 value:2
//key : 2 value:3
//key : 3 value:4
4.2. 遍历字符串一一获得字符
key value 分别代表字符串的索引 (base0)和字符串中的每一个字符。
func main() {
var str = "hello 你好"
for key, value := range str {
fmt.Printf("key:%d valye:0x%x
", key, value)
}
}
//key : 0 value : Ox68
//key : 1 value : Ox65
//key : 2 value : Ox6c
//key : 3 value : Ox6c
//key : 4 value : Ox6f
//key : 5 value : Ox20
//key : 6 value : Ox4f60
//key : 9 value : Ox597d
代码中的v变量，实际类型是rune，实际上就是 int32 ，以十六进制打印出来就是字符的编码。
4.3. 遍历 map一一一获得 map 的键和值
对于 map 类型来说，for range 遍历时， key value 分别代 map 的索引键 key 和索引对应的值。
func main() {
m := map[string]int{
"hello":100,
"world":200,
}
for key, value := range m {
fmt.Println(key, value)
}
}
//代码输出如下
//hello 100
//world 200
注意： 遍历时，遍历输出的键值是无序的，如果需要有序的键值对输出，需要对结果进行排序
4.4. 遍历通道 channel 一一接收通道数据
for range 可以遍历通道(channel) ，但通道在遍历时，只输出一个值，即管道内的对应的数据。
func main() {
c := make(chan int)
go func (){
c <- 1
c <- 2
c <- 3
close(c)
}()
for v := range c{
fmt.Println(v)
}
}
//代码输出如下
//1
//2
//3
4.5. 在遍历中选择希望获得的变量
使用 for range 循环遍历某个对象一般不会同时需要key 或者 value
func main() {
m := map[string]int{
"world" : 100,
"hello" : 200,
}
for _, value := range m{
fmt.Println(value)
}
}
//代码输出如下
//100
//200
本身这种变量不会进行空间分配，也不会占用一个变量的名字。
在for range 可以对 key 使用匿名变量，也可以对 value 用匿名变量。
5. 分支选择（ switch ）一一拥青多个条件分支的判断
分支选择可以理解为一种批量的 if 语句 ，使用 switch 语句可方便地对大量的值进行判断。
5.1. 基本写法
func main() {
var a ="hello"
switch a{
case "hello":
fmt.Println(1)
case "world":
fmt.Println(2)
default:
fmt.Println(0)
}
}
// 代码输出如下:
// 1
上面例子中，每个case 均是字符串格式，且使用了 default 分支， Go规定定每个switch 只能有一个 default 分支。
5.1.1. 一分支多值
func main() {
var a = "num"
switch a {
case "mum", "daddy":
fmt.Println("family")
}
}
不同的 case 表达式使用逗号分隔。
5.1.2. 分支表达式
case 后不仅仅只是常量， 还可以和if一样添加表达式：
func main() {
var r int = 11
switch {
case r > 10 && r<20:
fmt.Println(r)
}
}
5.1.3. 跨越 case 的 fallthrough 兼容C语言的 case 设计
在 Go 语言中 case 是一个独立的代码块，执行完毕后不会像C语言那样紧接着下一个 case 执行。但是为了兼容一些移植代码，依然加入了 fallthrough 关键字来实现这一功能，代码如下：
func main() {
var s = "hello"
switch {
case s == "hello":
fmt.Println("hello")
fallthrough
case s != "world":
fmt.Println("world")
}
}
// 代码输出如下
// hello
// world
新编写的代码，不建议使用 fallthrough。
6. 跳转到指定代码标签(goto)
goto 语句通过标签进行代码间的无条件跳转。 goto 语句可以在快速跳出循环、避免重复退出。 Go 语言中使用 goto 语句能简化一些代码的实现过程。
6.1 使用goto退出多层循环
下面这段代码在满足条件时，需要连续退出两层循环，使用传统的编码方式如下：
func main() {
var breakAgain bool
// 外循环
for x:=0; x<10;x++{
//内循环
for y :=0;y<10;y++{
// 满足某个条件时，退出循环
if y == 2 {
// 设置退出标记
breakAgain = true
// 退出本次循环
break
}
}
if breakAgain {
break
}
}
fmt.Println("done")
}
将代码进行goto优化：
func main() {
// 外循环
for x := 0; x < 10; x++ {
//内循环
for y := 0; y < 10; y++ {
// 满足某个条件时，退出循环
fmt.Println(y)
if y == 2 {
// 跳转标签
goto breakHere
}
}
// 手动返回，避免执行进入标签
return
}
breakHere:
fmt.Println("done")
}
return如果不手动返回在不满足条件时，breakHere 也会执行代码
6.2 统一错误处理
多处错误处理存在代码重复时是非常棘手的 ，例如
func main() {
err := fiirstCheckError()
if err != nil {
fmt.Println(err)
exitProcess()
return
}
err = secondCheckError()
if err != nil {
fmt.Println(err)
exitProcess()
return
}
fmt.Println("done")
}
如果使用 goto 语句来实现同样的逻辑:
func main() {
err := fiirstCheckError()
if err != nil {
goto onExit
}
err = secondCheckError()
if err != nil {
goto onExit
}
fmt.Println("done")
return
onExit:
fmt.Println(err)
exitProcess()
}
7. 跳出指定循环（ break ）一一可以跳出多层循环
break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的 for、switch、select 的代码块上。
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 2:
fmt.Println(i, j)
break OuterLoop
case 3:
fmt.Println(i, j)
break OuterLoop
}
}
}
}
8. 继续下一次循环(continue)
continue 语句可以结束当前循环, 开始下一次的循环法代过程, 仅限在 for 循环用。在 continue 语句后添加标签时 表示开始标签对应的循环。
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 2:
fmt.Println(i, j)
continue OuterLoop
}
}
}
}