在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。以下为大多编程语言循环程序的流程图：

Go语言 循环语句 - 图1

Go 语言提供了以下几种类型循环处理语句：

循环类型 描述
for 循环 重复执行语句块
循环嵌套 在 for 循环中嵌套一个或多个 for 循环

循环控制语句可以控制循环体内语句的执行过程。GO 语言支持以下几种循环控制语句：

控制语句 描述
break 语句 经常用于中断当前 for 循环或跳出 switch 语句
continue 语句 跳过当前循环的剩余语句，然后继续进行下一轮循环
goto 语句 将控制转移到被标记的语句

for 循环

for 循环是一个循环控制结构，可以执行指定次数的循环 Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号

for 循环的几种形式

和 C 语言、Java、JavaScript的 for 一样

  1. for init; condition; post { }

先对表达式 1 赋初值,判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句

  • init 一般为赋值表达式，给控制变量赋初值
  • condition 关系表达式或逻辑表达式，循环控制条件
  • post 一般为赋值表达式，给控制变量增量(increment)或减量(decrement)

image.png

和 C 的 while 一样：

  1. for condition { }

和 C 的 for(;;) 一样：

  1. for { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

  1. for key, value := range oldMap {
  2.     newMap[key] = value
  3. }
  5. //和JavaScript中for中操作对象,数组的对比
  6. var obj = { a: 1, b: 2, c:3 }
  7. for (const [k,v] of Object.entries(obj)) {
  8.   console.log(k,v)
  9. }
  11. var obj = { a: 1, b: 2, c:3 }
  12. for (const k in obj) {
  13.   console.log(k, obj[k])
  14. }
  17. var obj = [1,2,3]
  18. for (const k in obj) {
  19.   console.log(k, obj[k])
  20. }

计算 1 到 10 的数字之和

  1. package main
  2. import "fmt"
  4. func main() {
  5.     sum := 0
  6.     for i := 0; i <= 10; i++ {
  7.         sum += i
  8.     }
  9.     fmt.Println(sum)
  10. }
  12. // 输出结果:55


sum 小于 10 的时候计算 sum 自相加后的值

  1. package main
  2. import "fmt"
  4. func main() {
  5.     sum := 1
  6.     for ;sum <= 10; {
  7.         sum += sum
  8.     }
  9.     fmt.Println(sum)
  11.     // 这样写也可以，更像 While 语句形式
  12.     for sum <= 10{
  13.         sum += sum
  14.     }
  15.     fmt.Println(sum)
  16. }

无限循环

如果循环中条件语句永远不为 false 则会进行无限循环，我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环：

  1. package main
  2. import "fmt"
  4. func main() {
  5.     sum := 0
  7.     for;;{ fmt.Printf(";;\n"); }
  9.     for true  { fmt.Printf("这是条件为true的无限循环\n"); }
  11.     for {
  12.         sum++ // 无限循环下去
  13.         fmt.Printf("无参数的无限循环。\n");
  14.     }
  16.     fmt.Println(sum) // 无法输出
  17. }

⚠️ 要停止无限循环，可以在命令窗口按下ctrl+c

循环嵌套

Go 语言允许用户在循环内使用循环, 以下为 Go 语言嵌套循环的格式：

  1. for [(init; condition; increment) | condition | Range] {
  2.    for [(init; condition; increment) | condition | Range]{
  3.       statement(s);
  4.    }
  5.    statement(s);
  6. }

使用循环嵌套来输出 2 到 100 间的素数

  1. package main
  2. import "fmt"
  4. func main() {
  5.     // 定义局部变量
  6.     var i, j int
  8.     for i=2; i < 100; i++ {
  9.         for j=2; j*j <= i; j++ {
  10.                 if(i%j==0) {
  11.                     break; // 如果发现因子，则不是素数
  12.                 }
  13.         }
  15.         if(j*j > i) {
  16.                 fmt.Printf("%d  是素数\n", i);
  17.         }
  19.     }  
  20. }
  22. /* 
  23. 2  是素数
  24. 3  是素数
  25. 5  是素数
  26. 7  是素数
  27. 11  是素数
  28. 13  是素数
  29. 17  是素数
  30. 19  是素数
  31. 23  是素数
  32. 29  是素数
  33. 31  是素数 
  34. */

for-range 范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、集合(map)、通道(channel)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 键值对

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素

  1. package main
  2. import "fmt"
  4. func main() {
  5.     strings := []string{"google", "runoob"}
  6.     for i, s := range strings {
  7.         fmt.Println(i, s)
  8.     }
  10.     numbers := [6]int{1, 2, 3, 5} 
  11.     for i,x:= range numbers {
  12.         fmt.Printf("第%d位 x 的值 = %d\n", i,x)
  13.     }  
  14. }
  16. /* 
  17. 0 google
  18. 1 runoob
  19. 第0位 x 的值 = 1
  20. 第1位 x 的值 = 2
  21. 第2位 x 的值 = 3
  22. 第3位 x 的值 = 5
  23. 第4位 x 的值 = 0
  24. 第5位 x 的值 = 0 
  25. */
  1. package main
  2. import "fmt"
  3. func main() {
  4.     //这是我们使用range去求一个slice的和。使用数组跟这个很类似
  5.     nums := []int{2, 3, 4}
  6.     sum := 0
  7.     for _, num := range nums[1:] {
  8.         sum += num
  9.     }
  10.     fmt.Println("sum:", sum)
  12.     //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
  13.     for i, num := range nums {
  14.         if num == 3 {
  15.             fmt.Println("index:", i)
  16.         }
  17.     }
  19.     //range也可以用在map的键值对上
  20.     kvs := map[string]string{"a": "apple", "b": "banana"}
  21.     for k, v := range kvs {
  22.         fmt.Printf("%s -> %s\n", k, v)
  23.     }
  25.     //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
  26.     for i, c := range "go" {
  27.         fmt.Println(i, c)
  28.     }
  29.     c := make(chan int, 12)
  30.     go fibonacci(cap(c), c)
  31.     for i := range c { fmt.Println(i) }
  32. }
  33. func fibonacci(n int, c chan int) {
  34.     x, y := 0, 1
  35.     for i := 0; i <= n; i++ {
  36.         c <- x
  37.         x, y = y, x+y
  38.     }
  39.     close(c)
  40. }
  41. /* 以上实例运行输出结果为：
  42. sum: 7
  44. index: 1
  46. a -> apple
  47. b -> banana
  49. 0 103
  50. 1 111
  52. 0
  53. 1
  54. 1
  55. 2
  56. 3
  57. 5
  58. 8
  59. 13
  60. 21
  61. 34
  62. 55
  63. 89
  64. 144
  65. */

break 语句

Go 语言中 break 语句用于以下两方面：

  • 用于循环语句中跳出循环，并开始执行循环之后的语句。
  • break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
  • 在多重循环中，可以用标号 label 标出想 break 的循环

break 语法格式与语句流程图

  1. break;

image.png
**

在变量 a 大于 15 的时候跳出循环

  1. package main
  2. import "fmt"
  4. func main() {
  5.   //  定义局部变量
  6.    var a int = 10
  8.   //  for 循环
  9.    for a < 20 {
  10.       fmt.Printf("a的值为 : %d\n", a);
  11.       a++;
  12.       if a > 15 {
  13.          break; //使用 break 语句跳出循环
  14.       }
  15.    }
  16. }
  18. /* 
  19. a的值为 : 10
  20. a的值为 : 11
  21. a的值为 : 12
  22. a的值为 : 13
  23. a的值为 : 14
  24. a的值为 : 15 
  25. */

有多重循环，使用标记和不使用标记的区别

  1. package main
  3. import "fmt"
  5. func main() {
  7.     // 不使用标记
  8.     fmt.Println("---- break ----")
  9.     for i := 1; i <= 3; i++ {
  10.         fmt.Printf("i: %d\n", i)
  11.                 for i2 := 11; i2 <= 13; i2++ {
  12.                         fmt.Printf("i2: %d\n", i2)
  13.                         break
  14.                 }
  15.         }
  18.     // 使用标记
  19.     fmt.Println("---- break label ----")
  20.     re:
  21.         for i := 1; i <= 3; i++ {
  22.             fmt.Printf("i: %d\n", i)
  23.             for i2 := 11; i2 <= 13; i2++ {
  24.                 fmt.Printf("i2: %d\n", i2)
  25.                 break re
  26.             }
  27.         }
  28. }
  30. /* 
  31. ---- break ----
  32. i: 1
  33. i2: 11
  34. i: 2
  35. i2: 11
  36. i: 3
  37. i2: 11
  38. ---- break label ----
  39. i: 1
  40. i2: 11 
  41. */

continue 语句

Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句 for 循环中，执行 continue 语句会触发 for 增量语句的执行 在多重循环中，可以用标号 label 标出想 continue 的循环

continue 语法格式与语句流程图

  1. continue;

image.png
**

在a=15 的时候跳过本次循环执行下一次循环

  1. package main
  2. import "fmt"
  4. // func main() {
  5. //    var a int = 10 // 定义局部变量
  7. //    for a < 20 {
  8. //       if a == 15 {
  9. //          a = a + 1;
  10. //          continue; // 跳过此次循环,即使跳过一次下面的打印
  11. //       }
  12. //       fmt.Printf("a 的值为 : %d\n", a);
  13. //       a++;     
  14. //    }  
  15. // }
  17. func main() {
  18.    for a :=10 ;a < 20;a++ {
  19.       if a == 15 {
  20.          continue; // 跳过此次循环,即使跳过一次下面的打印
  21.       }
  22.       fmt.Printf("a 的值为 : %d\n", a);
  23.    }  
  24. }
  26. /* 
  27. a 的值为 : 10
  28. a 的值为 : 11
  29. a 的值为 : 12
  30. a 的值为 : 13
  31. a 的值为 : 14
  32. a 的值为 : 16
  33. a 的值为 : 17
  34. a 的值为 : 18
  35. a 的值为 : 19 
  36. */

多重循环，使用标记和不使用标记的区别

  1. package main
  2. import "fmt"
  4. func main() {
  5.     // 不使用标记
  6.     fmt.Println("---- continue ---- ")
  7.     for i := 1; i <= 3; i++ {
  8.         fmt.Printf("i: %d\n", i)
  9.             for i2 := 11; i2 <= 13; i2++ {
  10.                 fmt.Printf("i2: %d\n", i2)
  11.                 continue
  12.             }
  13.     }
  15.     // 使用标记
  16.     fmt.Println("---- continue label ----")
  17.     re:
  18.         for i := 1; i <= 3; i++ {
  19.             fmt.Printf("i: %d\n", i)
  20.                 for i2 := 11; i2 <= 13; i2++ {
  21.                     fmt.Printf("i2: %d\n", i2)
  22.                     continue re
  23.                 }
  24.         }
  25. }
  28. /* ---- continue ---- 
  29. i: 1
  30. i2: 11
  31. i2: 12
  32. i2: 13
  33. i: 2
  34. i2: 11
  35. i2: 12
  36. i2: 13
  37. i: 3
  38. i2: 11
  39. i2: 12
  40. i2: 13
  41. ---- continue label ----
  42. i: 1
  43. i2: 11
  44. i: 2
  45. i2: 11
  46. i: 3
  47. i2: 11 
  48. */

goto 语句

Go 语言的 goto 语句可以无条件地转移到过程中指定的行 goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能 但是，在结构化程序设计中一般不主张使用 goto 语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难

goto 语法格式与语句流程图

  1. goto label;
  2. ..
  3. .
  4. label: statement;

image.png

在a=15的时候跳过本次循环并回到循环的开始语句LOOP处

  1. package main
  3. import "fmt"
  5. func main() {
  6.    // 定义局部变量
  7.    var a int = 10
  9.    // 循环
  10.    LOOP: for a < 20 {
  11.       if a == 15 {
  12.          // 跳过迭代
  13.          a = a + 1
  14.          goto LOOP
  15.       }
  16.       fmt.Printf("a的值为 : %d\n", a)
  17.       a++     
  18.    }  
  19. }
  21. /* 
  22. a的值为 : 10
  23. a的值为 : 11
  24. a的值为 : 12
  25. a的值为 : 13
  26. a的值为 : 14
  27. a的值为 : 16
  28. a的值为 : 17
  29. a的值为 : 18
  30. a的值为 : 19 
  31. */

打印九九乘法表

  1. package main 
  2. import "fmt"
  3. func main() {
  4.     //print9x()
  5.     gotoTag()
  6. }
  8. //嵌套for循环打印九九乘法表
  9. func print9x() {
  10.   for m := 1; m < 10; m++ {
  11.     for n := 1; n <= m; n++ {
  12.       fmt.Printf("%dx%d=%d ",n,m,m*n)
  13.     }
  14.     fmt.Println("")
  15.   }
  16. }
  18. //for循环配合goto打印九九乘法表
  19. func gotoTag() {
  20.     for m := 1; m < 10; m++ {
  21.     n := 1
  23.     LOOP: if n <= m {
  24.         fmt.Printf("%dx%d=%d ",n,m,m*n)
  25.         n++
  26.         goto LOOP
  27.     } 
  29.     fmt.Println("")
  30.     n++
  31.   }
  32. }
  34. /* 
  35. 1x1=1 
  36. 1x2=2 2x2=4 
  37. 1x3=3 2x3=6 3x3=9 
  38. 1x4=4 2x4=8 3x4=12 4x4=16 
  39. 1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 
  40. 1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 
  41. 1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 
  42. 1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 
  43. 1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81 
  44.  */

使用 goto 退出多层循环

下面这段代码在满足条件时，需要连续退出两层循环，使用传统的编码方式如下

  1. package main
  3. import "fmt"
  5. func main() {
  6.  var breakAgain bool
  8.  for x := 0; x < 10; x++ {
  9.   for y := 0; y < 10; y++ {
  10.    // 满足某个条件时, 退出循环
  11.    if y == 2 {
  12.     breakAgain = true // 设置退出标记
  13.     break // 退出本次循环
  14.    }
  15.   }
  17.   // 根据标记, 还需要退出一次循环
  18.   if breakAgain { break }
  19.  }
  21.  fmt.Println("done")
  22. }

将上面的代码使用Go语言的 goto 语句进行优化

  1. package main
  2. import "fmt"
  4. func main() {
  5.   for x := 0; x < 10; x++ {
  6.     for y := 0; y < 10; y++ {
  7.       if y == 2 {
  8.         // 跳转到标签
  9.         goto breakHere
  10.       }
  11.     }
  12.   }
  15.   return      // 手动返回, 避免执行进入标签
  16.   breakHere:  // 标签
  17.     fmt.Println("done")
  18. }

使用 goto 集中处理错误

多处错误处理存在代码重复时是非常棘手的，例如：

  1. package main
  2. import "fmt"
  4. func main() {
  5.   err := firstCheckError()  //执行某逻辑，返回错误
  6.   //如果发生错误，打印错误退出进程
  7.   if err != nil {
  8.       fmt.Println(err)
  9.       exitProcess()
  10.       return
  11.   }
  13.   err = secondCheckError()
  14.   if err != nil {
  15.       fmt.Println(err)
  16.       exitProcess()
  17.       return
  18.   }
  19.   fmt.Println("done")
  20. }

在上面代码中，有一部分都是重复的错误处理代码，如果后期在这些代码中添加更多的判断，就需要在这些雷同的代码中依次修改，极易造成疏忽和错误,使用 goto 语句来实现同样的逻辑:

  1. package main
  2. import "fmt"
  4. func main() {
  5.     err := firstCheckError()
  6.     if err != nil {
  7.         goto onExit
  8.     }
  10.     err = secondCheckError()
  11.     if err != nil {
  12.         goto onExit
  13.     }
  14.     fmt.Println("done")
  16.     return  //阻止正常顺序读取到onExit
  17.     onExit:
  18.         fmt.Println(err)
  19.         exitProcess()
  20. }