[译] part 9: golang 循环语句

https://juejin.im/post/5cbc414cf265da036b4a6216

循环语句被用来重复执行一块代码。

for是 Go 中唯一的循环语句。 Go 没有whiledo while循环,这些循环存在于其他如 C 语言中。

for 循环的语法

  1. for initialisation; condition; post {
  2. }

初始化语句只执行一次。初始化循环后,将检查条件。如果条件的计算结果为true,则执行{}内的循环体,然后执行post语句。post语句将在每次成功迭代循环后执行。执行post语句后,将重新检查条件。如果是true,则循环将继续执行,否则for循环终止。

在 Go 中,这三个组件叫初始化,conditionpost都是可选的。让我们看一个例子来更好地理解 for 循环。

例子

我们编写一个程序,使用 for 循环打印从 1 到 10 的所有数字。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 1; i <= 10; i++ {
  7. fmt.Printf(" %d",i)
  8. }
  9. }

Run in playground

在上面的程序中,i被初始化为 1。条件语句将检查i <= 10。如果条件为满足,则打印i的值,否则循环终止,post语句在每次迭代结束时将i递增 1。一旦大于 10,循环终止。

程序将输出,1 2 3 4 5 6 7 8 9 10

在 for 循环中声明的变量仅在循环范围内可用。因此我不能在代码块外获取i

break

break 语句用于在正常执行之前终止 for 循环,并执行 for 循环之后的代码行。

让我们编写一个程序,使用 break 并打印 1 到 5 的数字。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 1; i <= 10; i++ {
  7. if i > 5 {
  8. break //loop is terminated if i > 5
  9. }
  10. fmt.Printf("%d ", i)
  11. }
  12. fmt.Printf("\nline after for loop")
  13. }

Run in playground

在上述程序中,每次迭代都检查i的值。如果i大于 5,则执行 break 并终止循环。然后执行 for 循环之后的 print 语句。以上程序将输出,

  1. 1 2 3 4 5
  2. line after for loop

cotinue

continue 语句用于跳过当前 for 循环的迭代。在 continue 语句之后的代码都不会在当前迭代中执行。循环将继续下一次迭代。

让我们编写一个程序,使用 continue 来打印从 1 到 10 的所有奇数。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 1; i <= 10; i++ {
  7. if i%2 == 0 {
  8. continue
  9. }
  10. fmt.Printf("%d ", i)
  11. }
  12. }

Run in playground

在上面的程序中,if i%2 == 0检查i除以 2 是否为 0。如果为 0 则为偶数并执行continue语句,执行下一次迭代环。因此,不会调用continue之后的print语句,循环进入下一次迭代。上述程序的输出为1 3 5 7 9

嵌套 for 循环

在循环中包含另一个 for 循环的 for 循环称为嵌套 for 循环。

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

  1. *
  2. **
  3. ***
  4. ****
  5. *****

下面的程序使用嵌套 for 循环来打印序列。变量 n 存储序列的行数,在我们的例子中n是 5。外部 for 循环从 0 到 4 迭代i,内部 for 循环将 j 从 0 迭代到i的当前值。内部循环迭代打印*,外部循环在每次迭代结束时换行。运行此程序,将看到上述打印的序列。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. n := 5
  7. for i := 0; i < n; i++ {
  8. for j := 0; j <= i; j++ {
  9. fmt.Print("*")
  10. }
  11. fmt.Println()
  12. }
  13. }

Run in playground

标签 label

标签可用于从内部 for 循环内部打破外部循环。让我们通过一个简单的例子来理解我的意思。(译者注:Go 语言中可以用到 label 的有 goto,break,continue)

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 0; i < 3; i++ {
  7. for j := 1; j < 4; j++ {
  8. fmt.Printf("i = %d , j = %d\n", i, j)
  9. }
  10. }
  11. }

Run in playground

理解上面的代码不难,上述程序将打印,

  1. i = 0 , j = 1
  2. i = 0 , j = 2
  3. i = 0 , j = 3
  4. i = 1 , j = 1
  5. i = 1 , j = 2
  6. i = 1 , j = 3
  7. i = 2 , j = 1
  8. i = 2 , j = 2
  9. i = 2 , j = 3

如果我们想在ij相等时停止打印怎么办?要做到这一点,我们需要在外部 for 循环中断。当ij相等时,在内部 for 循环中添加一个 break 只会从内部 for 循环中中断。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 0; i < 3; i++ {
  7. for j := 1; j < 4; j++ {
  8. fmt.Printf("i = %d , j = %d\n", i, j)
  9. if i == j {
  10. break
  11. }
  12. }
  13. }
  14. }

Run in playground

在上面的程序中,当ij相等时,我在内部 for 循环中添加了一个 break。这将仅从内部 for 循环中断,外循环将继续,该程序将打印,

  1. i = 0 , j = 1
  2. i = 0 , j = 2
  3. i = 0 , j = 3
  4. i = 1 , j = 1
  5. i = 2 , j = 1
  6. i = 2 , j = 2

这不是期望的输出。当ij相等时,即当它们都等于 1 时,我们需要停止打印。

这是标签发挥作用的地方。标签可用于从外循环中断开。让我们用标签重写上面的程序。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. outer:
  7. for i := 0; i < 3; i++ {
  8. for j := 1; j < 4; j++ {
  9. fmt.Printf("i = %d , j = %d\n", i, j)
  10. if i == j {
  11. break outer
  12. }
  13. }
  14. }
  15. }

Run in plaground

在上面的程序中,我们在第 8 行为外部 for 循环添加了一个标签。我们通过中断指定标签来结束外部 for 循环。当ij相等时,该程序将停止打印。该程序将输出

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

更多例子

让我们编写一些代码来熟悉 for 循环的各种用法。

下面的程序打印从 0 到 10 的所有偶数。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. i := 0
  7. for ;i <= 10; { // initialisation and post are omitted
  8. fmt.Printf("%d ", i)
  9. i += 2
  10. }
  11. }

Run in playground

我们已经知道 for 循环有三个组件,即initialisationconditionpost是可选的。在上面的程序中,省略了initialisationpost。我在 for 循环之外初始化i为 0。只要i <= 10,就会执行循环。i在 for 循环中增加 2。上述程序输出0 2 4 6 8 10

也可以省略上述程序的 for 循环中的分号。这种格式可以被认为是 while 循环的替代方案。上述程序可以改写为,

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. i := 0
  7. for i <= 10 { //semicolons are ommitted and only condition is present
  8. fmt.Printf("%d ", i)
  9. i += 2
  10. }
  11. }

Run in playground

我们也可以在 for 循环中声明和操作多个变量。来编写一个程序,在 for 语句中使用多个变量声明并打印下面的序列。

  1. 10 * 1 = 10
  2. 11 * 2 = 22
  3. 12 * 3 = 36
  4. 13 * 4 = 52
  5. 14 * 5 = 70
  6. 15 * 6 = 90
  7. 16 * 7 = 112
  8. 17 * 8 = 136
  9. 18 * 9 = 162
  10. 19 * 10 = 190
  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
  7. fmt.Printf("%d * %d = %d\n", no, i, no*i)
  8. }
  9. }

Run in playground

在上面的程序中,noi被声明并初始化为 10 和 1。它们在每次迭代结束时递增 1。在condition中使用布尔运算符&&以确保i小于或等于 10 并且no小于或等于 19。

无限循环

无限循环的语法为,

  1. for {
  2. }

以下程序将一直打印 Hello World 且不会结束。

  1. package main
  2. import "fmt"
  3. func main() {
  4. for {
  5. fmt.Println("Hello World")
  6. }
  7. }

如果你在 playground 上运行该程序,将会报错process took too long。请尝试在本地系统中运行它以无限地打印Hello World

还有range可以用 for 循环以进行数组的迭代操作。我们了解数组时,再介绍这一点。

ft_authoradmin  ft_create_time2019-08-03 16:33
 ft_update_time2019-08-03 16:36