Go 循環語句
一、概述
二、Go 語言 for 循環
三、循環嵌套
四、break 語句
五、 continue 語句
六、goto 語句
一、概述
在不少實際問題中有許多具有規律性的重復操作，因此在程序中就需要重復執行某些語句。
循環程序的流程圖：
Go 語言提供了以下幾種類型循環處理語句：
| 循環類型 | 描述 |
|---|---|
| for 循環 | 重復執行語句塊 |
| 循環嵌套 | 循環中嵌套一個或多個 for 循環 |
1. 循環控制語句
循環控制語句可以控制循環體內語句的執行過程。
GO 語言支持以下幾種循環控制語句：
| 控制語句 | 描述 |
|---|---|
| break 語句 | 經常用於中斷當前 for 循環或跳出 switch 語句 |
| continue 語句 | 跳過當前循環的剩余語句，然后繼續進行下一輪循環。 |
| goto 語句 | 將控制轉移到被標記的語句。 |
2. 無限循環
如果循環中條件語句永遠不為 false 則會進行無限循環，我們可以通過 for 循環語句中只設置一個條件表達式來執行無限循環：
示例
package main
import (
"fmt"
"time"
)
func main() {
i := 0
for true { //for后面true為可選，若不加，默認為true
fmt.Printf("i: %v\n", i)
i++
time.Sleep(time.Second)
}
}
//輸出結果如下
i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
....
....
....
二、Go 語言 for 循環
1. 語法
for 循環是一個循環控制結構，可以執行指定次數的循環
語法：
//Go 語言的 For 循環有 3 種形式，只有其中的一種使用分號
//和 C 語言的 for 一樣：
for init; condition; post { }
//和 C 的 while 一樣：
for condition { }
//和 C 的 for(;;) 一樣：
for { }
- init： 一般為賦值表達式，給控制變量賦初值
- condition： 關系表達式或邏輯表達式，循環控制條件
- post：一般為賦值表達式，給控制變量增量或減量。
2. for語句執行過程
① 先對表達式 1 賦初值；
② 判別賦值表達式 init 是否滿足給定條件，若其值為真，滿足循環條件，則執行循環體內語句，然后執行 post，進入第二次循環，再判別 condition；否則判斷 condition 的值為假，不滿足條件，就終止for循環，執行循環體外語句。
for 循環的 range 格式可以對 slice、map、數組、字符串等進行迭代循環。
格式如下：
for key, value := range oldMap {
newMap[key] = value
}
for 語句語法流程如下圖所示：
3. 示例
計算 1 到 10 的數字之和
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Printf("sum: %v\n", sum)
}
//輸出結果為：
55
-----------------------------------------------------------------------------------------------
//int 和 post 參數是可選的，我們可以直接省略他，類型while語句
package main
import "fmt"
func main() {
sum := 0
i := 1
for i <= 10 {
sum += i
i++
}
fmt.Printf("sum: %v\n", sum)
}
計算0-100間偶數的和
//求出0-100的偶數和
package main
import "fmt"
func main() {
a := 0
for i := 1; i <= 100; i++ {
if i%2 == 0 {
a += i
}
}
fmt.Printf("a: %v\n", a)
}
//輸出結果如下
2550
--------------------------------------------------------------------------------------------
//方法二
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 100; i += 2 {
sum += i
}
fmt.Printf("sum: %v\n", sum)
}
4. For-each range 循環
這種格式的循環可以對字符串、數組、切片等進行迭代輸出元素
示例
//循環數組
package main
import "fmt"
func main() {
names := []int{20, 30, 40, 50, 60}
//a獲取key,b獲取value
for a, b := range names {
fmt.Print("key:", a, " value:", b, "\n")
}
}
//輸出結果如下
key:0 value:20
key:1 value:30
key:2 value:40
key:3 value:50
key:4 value:60
//使用空白標識符直接獲取value
package main
import "fmt"
func main() {
names := []int{20, 30, 40, 50, 60}
//a獲取key,b獲取value
for _, b := range names {
fmt.Print("value:", b, "\n")
}
}
//輸出結果
value:20
value:30
value:40
value:50
value:60
三、循環嵌套
Go 語言允許用戶在循環內使用循環
1. 語法
以下為 Go 語言嵌套循環的格式：
for [condition | ( init; condition; increment ) | Range]
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}
statement(s);
}
2. 示例
以下實例使用循環嵌套來輸出 2 到 100 間的素數：
package main
import "fmt"
func main() {
/* 定義局部變量 */
var i, j int
for i=2; i < 100; i++ {
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break; // 如果發現因子，則不是素數
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素數\n", i);
}
}
}
//輸出結果如下
2 是素數
3 是素數
5 是素數
7 是素數
11 是素數
13 是素數
17 是素數
19 是素數
23 是素數
29 是素數
31 是素數
37 是素數
41 是素數
43 是素數
47 是素數
53 是素數
59 是素數
61 是素數
67 是素數
71 是素數
73 是素數
79 是素數
83 是素數
89 是素數
97 是素數
99乘法表：
package main
import "fmt"
func main() {
for i := 1; i < 10; i++ {
for j := 1; j < i+1; j++ {
fmt.Printf("%d * %d = %d\t", i, j, j*i)
}
fmt.Println()
}
}
//輸出結果如下
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
四、break 語句
1. 語法
Go 語言中 break 語句用於以下兩方面：
用於循環語句中跳出循環，並開始執行循環之后的語句。
break 在 switch（開關語句）中在執行一條 case 后跳出語句的作用。
在多重循環中，可以用標號 label 標出想 break 的循環。
break 語法格式如下：
break;
流程如圖：
2. 示例
- 在變量 a 大於 15 的時候跳出循環：
package main
import "fmt"
func main() {
var a int = 10
for a < 20 {
fmt.Printf("a: %v\n", a)
a++
if a > 15 {
break
}
}
}
//執行結果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 15
- 演示使用標記和不使用標記的區別
package main
import "fmt"
func main() {
//不適用標記
fmt.Println("----break----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %v\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %v\n", a)
break
}
}
//使用標記
fmt.Println("----break label----")
fla:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %v\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %v\n", a)
break fla
}
}
}
//輸出結果如下
----break----
i: 1
a: 11
i: 2
a: 11
i: 3
a: 11
----break label----
i: 1
a: 11
五、 continue 語句
1. 語法
Go 語言的 continue 語句 有點像 break 語句。但是 continue 不是跳出循環，而是跳過當前循環執行下一次循環語句。
for 循環中，執行 continue 語句會觸發 for 增量語句的執行。
在多重循環中，可以用標號 label 標出想 continue 的循環。
continue 語法格式如下：
continue;
continue 語句流程圖如下：
2. 示例
- 在變量 a 等於 15 的時候跳過本次循環執行下一次循環：
package main
import "fmt"
func main() {
var a int = 10
for a < 20 {
if a == 15 {
a = a + 1
continue
}
fmt.Printf("a: %v\n", a)
a++
}
}
//輸出結果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 16
a: 17
a: 18
a: 19
- 用多重循環演示使用標記和不使用標記的區別：
package main
import "fmt"
func main() {
// 不使用標記
fmt.Println("---- continue ---- ")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %d\n", a)
continue
}
}
// 使用標記
fmt.Println("---- continue label ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %d\n", a)
continue re
}
}
}
//輸出結果如下
---- continue ----
i: 1
a: 11
a: 12
a: 13
i: 2
a: 11
a: 12
a: 13
i: 3
a: 11
a: 12
a: 13
---- continue label ----
i: 1
a: 11
i: 2
a: 11
i: 3
a: 11
六、goto 語句
1. 語法
Go 語言的 goto 語句可以無條件地轉移到過程中指定的行
goto 語句通常與條件語句配合使用，可用來實現條件轉移， 構成循環，跳出循環體等功能。
但是，在結構化程序設計中一般不主張使用 goto 語句， 以免造成程序流程的混亂，使理解和調試程序都產生困難。
goto 語法格式如下：
goto label; .. . label: statement;
goto 語句流程圖如下：
2. 示例
- 在變量 a 等於 15 的時候跳過本次循環並回到循環的開始語句 LOOP 處：
package main
import "fmt"
func main() {
/* 定義局部變量 */
var a int = 10
/* 循環 */
LOOP:
for a < 20 {
if a == 15 {
/* 跳過迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值為 : %d\n", a)
a++
}
}
//輸出結果如下
a的值為 : 10
a的值為 : 11
a的值為 : 12
a的值為 : 13
a的值為 : 14
a的值為 : 16
a的值為 : 17
a的值為 : 18
a的值為 : 19
- goto 語句打印九九乘法表:
package main
import "fmt"
//for循環配合goto打印九九乘法表
func main() {
for m := 1; m < 10; m++ {
n := 1
LOOP:
if n <= m {
fmt.Printf("%dx%d=%d ", n, m, m*n)
n++
goto LOOP
} else {
fmt.Println("")
}
n++
}
}