1. 循环语句for

1.1.1. Golang for支持三种循环方式，包括类似 while 的语法。

for循环是一个循环控制结构，可以执行指定次数的循环。

语法

Go语言的For循环有3中形式，只有其中的一种使用分号。

  1.     for init; condition; post { }
  2.     for condition { }
  3.     for { }
  4.     init： 一般为赋值表达式，给控制变量赋初值；
  5.     condition： 关系表达式或逻辑表达式，循环控制条件；
  6.     post： 一般为赋值表达式，给控制变量增量或减量。
  7.     for语句执行过程如下：
  8.     ①先对表达式 init 赋初值；
  9.     ②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。
  1. s := "abc"
  3. for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
  4.     println(s[i])
  5. }
  7. n := len(s)
  8. for n > 0 {                // 替代 while (n > 0) {}
  9.     println(s[n])        // 替代 for (; n > 0;) {}
  10.     n-- 
  11. }
  13. for {                    // 替代 while (true) {}
  14.     println(s)            // 替代 for (;;) {}
  15. }

不要期望编译器能理解你的想法，在初始化语句中计算出全部结果是个好主意。

  1. package main
  3. func length(s string) int {
  4.     println("call length.")
  5.     return len(s)
  6. }
  8. func main() {
  9.     s := "abcd"
  11.     for i, n := 0, length(s); i < n; i++ {     // 避免多次调用 length 函数。
  12.         println(i, s[i])
  13.     } 
  14. }

输出:

  1.     call length.
  2.     0 97
  3.     1 98
  4.     2 99
  5.     3 100

实例：

  1. package main
  3. import "fmt"
  5. func main() {
  7.    var b int = 15
  8.    var a int
  10.    numbers := [6]int{1, 2, 3, 5}
  12.    /* for 循环 */
  13.    for a := 0; a < 10; a++ {
  14.       fmt.Printf("a 的值为: %d\n", a)
  15.    }
  17.    for a < b {
  18.       a++
  19.       fmt.Printf("a 的值为: %d\n", a)
  20.       }
  22.    for i,x:= range numbers {
  23.       fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
  24.    }   
  25. }

以上实例运行输出结果为:

  1.     a 的值为: 0
  2.     a 的值为: 1
  3.     a 的值为: 2
  4.     a 的值为: 3
  5.     a 的值为: 4
  6.     a 的值为: 5
  7.     a 的值为: 6
  8.     a 的值为: 7
  9.     a 的值为: 8
  10.     a 的值为: 9
  11.     a 的值为: 1
  12.     a 的值为: 2
  13.     a 的值为: 3
  14.     a 的值为: 4
  15.     a 的值为: 5
  16.     a 的值为: 6
  17.     a 的值为: 7
  18.     a 的值为: 8
  19.     a 的值为: 9
  20.     a 的值为: 10
  21.     a 的值为: 11
  22.     a 的值为: 12
  23.     a 的值为: 13
  24.     a 的值为: 14
  25.     a 的值为: 15
  26.     第 0 位 x 的值 = 1
  27.     第 1 位 x 的值 = 2
  28.     第 2 位 x 的值 = 3
  29.     第 3 位 x 的值 = 5
  30.     第 4 位 x 的值 = 0
  31.     第 5 位 x 的值 = 0

1.1.2. 循环嵌套

在 for 循环中嵌套一个或多个 for 循环

语法

以下为 Go 语言嵌套循环的格式：

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

实例：

以下实例使用循环嵌套来输出 2 到 100 间的素数：

  1. package main
  3. import "fmt"
  5. func main() {
  6.    /* 定义局部变量 */
  7.    var i, j int
  9.    for i=2; i < 100; i++ {
  10.       for j=2; j <= (i/j); j++ {
  11.          if(i%j==0) {
  12.             break // 如果发现因子，则不是素数
  13.          }
  14.       }
  15.       if(j > (i/j)) {
  16.          fmt.Printf("%d  是素数\n", i)
  17.       }
  18.    }  
  19. }

以上实例运行输出结果为:

  1.     2  是素数
  2.     3  是素数
  3.     5  是素数
  4.     7  是素数
  5.     11  是素数
  6.     13  是素数
  7.     17  是素数
  8.     19  是素数
  9.     23  是素数
  10.     29  是素数
  11.     31  是素数
  12.     37  是素数
  13.     41  是素数
  14.     43  是素数
  15.     47  是素数
  16.     53  是素数
  17.     59  是素数
  18.     61  是素数
  19.     67  是素数
  20.     71  是素数
  21.     73  是素数
  22.     79  是素数
  23.     83  是素数
  24.     89  是素数
  25.     97  是素数

1.1.3. 无限循环

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

  1. package main
  3. import "fmt"
  5. func main() {
  6.     for true  {
  7.         fmt.Printf("这是无限循环。\n");
  8.     }
  9. }