Aller aux bases du langage – instructions en boucle

Il n'y a qu'une instruction de boucle for dans le langage Go, et il n'y a pas de boucle while ou do-while que d'autres langages (comme le langage C, etc.) ont.

for syntaxe de boucle

for initialisation; condition; post {  
}

initialisation L'instruction d'initialisation ne sera exécutée qu'une fois l'initialisation terminée, elle vérifiera si la condition est vraie. Si tel est le cas, le code dans {. } sera exécuté, puis l'instruction post sera exécutée. Chaque fois que l'instruction de boucle dans {} est itérée avec succès, l'instruction post sera exécutée, puis la condition sera revérifiée pour voir si elle est vraie. Si c'est vrai, l'exécution de l'instruction de boucle continuera, sinon la boucle se terminera.

Dans Go, l'initialisation, la condition et la publication sont toutes facultatives. Regardons un exemple pour mieux comprendre la boucle for.

Exemple

Nous écrivons un programme pour imprimer tous les entiers de 1 à 10 en utilisant une boucle for.

package main

import (  
    "fmt"
)

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

Exécuter

Dans le code ci-dessus, i est initialisé à 1 et l'instruction conditionnelle vérifiera i <= 10. Si la condition est vraie, imprimez la valeur de i, sinon terminez la boucle. L'instruction post incrémente i de 1 à la fin de chaque itération, et une fois que i devient supérieur à 10, la boucle se termine.

Le code ci-dessus s'imprime : 1 2 3 4 5 6 7 8 9 10

Les variables déclarées dans une boucle for ne sont disponibles que dans le cadre du corps de la boucle. Par conséquent, la variable i n’est pas accessible en dehors du corps de la boucle for.

break

break est utilisé pour terminer la boucle for et sortir de la boucle pour continuer à exécuter les instructions après la boucle for.

Nous modifions le code précédent et utilisons l'instruction break pour imprimer uniquement tous les entiers compris entre 1 et 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")
}

Exécution

Dans le code ci-dessus, la valeur de i est vérifiée à chaque itération. Si i est supérieur à 5, break est exécuté et la boucle est terminée, puis l'instruction print après la boucle for est exécutée.

上面的程序会输出：

1 2 3 4 5  
line after for loop

continue

continue 语句用于跳过 for 循环的当前迭代。本次迭代中，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。如果为零，则该数为偶数，执行 continue 语句，则不会调用 continue 之后的 print 语句，并且循环继续进行下一次迭代。

上述程序的输出：1 3 5 7 9。

嵌套循环

一个 for 循环内部有另一个 for 循环称为嵌套 for 循环。

我们通过编写一个打印以下序列的程序来理解嵌套的 for 循环。

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

下面的程序使用嵌套 for 循环打印上述序列。

第 8 行的变量 8 存储序列的行数，我们这里是 5。外部 for 循环将 i 从 0 迭代到 4，内部 for 循环将 j 从 0 迭代到 i 的当前值。内部循环为每次迭代打印 * ，外部循环在每次迭代结束时打印一个新行。

运行这个程序将会输出上面的有序序列。

package main

import (  
    "fmt"
)

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

执行

标签

标签(label)可用于在内部 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)
        }

    }
}

执行

上面的程序比较容易理解，将会输出：

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 相等时，停止打印该怎么办？我们需要做的是从内部循环破坏外部 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
            }
        }

    }
}

执行

上面的代码，当判断 i 和 j 相等时，我们在内部 for 循环中会执行 break 语句，但这只会中断本次内部 for 循环，外部循环将继续执行。

程序输出：

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 时，我们需要停止打印。

这时候标签(label)就可以派上用场了。标签可用于中断外部循环，让我们用 label 重写上面的程序。

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 行循环的外部添加了名为 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 已经初始化为 0。只要 i <= 10，就会执行循环，在 for 循环内部 i 每次都增加 2.

上述代码的 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。在 condition 条件中使用布尔运算符 && 来确保 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。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!