Go学习笔记 -- 流程控制 for、switch、select

当然我们可以不在 Range 阶段求值，那样就会避免求值产生副本的问题。

list := [...]int{1, 1, 1, 1, 1}
for i := range list {
	if i+1 < len(list) {
		list[i+1] += list[i]
	}
}
fmt.Println(list)
-----------------------------------
[1 2 3 4 5]
1
2
3
4
5
6
7
8
9

Switch

在 switch 语句中，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。 switch 分支表达式可以是任意类型，不限于常量。可省略 break，默认自动终止。

通过 switch 的值和 case 的值是否一致，判断逻辑分支

  case 表达式中，可以放多个情况值。
  Go 语言中每个分支的最后默认都是有一个 break 的，使用 fallthrough 可以在走到当前分支后强制执行下一个 case 。

var ilist = []uint8{0, 1, 2, 3}
switch ilist[0] {
case 0:
	fmt.Println("000")
case 1:
	fmt.Println("111222")
	fallthrough
default:
	fmt.Println("default")
}
fmt.Println("--------分割线--------")
//使用 fallthrough 可以在走到当前分支后强制执行下一个 case 
switch ilist[2] {
case 0:
	fmt.Println("000")
case 1 , 2:
	fmt.Println("111222")
	fallthrough
default:
	fmt.Println("default")
}
----------------------------------
000
--------分割线--------
111222
default
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

省略条件表达式

也可以省略条件表达式，当作 if… else… 使用

var i int = 1
switch {
case i > 0 && i < 2:
	fmt.Println("1")
case i > 1 && i < 3:
	fmt.Println("2")
default:
	fmt.Println("default")
}
----------------------------------
1
1
2
3
4
5
6
7
8
9
10
11

Type Switch 判断接口类型

type Test struct {
	name string
}

func main() {
	var test1 = Test{"测试"}
	switch i := interface{}(test1).(type) {
	case nil:
		fmt.Printf(" x 为空")
	case int:
		fmt.Printf("x 是 int 型")
	case bool, string:
		fmt.Printf("x 是 bool 或 string 型")
	default:
		fmt.Printf("其他类型 %T", i)
	}
}
--------------------------------
其他类型 main.Test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Select

• select 是类似于 switch 的存在，但是他的分支需要绑定到通信操作上，select 中的 case 都是通信操作，要么接受，要么发送。
• 在一开始所有 channel 表达式都会被求值，如果其中任意一个通信可以进行，那么他就会执行，其他的会被忽略。
• 如果有多个case都可以运行，select 会随机公平地选出一个执行。其他不会执行。
• 如果没有分支可执行，但有 default 子句，则执行 default 语句。
• 如果没有分支可执行，且没有 default 字句，select 将阻塞，直到某个通信可以运行。

  如下代码，如果我们不屏蔽 default 分支，正常情况下最终将会打印十次 none value 结果，因为我们在执行 select 的时候，我们创建的三个通道里面都还没有值，过100 ms 之后我们才会放值，select 将走 default 分支。
  如果我们屏蔽掉 defalut 分支，打印结果如下，每一次的执行结果都可能不一样，哪一个通道中能先获取到值，就会执行对应分支的逻辑。

func goFunc(i int, ch *chan int) {
	time.Sleep(time.Millisecond * 100)
	*ch <- i
}

func main() {

	ch0 := make(chan int, 3)
	ch1 := make(chan int, 3)
	ch2 := make(chan int, 3)

	for i := 0; i < 10; i++ {

		ch0 = make(chan int, 3)
		ch1 = make(chan int, 3)
		ch2 = make(chan int, 3)

		go goFunc(0, &ch0)
		go goFunc(1, &ch1)
		go goFunc(2, &ch2)

		select {
		case v := <-ch0:
			fmt.Printf("ch0 current value is %d\n", v)
		case v := <-ch1:
			fmt.Printf("ch1 current value is %d\n", v)
		case v := <-ch2:
			fmt.Printf("ch2 current value is %d\n", v)
			// default:
			// 	fmt.Printf("none value\n")
		}
	}

	//等待一段时间
	time.Sleep(time.Millisecond * 5000)
}
----------------------
ch1 current value is 1
ch1 current value is 1
ch0 current value is 0
ch1 current value is 1
ch2 current value is 2
ch0 current value is 0
ch2 current value is 2
ch0 current value is 0
ch1 current value is 1
ch2 current value is 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

同理，我们也可以通过校验通道是否可以写入值来控制分支。修改一下上面的代码，将其中一个分支修改为向通道中写值
执行到 select 时，所有通道中都没有值，但是 ch0 可以写入，所以会走第一个分支，打印结果全是 ch0 set value 9

func goFunc(i int, ch *chan int) {...}

func main() {
...
		select {
		case ch0 <- 9:
			fmt.Printf("ch0 set value %d\n", <-ch0)
...
		}
	}
...
}
----------------------
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
ch0 set value 9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23