Part9:循環

歡迎來到Golang系列教程的第 9 節

循環語句被用來重複執行一個代碼塊。

for 是 Go 中唯一可用的循環，Go 沒有 while 或 do-while 循環，這些在出現在其他語言中，比如C。

for 循環語法

for initialisation; condition; post {
}

初始化(initialisation) 語句僅被執行一次。當循環初始化後，將檢查條件(condition)。當條件是真，在 {``}中的循環體將被執行，然後執行 post 語句。每次成功迭代循環後，執行 post 語句。當 post 語句執行後，條件將被複查。如果它爲真，循環繼續執行，否則循環終止。

在 Go 中，名爲 initialisation，condition 和 post 的三個部分都是可選的。我們來看個例子以更好地理解循環。

示例

我們寫一個程序，使用循環來打印從 1 到 10 的所有數字。

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        fmt.Printf(" %d",i)
    }
}

上面程序中，i 被初始化爲 1。條件語句檢查是否 i <= 10 。如果條件是真，則打印 i 的值。否則循環終止。在每次迭代後，post 語句將 i 遞增 1 。當 i 大於 10，循環終止。

上面的程序打印 1 2 3 4 5 6 7 8 9 10

在 for 循環中聲明的變量，作用域爲該循環內，因此 i 不可以在 for 循環外部訪問。

break

break 語句常被用來在循環正常執行完成前突然終止循環，並將控制交給 for 循環下面的一行代碼。

我們使用 break 寫一個打印 1 到 5 數字的程序

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i > 5 {
            break //loop is terminated if i > 5
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("\nline after for loop")
}

在上面的程序中，i 的值在每次迭代中被檢查。如果 i 的值大於 5，break 被打造 ，循環終止。 for 循環後的打印語句被執行，上面的程序輸出

1 2 3 4 5  
line after for loop  

continue

continue 語句被用來跳過當前循環。for 循環中所有出現在 continue 後面的代碼在當前迭代中不被執行。循環移動到下一次的迭代。

我們使用 continue 寫一個打印所有從 1 到 10 的奇數

package main

import (  
    "fmt"
)

func main() {  
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
}

上面程序中，if i % 2 == 0 這一行檢查提醒 i 對 2 取餘是否等於 0 。如果爲0，則該數是偶數，continue 語句被執行，控制移到循環的下一次迭代。因此在 continue 後面的打印語句不被調用，循環處理下一次迭代。程序輸出 1 3 5 7 9。

循環嵌套

for 循環內部有另一個 for 循環被稱爲 for 循環嵌套。

我們寫一個循環嵌套的程序來打印下面的序列。

*
**
***
****
*****

下面的程序使用循環嵌套打印序列。第 8 行的變量 n 存儲序列中的行數。在我們例子中，它是 5。外部的循環從 0 到 4 迭代 i，內部的循環從 0 到當前 i 的值迭代 j。在每次迭代中內部循環打印 *，外部的循環在每次內部迭代結束打印一個換行。運行這個程序，你會看到序列打印如輸出

package main

import (  
    "fmt"
)

func main() {  
    n := 5
    for i := 0; i < n; i++ {
        for j := 0; j <= i; j++ {
            fmt.Print("*")
        }
        fmt.Println()
    }
}

標籤(Labels)

標籤可以用來從內部循環中中斷外部循環。我們使用一個簡單的例子來理解我說的是什麼意思。

package main

import (  
    "fmt"
)

func main() {  
    for i := 0; i < 3; i++ {
        for j := 1; j < 4; j++ {
            fmt.Printf("i = %d , j = %d\n", i, j)
        }

    }
}

上面的程序是自解釋的，它打印

i = 0 , j = 1  
i = 0 , j = 2  
i = 0 , j = 3  
i = 1 , j = 1  
i = 1 , j = 2  
i = 1 , j = 3  
i = 2 , j = 1  
i = 2 , j = 2  
i = 2 , j = 3 

這沒有什麼特殊的。

如果 i 和 j 的值相等時，怎麼停止打印呢。實現這個，我們需要 break 外部的 for 循環。在內部 for 循環中，當 i 和j 相等時添加一個 break 將僅可以跳出內部 for 循環。

package main

import (  
    "fmt"
)

func main() {  
    for i := 0; i < 3; i++ {
        for j := 1; j < 4; j++ {
            fmt.Printf("i = %d , j = %d\n", i, j)
            if i == j {
                break
            }
        }

    }
}

上面的程序中，我已經在第 10 行的內部 for 循環中，當 i 和 j 相等時添加了break。這個 break 只能終止內部循環，外部循環仍然繼續。程序打印

i = 0 , j = 1  
i = 0 , j = 2  
i = 0 , j = 3  
i = 1 , j = 1  
i = 2 , j = 1  
i = 2 , j = 2  

這不是預期的輸出，當 i 和 j 相等時，我們需要停止打印，即當他們等於 1 時。

這就是標籤來拯救我們的地方。標籤可以被用來從外部終止循環。

package main

import (  
    "fmt"
)

func main() {  
outer:  
    for i := 0; i < 3; i++ {
        for j := 1; j < 4; j++ {
            fmt.Printf("i = %d , j = %d\n", i, j)
            if i == j {
                break outer
            }
        }

    }
}

在上面的程序，我們在第 8 行的 for 循環外添加一個 outer 標籤，而在第 13 行，我們通過指定這個標籤來終止外部循環。這個程序在 i 和 j 相等時停止打印。程序打印

i = 0 , j = 1  
i = 0 , j = 2  
i = 0 , j = 3  
i = 1 , j = 1  

更多例子

我們寫一些覆蓋 for 循環所有變量的代碼。

下面的這個程序將打印 0 到 10 的所有偶數

package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for ;i <= 10; { // initialisation and post are omitted
        fmt.Printf("%d ", i)
        i += 2
    }
}

正如我們已經知道的，for 循環名爲 initialisation，condition 和 post 的三個部件都是可選的。上面的程序，我們省略了 initialisation 和 post。i 在 for 循環外部被初始化爲 0。循環執行，直到 i <= 10。i 在循環中每次增加 2.上面的程序輸出0 2 4 6 8 10。

上面程序中的 for 循環中的分號也可以被省略。這種格式可以被認爲是 while 的替代方案。上面的程序可以被重寫爲

package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for i <= 10 { //semicolons are ommitted and only condition is present
        fmt.Printf("%d ", i)
        i += 2
    }
}

可以在 for 循環中聲明和操作多個變量。我們使用多個變量聲明來寫一個打印下列序列的程序

10 * 1 = 10  
11 * 2 = 22  
12 * 3 = 36  
13 * 4 = 52  
14 * 5 = 70  
15 * 6 = 90  
16 * 7 = 112  
17 * 8 = 136  
18 * 9 = 162  
19 * 10 = 190  

package main

import (  
    "fmt"
)

func main() {  
    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
        fmt.Printf("%d * %d = %d\n", no, i, no*i)
    }

}

在上面程序中，no 和 i 分別被聲明並初始化爲 10 和 1。在每次迭代後，它們增加 1。布爾運行符 && 在條件中確保 i 小於等於 10 同時 no 小於等於 19。

無限循環

創建一個無限循環的語法是

for{
}

下面的程序將持續打印 Hello World 而不會終止

package main

import "fmt"

func main() {  
    for {
        fmt.Println("Hello World")
    }
}

如果你嘗試在go playground中運行上面的程序，你將獲得一個錯誤"process took too long"。請嘗試在你本地系統上運行它，來無限打印 ”Hello World"。

在 for 循環中還有一個 range 被用在數組操作上。當我們討論數組時，將會涵蓋它。

** 下一教程 - switch 語句 **