Go语言的流程控制

Go语言没有do-while语句。

Go语言有三个特殊关键字：

defer ：用于捕获异常和资源回收等工作。

select：用于多分支选择（配合通道使用）。

go：用于异步启动goroutine并执行特定函数。

条件语句：

if关键字的格式如下：

if 表达式1 {

        分支1

} else if 表达式2 {

        分支2

} else {

        分支3

}

使用if语句的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  b:=true
  if b{
    fmt.Println("b is true!")
  }
}

运行结果如下：

b is true!

if判断的代码清单如下：

package main

import (
	"fmt"
)

func main() {
	a := 1
	if a < 20 {
		fmt.Printf("a小于20\n")
	}
	fmt.Printf("a的值是：%d\n", a)
}

运行结果如下：

a小于20
a的值是：1

使用else语句的代码清单如下：

package main

import(
  "fmt"
)
func main(){
  b:=false
  if b{
    fmt.Println("b is true!")
  } else{
    fmt.Println("b is false!")
  }
}

运行结果如下：

b is false!

if-else判断，代码清单如下：

package main

import (
	"fmt"
)

func main() {
	a := 100
	if a < 20 {
		fmt.Printf("a小于20\n")
	} else {
		fmt.Printf("a大于20\n")
	}
	fmt.Printf("a的值是：%d\n", a)
}

运行结果如下： 

a大于20
a的值是：100

使用else if语句的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  i:=2
  if i==3{
    fmt.Println("i is 3")
  } else if i==2{
    fmt.Println("i is 2")
  }
}

运行结果如下：

i is 2

else-if判断，代码清单如下：

package main

import (
	"fmt"
)

func main() {
	a := 11
	if a > 20 {
		fmt.Printf("a大于20\n")
	} else if a < 10 {
		fmt.Printf("a小于10\n")
	} else {
		fmt.Printf("a大于10\n")
		fmt.Printf("a小于20\n")
	}
	fmt.Printf("a的值是：%d\n", a)
}

运行结果如下：

a大于10
a小于20
a的值是：11

初始化子语句：

if语句可以有一个子语句，用于初始化局部变量。

代码如下：

package main

import (
	"fmt"
)

func main() {
	if a := 10; a < 20 {
		fmt.Printf("a小于20\n")
	} else {
		fmt.Printf("a的值是：%d\n", a)
	}
}

运行结果如下： 

a小于20

选择语句：

在Go语言中，switch表示选择语句的关键字。如果没有遇到符合的case则，可以使用的default case，如果已经遇到了符合的case，那么后面的case都不会被执行。

使用switch语句的程序清单：

package main

import(
  "fmt"
)
func main(){
  i:=2
  switch i{
  case 2:
    fmt.Println("Two")
  case 3:
    fmt.Println("Three")
  case 4:
    fmt.Println("Four")
  }
}

运行结果如下：

Two

在switch语句中添加default case的程序清单：

package main

import(
  "fmt"
)
func main(){
  s:="c"
  switch s{
  case "a":
    fmt.Println("The letter a!")
  case "b":
    fmt.Println("The letter b!")
  default:
    fmt.Println("I don't recognize that letter!")
  }
}

运行结果如下：

I don't recognize that letter!

fallthrough关键词可以把当前case控制权交给下一个case语句判断。

代码如下：

package main

import (
	"fmt"
)

func main() {
	grade := "D"
	switch {
	case grade == "A":
		fmt.Println("成绩优秀！")
	case grade == "B":
		fmt.Println("表现良好！")
	case grade == "C":
		fallthrough
	case grade == "D":
		fmt.Println("再接再厉！")
	default:
		fmt.Println("成绩不合格！")
	}
}

运行结果如下： 

再接再厉！

select语句：

在Go语言中，除了switch语句，还有一种选择语句——select，这种选择语句用于配合通道（channel）的读写操作，用于多个channel的并发读写操作。

select是按顺序从上到下依次执行的，而select是随机选择一个case来判断，直到匹配其中的一个case。

代码如下：

package main

import (
	"fmt"
)

func main() {
	a := make(chan int, 1024)
	b := make(chan int, 1024)
	for i := 0; i < 10; i++ {
		fmt.Printf("第%d次， ", i)
		a <- 1
		b <- 1
		select {
		case <-a:
			fmt.Println("from a")
		case <-b:
			fmt.Println("from b")
		}
	}
}

运行结果如下：

第0次， from b
第1次， from b
第2次， from b
第3次， from b
第4次， from b
第5次， from a
第6次， from a
第7次， from a
第8次， from b
第9次， from b

再次运行结果如下：

第0次， from a
第1次， from a
第2次， from a
第3次， from a
第4次， from a
第5次， from a
第6次， from a
第7次， from b
第8次， from a
第9次， from a

由于channel的读写操作是阻塞操作，使用select语句可以避免单个channel的阻塞。select可以使用default代码块，用于避免所有channel同时阻塞。

循环语句：

在Go语言中，循环语句的关键字是for，没有while关键字。

for循环格式如下：

for 初始语句;条件表达式;结束语句{

        循环体代码

}

使用for语句进行循环的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  i:=0
  for i<10{
    i++
    fmt.Println("i is",i)
  }
}

运行结果如下：

i is 1
i is 2
i is 3
i is 4
i is 5
i is 6
i is 7
i is 8
i is 9
i is 10

一个包含初始化语句和后续语句的for语句的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  for i:=0;i<10;i++{
    fmt.Println("i is",i)
  }
}

运行结果如下：

i is 0
i is 1
i is 2
i is 3
i is 4
i is 5
i is 6
i is 7
i is 8
i is 9

示例：九九乘法表

代码如下：

package main

import (
	"fmt"
)

func main() {
	for y := 1; y <= 9; y++ {
		for x := 1; x <= y; x++ {
			fmt.Printf("%d*%d=%d	", x, y, x*y)
		}
		fmt.Println()
	}
}

运行结果如下：

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	

range子语句：

每一个for语句都可以使用一个特殊的range子语句，其作用类似于迭代器，用于轮询数组或者切片值中的每一个元素，也可以用于轮询字符串的每一个字符，以及字典值中的每个键值对，甚至还可以持续读取一个通道类型值中的元素。

range返回值的输出

右边表达式返回的类型	第一个值	第二个值
string	index	str[index]，返回类型为rune
array/slice	index	str[index]
map	key	m[key]
channel	element

包含range子句的for语句的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  numbers:=[]int{1,2,3,4}
  for i,n:= range numbers {
    fmt.Println("The index of the loop is",i)
    fmt.Println("The value from the array is",n)
  }
}

//i和n是迭代变量。i用于存储索引值，n用于存储来自数组中的值。
//迭代变量从0开始。

运行结果如下：

The index of the loop is 0
The value from the array is 1
The index of the loop is 1
The value from the array is 2
The index of the loop is 2
The value from the array is 3
The index of the loop is 3
The value from the array is 4

代码如下：

package main

import (
	"fmt"
)

func main() {
	m := map[string]int{"a": 1, "b": 2}
	for k, v := range m {
		println(k, v)
	}
	numbers := []int{1, 2, 3, 4}
	for i, x := range numbers {
		fmt.Printf("第%d次，x的值为%d。\n", i, x)
	}
}

运行结果如下：

a 1
b 2
第0次，x的值为1。
第1次，x的值为2。
第2次，x的值为3。
第3次，x的值为4。

使用“_”空标识符表示忽略第一个返回值。对于空字典或切片、空数组、空字符串等情况，for语句会直接结束，不会循环。

用range遍历字符串切片，代码如下：

package main

import (
	"fmt"
)

func main() {
	a := []string{"abc", "def", "zzz"}
	for i, v := range a {
		fmt.Println(i, " : ", v)
	}
}

运行结果如下：

0  :  abc
1  :  def
2  :  zzz

对于映射类型的亦是，遍历方法如下：

package main

import (
	"fmt"
)

func main() {
	a := map[string]int{"Number1": 1, "Number2": 2, "Number3": 4}
	for k, v := range a {
		fmt.Println(k, " : ", v)
	}
}

运行结果如下：

Number3  :  4
Number1  :  1
Number2  :  2

Number1  :  1
Number2  :  2
Number3  :  4

键值循环（for range）——直接获得对象的索引和数据 

1、遍历数组、切片——获得索引和元素

代码如下：

package main

import (
	"fmt"
)

func main() {
	for key, value := range []int{1, 2, 3, 4} {
		fmt.Printf("key:%d value:%d\n", key, value)
	}
}

运行结果如下 ：

key:0 value:1
key:1 value:2
key:2 value:3
key:3 value:4

2、遍历字符串——获得字符

代码如下：

package main

import (
	"fmt"
)

func main() {
	var str = "hello 你好"
	for key, value := range str {
		fmt.Printf("key:%d value:0x%x\n", key, value)
	}
}

运行结果如下 ：

key:0 value:0x68
key:1 value:0x65
key:2 value:0x6c
key:3 value:0x6c
key:4 value:0x6f
key:5 value:0x20
key:6 value:0x4f60
key:9 value:0x597d

3、遍历map——获得map的键和值

代码如下：

package main

import (
	"fmt"
)

func main() {
	m := map[string]int{
		"hello": 100,
		"world": 200,
	}
	for key, value := range m {
		fmt.Println(key, value)
	}
}

运行结果如下 ：

hello 100
world 200

4、遍历通道（channel）——接收通道数据

代码如下：

package main

import (
	"fmt"
)

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

5、在遍历中选择希望获得的变量

代码如下：

package main

import (
	"fmt"
)

func main() {
	m := map[string]int{
		"hello": 100,
		"world": 200,
	}
	for _, value := range m {
		fmt.Println(value)
	}
}

运行结果如下 ：

100
200

代码如下：

package main

import (
	"fmt"
)

func main() {
	for key, _ := range []int{1, 2, 3, 4} {
		fmt.Printf("key:%d \n", key)
	}
}

运行结果如下 ：

key:0
key:1
key:2
key:3

延迟语句：

defer用于延迟调用指定函数，defer关键字只能出现在函数内部。

defer后面的表达式必须是外部函数的调用。

defer有两大特点：

（1）只有当defer语句全部执行，defer所在函数才算真正结束执行。

（2）当函数中有defer语句时，需要等待所有defer语句执行完毕，才会执行return语句。

defer的延迟特点，可以把defer语句用于回收资源、清理收尾等工作。使用defer语句之后，不用纠结回收代码放在哪里，反正都是最后执行。

使用defer语句的程序清单如下：

package main

import(
  "fmt"
)
func main(){
  defer fmt.Println("I am run after the function completes")
  fmt.Println("Hello World!")
}

运行结果如下：

Hello World!
I am run after the function completes

使用多条defer语句的程序清单：

package main

import(
  "fmt"
)
func main(){
  defer fmt.Println("I am the first defer statement")
  defer fmt.Println("I am the second defer statement")
  defer fmt.Println("I am the third defer statement")
  fmt.Println("Hello World!")
}

运行结果如下：

Hello World!
I am the third defer statement
I am the second defer statement
I am the first defer statement

代码如下：

package main

import (
	"fmt"
)

var i = 0

func print() {
	fmt.Println(i)
}
func main() {
	for ; i < 5; i++ {
		defer print()
	}
}

运行结果如下：

5
5
5
5
5

代码如下：

package main

import (
	"fmt"
)

var i = 0

func print(i int) {
	fmt.Println(i)
}
func main() {
	for ; i < 5; i++ {
		defer print(i)
	}
}

运行结果如下：

4
3
2
1
0

defer是一个栈，遵循先入后出，后进先出。

当一个函数内部有多个defer语句时，最后面的defer语句最先执行。

break语句意思是打断，这个语句表示打断当前流程控制。

continue用于跳转到指定代码块位置继续执行任务，continue仅能用于for循环。

goto语句可以无条件跳转到相同函数中的带标签语句。

跳出指定循环（break）——可以跳出多层循环

代码如下：

package main

import (
	"fmt"
)

func main() {
OuterLoop:
	for i := 0; i < 2; i++ {
		for j := 0; i < 5; j++ {
			switch j {
			case 2:
				fmt.Println(i, j)
				break OuterLoop
			case 3:
				fmt.Println(i, j)
				break OuterLoop
			}
		}
	}
}

运行结果如下：

0 2

继续下一个循环（continue）

代码如下：

package main

import (
	"fmt"
)

func main() {
OuterLoop:
	for i := 0; i < 2; i++ {
		for j := 0; i < 5; j++ {
			switch j {
			case 2:
				fmt.Println(i, j)
				continue OuterLoop
			}
		}
	}
}

运行结果如下：

0 2
1 2