for
基本的for循环由三部分组成，它们用分号隔开：
- 初始化语句：在第一次迭代前执行
- 条件表达式：在每次迭代前执行
- 后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该声明仅在for语句的作用域中可见
当条件表达式返回`false`时，循环终止
注意：
和C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号， 大括号 { } 则是必须的。
for.go1
2
3
4
5
6
7
8
9
| package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}
|
初始化语句和后置语句是可选的。
for-continue.go1
2
3
4
5
6
7
8
9
10
11
| package main
import "fmt"
func main() {
i := 0
for ;i < 10; {
i++
}
fmt.Println(i)
}
|
此时，可以把分号移除，功能就变成了while
for-as-while.go1
2
3
4
5
6
7
8
9
10
11
| package main
import "fmt"
func main() {
i := 0
for i < 10 {
i++
}
fmt.Println(i)
}
|
无限循环
如果省略循环条件，则循环将无限执行下去。
for-forever.go1
2
3
4
5
6
7
8
9
| package main
import "fmt"
func main() {
for {
fmt.Println("forever")
}
}
|
if
Go中的if语句和for循环类似，表达式无需小括号( )，大括号{ }是必须的。
if.go1
2
3
4
5
6
7
8
9
10
11
12
13
14
| package main
import "fmt"
func check(i int) string {
if i > 0 {
return "true"
}
return "false"
}
func main() {
fmt.Println(check(1))
}
|
同for一样，if语句可以在条件表达式前执行一个简单的初始化语句。
初始化语句声明的变量作用域仅在if语句内。
if-with-init.go1
2
3
4
5
6
7
8
9
10
11
12
13
| package main
import (
"fmt"
"math/rand"
)
func main() {
if i := rand.Intn(10); i > 5 {
fmt.Println("i is", i)
}
fmt.Println("over")
}
|
else
在if的初始化语句中声明的变量，在else语句中也可以使用
也可以使用else-if语句继续进行条件判断
if-and-else.go1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| package main
import (
"fmt"
"math/rand"
)
func main() {
if i := rand.Intn(10); i > 5 {
fmt.Println(i, "> 5")
} else if i > 3 {
fmt.Println(i, "> 3")
} else {
fmt.Println(i, "<= 3")
}
}
|
switch
switch是编写一连串if-else语句的快捷方式。它运行第一个值等于条件表达式的case语句。
Go 自动提供了每个case中的break语句。
case中的语句可以常量，也可以是表达式。
switch.go1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Printf("Go runs on ")
switch os := runtime.GOOS; os {
case "darwin":
fmt.Println("OS X.")
case "linux":
fmt.Println("Linux.")
default:
fmt.Printf("%s.\n", os)
}
}
|
switch中的case语句从上往下顺次执行，知道匹配成功时停止。
没有条件的switch
switch可以没有条件，相当于switch true。
这种形式能将一长串if-then-else写得更加清晰。
switch-with-no-condition.go1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| package main
import "time"
func main() {
t := time.Now()
switch {
case t.Hour() < 12:
println("Good morning!")
case t.Hour() < 19:
println("Good afternoon.")
default:
println("Good evening.")
}
}
|
defer
defer语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
defer.go1
2
3
4
5
6
7
8
| package main
import "fmt"
func main() {
defer fmt.Println("world")
fmt.Printf("hello ")
}
|
defer 栈
defer语句可以有多个，多个defer推迟的函数会压入一个栈中，按照后进先出的顺序执行
defer-multi.go1
2
3
4
5
6
7
8
9
| package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
defer fmt.Print(i, ",")
}
}
|
上面代码的输出结果是
result1
2
| go run .
9,8,7,6,5,4,3,2,1,0,
|