1 流程控制之if else
一般写法
1
2
3
4
5
6
7
| if 表达式1 {
分支1
} else if 表达式2 {
分支2
} else{
分支3
}
|
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| package main
import "fmt"
func main() {
a, b, c := 1, 2, 3
if a >b {
fmt.Println(a)
} else {
fmt.Println(c)
}
}
|
if else的特殊写法
if条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| package main
import "fmt"
func main() {
if a := 3; a > 0 {
fmt.Println(a)
}
}
|
注意： Go语言规定与if匹配的左括号{必须与if和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与else匹配的{也必须与else写在同一行，else也必须与上一个if或else if右边的大括号在同一行。
2 流程控制之switch
1
2
3
4
5
6
7
8
| switch var1 {
case val1:
...
case val2:
...
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
27
| package main
import "fmt"
func main() {
switchTest(1)
}
func switchTest(a int) {
switch a {
case 1:
fmt.Println(1)
case 2:
fmt.Println(2)
default:
fmt.Println(a)
}
}
|
注意 ：
- switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一匹配，直到匹配对为止。
- switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break
type switch
switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
1
2
3
4
5
6
7
8
9
| switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 你可以定义任意个数的case */
default: /* 可选 */
statement(s);
}
|
实例
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
| package main
import "fmt"
func main() {
switchTest("")
}
func switchTest( a interface{} ) {
switch a.(type) {
case int:
fmt.Println(1)
case float32:
fmt.Println(2)
default:
fmt.Println("未知的类型")
}
}
|
3 流程控制之 for循环
写法一
1
| for init; condition; post { }
|
说明：
- init： 一般为赋值表达式，给控制变量赋初值；
- condition： 关系表达式或逻辑表达式，循环控制条件；
- post： 一般为赋值表达式，给控制变量增量或减量。
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| package main
import "fmt"
func main() {
forDemo(10)
}
func forDemo(y int) {
for x := 0; x < y; x++ {
fmt.Println("Hello World", x)
}
}
|
输出
1
2
3
4
5
6
7
8
9
10
| Hello World 0
Hello World 1
Hello World 2
Hello World 3
Hello World 4
Hello World 5
Hello World 6
Hello World 7
Hello World 8
Hello World 9
|
写法二
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| package main
import (
"fmt"
)
func main() {
forDemo1()
}
func forDemo1() {
y := 0
for ; y < 10; y++ {
fmt.Println("Ferrayman",y)
}
}
|
输出
1
2
3
4
5
6
7
8
9
10
| Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 3
Ferrayman 4
Ferrayman 5
Ferrayman 6
Ferrayman 7
Ferrayman 8
Ferrayman 9
|
写法三
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| package main
import (
"fmt"
)
func main() {
forDemo2()
}
func forDemo2() {
x := 10
for x > 0 {
fmt.Println("Ferrayman", x)
x--
}
}
|
输出
1
2
3
4
5
6
7
8
9
10
| Ferrayman 10
Ferrayman 9
Ferrayman 8
Ferrayman 7
Ferrayman 6
Ferrayman 5
Ferrayman 4
Ferrayman 3
Ferrayman 2
Ferrayman 1
|
4 break跳出循环
break语句可以结束for、switch和select的代码块。
实例
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
| package main
import (
"fmt"
)
func main() {
for j := 5; j > 0; j-- {
for i := 0; i < 5; i++ {
if i == 3 {
break
}
fmt.Println("Ferrayman",i)
}
}
}
|
输出
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 0
Ferrayman 1
Ferrayman 2
|
break语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的for、switch和 select的代码块上。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| package main
import (
"fmt"
)
func main() {
Tag:
for j := 10; j > 0; j-- {
for i := 0; i < 10; i++ {
if i == 5 {
break Tag
}
fmt.Println("Ferrayman",i)
}
}
}
|
输出
1
2
3
4
5
| Ferrayman 0
Ferrayman 1
Ferrayman 2
Ferrayman 3
Ferrayman 4
|
5 continuce跳过本次循环，继续下一次循环
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
if i == 5 {
continue
}
fmt.Println("Ferrayman",i)
}
}
|
输出
1
2
3
4
5
6
7
8
9
| Ferryman 0
Ferryman 1
Ferryman 2
Ferryman 3
Ferryman 4
Ferryman 6
Ferryman 7
Ferryman 8
Ferryman 9
|
注意：continue仅限在for循环当中使用
6 goto关键字
Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
不建议使用goto关键字。会让程序变得难以理解。
实例
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
| package main
import (
"fmt"
)
/**goto关键字的使用
@author 赖柄沣 bingfengdev@aliyun.com
@date 2020-09-30 22:45:55
@version 1.0
*/
func main() {
Tag1:
fmt.Println("haha,我又来了")
for i := 0; i < 5; i++ {
if i == 3 {
goto Tag
}
fmt.Println("Ferrayman",i)
}
Tag:
fmt.Println("hehe，我出来了")
goto Tag1
}
|
输出
1
2
3
4
5
6
7
8
| hehe，我出来了
haha,我又来了
Ferryman 0
Ferryman 1
Ferryman 2
死循环。。。
而且第一次打印在程序的23行
|
（每次执行标签tag和tag1的执行顺序不太一样，个人感觉这应该和go语言对并行编程的设计有关）