如果想要重复执行某些语句，Go 语言中您只有 for 结构可以使用。不要小看它，这个 for 结构比其它语言中的更为灵活。

注意事项 其它许多语言中也没有发现和 do while 完全对等的 for 结构，可能是因为这种需求并不是那么强烈。

5.4.1 基于计数器的迭代

文件 for1.go 中演示了最简单的基于计数器的迭代，基本形式为：

  1. for 初始化语句; 条件语句; 修饰语句 {}

示例 5.6 for1.go：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     for i := 0; i < 5; i++ {
  7.         fmt.Printf("This is the %d iteration\n", i)
  8.     }
  9. }

输出：

  1. This is the 0 iteration
  2. This is the 1 iteration
  3. This is the 2 iteration
  4. This is the 3 iteration
  5. This is the 4 iteration

由花括号括起来的代码块会被重复执行已知次数，该次数是根据计数器（此例为 i）决定的。循环开始前，会执行且仅会执行一次初始化语句 i := 0;；这比在循环之前声明更为简短。紧接着的是条件语句 i < 5;，在每次循环开始前都会进行判断，一旦判断结果为 false，则退出循环体。最后一部分为修饰语句 i++，一般用于增加或减少计数器。

这三部分组成的循环的头部，它们之间使用分号 ; 相隔，但并不需要括号 () 将它们括起来。例如：for (i = 0; i < 10; i++) { }，这是无效的代码！

同样的，左花括号 { 必须和 for 语句在同一行，计数器的生命周期在遇到右花括号 } 时便终止。一般习惯使用 i、j、z 或 ix 等较短的名称命名计数器。

特别注意，永远不要在循环体内修改计数器，这在任何语言中都是非常差的实践！

您还可以在循环中同时使用多个计数器：

  1. for i, j := 0, N; i < j; i, j = i+1, j-1 {}

这得益于 Go 语言具有的平行赋值的特性（可以查看第 7 章 string_reverse.go 中反转数组的示例）。

您可以将两个 for 循环嵌套起来：

  1. for i:=0; i<5; i++ {
  2.     for j:=0; j<10; j++ {
  3.         println(j)
  4.     }
  5. }

如果您使用 for 循环迭代一个 Unicode 编码的字符串，会发生什么？

示例 5.7 for_string.go：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     str := "Go is a beautiful language!"
  7.     fmt.Printf("The length of str is: %d\n", len(str))
  8.     for ix :=0; ix < len(str); ix++ {
  9.         fmt.Printf("Character on position %d is: %c \n", ix, str[ix])
  10.     }
  11.     str2 := "日本語"
  12.     fmt.Printf("The length of str2 is: %d\n", len(str2))
  13.     for ix :=0; ix < len(str2); ix++ {
  14.         fmt.Printf("Character on position %d is: %c \n", ix, str2[ix])
  15.     }
  16. }

输出：

  1. The length of str is: 27
  2. Character on position 0 is: G 
  3. Character on position 1 is: o 
  4. Character on position 2 is:   
  5. Character on position 3 is: i 
  6. Character on position 4 is: s 
  7. Character on position 5 is:   
  8. Character on position 6 is: a 
  9. Character on position 7 is:   
  10. Character on position 8 is: b 
  11. Character on position 9 is: e 
  12. Character on position 10 is: a 
  13. Character on position 11 is: u 
  14. Character on position 12 is: t 
  15. Character on position 13 is: i 
  16. Character on position 14 is: f 
  17. Character on position 15 is: u 
  18. Character on position 16 is: l 
  19. Character on position 17 is:   
  20. Character on position 18 is: l 
  21. Character on position 19 is: a 
  22. Character on position 20 is: n 
  23. Character on position 21 is: g 
  24. Character on position 22 is: u 
  25. Character on position 23 is: a 
  26. Character on position 24 is: g 
  27. Character on position 25 is: e 
  28. Character on position 26 is: ! 
  29. The length of str2 is: 9
  30. Character on position 0 is: æ 
  31. Character on position 1 is:  
  32. Character on position 2 is: ¥ 
  33. Character on position 3 is: æ 
  34. Character on position 4 is:  
  35. Character on position 5 is: ¬ 
  36. Character on position 6 is: è 
  37. Character on position 7 is: ª 
  38. Character on position 8 is:

如果我们打印 str 和 str2 的长度，会分别得到 27 和 9。

由此我们可以发现，ASCII 编码的字符占用 1 个字节，既每个索引都指向不同的字符，而非 ASCII 编码的字符（占有 2 到 4 个字节）不能单纯地使用索引来判断是否为同一个字符。我们会在第 5.4.4 节解决这个问题。

练习题

练习 5.4 for_loop.go

  1. 使用 for 结构创建一个简单的循环。要求循环 15 次然后使用 fmt 包来打印计数器的值。
  2. 使用 goto 语句重写循环，要求不能使用 for 关键字。

练习 5.5 for_character.go

创建一个程序，要求能够打印类似下面的结果（直到每行 25 个字符时为止）：

  1. G
  2. GG
  3. GGG
  4. GGGG
  5. GGGGG
  6. GGGGGG
  1. 使用 2 层嵌套 for 循环。
  2. 使用一层 for 循环以及字符串截断。

练习 5.6 bitwise_complement.go

使用按位补码从 0 到 10，使用位表达式 %b 来格式化输出。

练习 5.7 Fizz-Buzz 问题：fizzbuzz.go

写一个从 1 打印到 100 的程序，但是每当遇到 3 的倍数时，不打印相应的数字，但打印一次 “Fizz”。遇到 5 的倍数时，打印 Buzz 而不是相应的数字。对于同时为 3 和 5 的倍数的数，打印 FizzBuzz（提示：使用 switch 语句）。

练习 5.8 rectangle_stars.go

使用 * 符号打印宽为 20，高为 10 的矩形。

5.4.2 基于条件判断的迭代

for 结构的第二种形式是没有头部的条件判断迭代（类似其它语言中的 while 循环），基本形式为：for 条件语句 {}。

您也可以认为这是没有初始化语句和修饰语句的 for 结构，因此 ;; 便是多余的了。

Listing 5.8 for2.go：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var i int = 5
  8.     for i >= 0 {
  9.         i = i - 1
  10.         fmt.Printf("The variable i is now: %d\n", i)
  11.     }
  12. }

输出：

  1. The variable i is now: 4
  2. The variable i is now: 3
  3. The variable i is now: 2
  4. The variable i is now: 1
  5. The variable i is now: 0
  6. The variable i is now: -1

5.4.3 无限循环

条件语句是可以被省略的，如 i:=0; ; i++ 或 for { } 或 for ;; { }（;; 会在使用 gofmt 时被移除）：这些循环的本质就是无限循环。最后一个形式也可以被改写为 for true { }，但一般情况下都会直接写 for { }。

如果 for 循环的头部没有条件语句，那么就会认为条件永远为 true，因此循环体内必须有相关的条件判断以确保会在某个时刻退出循环。

想要直接退出循环体，可以使用 break 语句（第 5.5 节）或 return 语句直接返回（第 6.1 节）。

但这两者之间有所区别，break 只是退出当前的循环体，而 return 语句提前对函数进行返回，不会执行后续的代码。

无限循环的经典应用是服务器，用于不断等待和接受新的请求。

  1. for t, err = p.Token(); err == nil; t, err = p.Token() {
  2.     ...
  3. }

5.4.4 for-range 结构

这是 Go 特有的一种的迭代结构，您会发现它在许多情况下都非常有用。它可以迭代任何一个集合（包括数组和 map，详见第 7 和 8 章）。语法上很类似其它语言中 foreach 语句，但您依旧可以获得每次迭代所对应的索引。一般形式为：for ix, val := range coll { }。

要注意的是，val 始终为集合中对应索引的值拷贝，因此它一般只具有只读性质，对它所做的任何修改都不会影响到集合中原有的值（译者注：如果 **val** 为指针，则会产生指针的拷贝，依旧可以修改集合中的原值）。一个字符串是 Unicode 编码的字符（或称之为 rune）集合，因此您也可以用它迭代字符串：

  1. for pos, char := range str {
  2. ...
  3. }

每个 rune 字符和索引在 for-range 循环中是一一对应的。它能够自动根据 UTF-8 规则识别 Unicode 编码的字符。

示例 5.9 range_string.go：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     str := "Go is a beautiful language!"
  7.     fmt.Printf("The length of str is: %d\n", len(str))
  8.     for pos, char := range str {
  9.         fmt.Printf("Character on position %d is: %c \n", pos, char)
  10.     }
  11.     fmt.Println()
  12.     str2 := "Chinese: 日本語"
  13.     fmt.Printf("The length of str2 is: %d\n", len(str2))
  14.     for pos, char := range str2 {
  15.         fmt.Printf("character %c starts at byte position %d\n", char, pos)
  16.     }
  17.     fmt.Println()
  18.     fmt.Println("index int(rune) rune    char bytes")
  19.     for index, rune := range str2 {
  20.         fmt.Printf("%-2d      %d      %U '%c' % X\n", index, rune, rune, rune, []byte(string(rune)))
  21.     }
  22. }

输出：

  1. The length of str is: 27
  2. Character on position 0 is: G 
  3. Character on position 1 is: o 
  4. Character on position 2 is:   
  5. Character on position 3 is: i 
  6. Character on position 4 is: s 
  7. Character on position 5 is:   
  8. Character on position 6 is: a 
  9. Character on position 7 is:   
  10. Character on position 8 is: b 
  11. Character on position 9 is: e 
  12. Character on position 10 is: a 
  13. Character on position 11 is: u 
  14. Character on position 12 is: t 
  15. Character on position 13 is: i 
  16. Character on position 14 is: f 
  17. Character on position 15 is: u 
  18. Character on position 16 is: l 
  19. Character on position 17 is:   
  20. Character on position 18 is: l 
  21. Character on position 19 is: a 
  22. Character on position 20 is: n 
  23. Character on position 21 is: g 
  24. Character on position 22 is: u 
  25. Character on position 23 is: a 
  26. Character on position 24 is: g 
  27. Character on position 25 is: e 
  28. Character on position 26 is: ! 
  30. The length of str2 is: 18
  31. character C starts at byte position 0
  32. character h starts at byte position 1
  33. character i starts at byte position 2
  34. character n starts at byte position 3
  35. character e starts at byte position 4
  36. character s starts at byte position 5
  37. character e starts at byte position 6
  38. character : starts at byte position 7
  39. character   starts at byte position 8
  40. character 日 starts at byte position 9
  41. character 本 starts at byte position 12
  42. character 語 starts at byte position 15
  44. index int(rune) rune    char bytes
  45. 0       67      U+0043 'C' 43
  46. 1       104      U+0068 'h' 68
  47. 2       105      U+0069 'i' 69
  48. 3       110      U+006E 'n' 6E
  49. 4       101      U+0065 'e' 65
  50. 5       115      U+0073 's' 73
  51. 6       101      U+0065 'e' 65
  52. 7       58      U+003A ':' 3A
  53. 8       32      U+0020 ' ' 20
  54. 9       26085      U+65E5 '日' E6 97 A5
  55. 12      26412      U+672C '本' E6 9C AC
  56. 15      35486      U+8A9E '語' E8 AA 9E

请将输出结果和 Listing 5.7（for_string.go）进行对比。

我们可以看到，常用英文字符使用 1 个字节表示，而汉字（译者注：严格来说，“Chinese: 日本語” 的 Chinese 应该是 Japanese）使用 3 个字符表示。

练习 5.9 以下程序的输出结果是什么？

  1. for i := 0; i < 5; i++ {
  2.     var v int
  3.     fmt.Printf("%d ", v)
  4.     v = 5
  5. }

问题 5.2： 请描述以下 for 循环的输出结果：


  1. for i := 0; ; i++ {
  2.     fmt.Println("Value of i is now:", i)
  3. }

  1. for i := 0; i < 3; {
  2.     fmt.Println("Value of i:", i)
  3. }

  1. s := ""
  2. for ; s != "aaaaa"; {
  3.     fmt.Println("Value of s:", s)
  4.     s = s + "a"
  5. }

  1. for i, j, s := 0, 5, "a"; i < 3 && j < 100 && s != "aaaaa"; i, j,
  2.     s = i+1, j+1, s + "a" {
  3.     fmt.Println("Value of i, j, s:", i, j, s)
  4. }