【go从入门到精通】for循环控制

前言

Go 语言提供了 for 循环语句，用于重复执行一段程序逻辑，直到循环条件不再满足时终止。
循环可以用于迭代各种数据结构（例如切片、数组、映射或字符串）中的元素

本文将很基础的for循环语法，循环嵌套，无限循环，goto，break，continue呈现给正在学习go开发的读者。

for

语法

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

for init; condition; post { }

for condition { }

for { }

init：一般为赋值表达式，给控制变量赋初值；

condition：关系表达式或逻辑表达式，循环控制条件；

post：一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

①先对表达式 init 赋初值；

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

Go 复制代码

s := "abc"

for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
    println(s[i])
}

n := len(s)
for n > 0 {                // 替代 while (n > 0) {}
    n-- 
    println(s[n])        // 替代 for (; n > 0;) {}
}

for {                    // 替代 while (true) {}
    println(s)            // 替代 for (;;) {}
}

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

Go 复制代码

package main

func length(s string) int {
    println("call length.")
    return len(s)
}

func main() {
    s := "abcd"

    for i, n := 0, length(s); i < n; i++ {     // 避免多次调用 length 函数。
        println(i, s[i])
    } 
}

输出:

call length.

0 97

1 98

2 99

3 100

for-range

range类似迭代器操作，返回 (索引, 值) 或 (键, 值)。

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

复制代码

for key, value := range oldMap {
    newMap[key] = value
}

	1st value	2nd value
string	index	s[index]	unicode, rune
array/slice	index	s[index]
map	key	m[key]
channel	element

可忽略不想要的返回值，或 "_" 这个特殊变量。

1. 迭代字符串

该for-range循环可用于访问字符串中的各个字符。

Go 复制代码

package main
import "fmt"

func main() {
  for i, ch := range "World" {
    fmt.Printf("%#U starts at byte position %d\n", ch, i)
  }
}

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

Go 复制代码

U+0057 'W' starts at byte position 0
U+006F 'o' starts at byte position 1
U+0072 'r' starts at byte position 2
U+006C 'l' starts at byte position 3
U+0064 'd' starts at byte position 4

2. 迭代map

该for-range循环可用于访问映射中的各个键值对。

Go 复制代码

package main
import "fmt"

func main() {
  m := map[string]int{
    "one":   1,
    "two":   2,
    "three": 3,
  }
  for key, value := range m {
      fmt.Println(key, value)
  }
}

输出结果：

Go 复制代码

one 1 
two 2 
three 3

3. 迭代通道

对于通道，迭代值是在通道关闭之前在通道上发送的连续值。

Go 复制代码

package main
import "fmt"

func main() {
  mychannel := make(chan int)
  go func() {
      mychannel <- 1
      mychannel <- 2
      mychannel <- 3
      close(mychannel)
  }()
  for n := range mychannel {
      fmt.Println(n)
  }
}

输出：

Go 复制代码

1
2
3

循环嵌套

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

语法

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

Go 复制代码

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s)
   }
   statement(s)
}

实例：

下面这个例子使用了两个 for 循环来实现循环嵌套。外层的循环变量为 i，范围是 1 到 3，内层的循环变量为 j，范围也是 1 到 3。

Go 复制代码

package main

import "fmt"

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

最终的输出结果为：：

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: 3, j: 1

i: 3, j: 2

i: 3, j: 3

无限循环

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

Go 复制代码

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}

细心的读者可能已经发现了实际上for true {} 和for {}是等价的，所以这两种方式都可以，只不过在阅读代码的时候你需要知道这种方式。

goto、break、continue

如果你有其他语言的开发基础，我i想你对这三个关键词很熟悉，同样的在Go中，goto、break和continue也是三种控制流语句，用于改变程序的执行顺序

goto语句：

语法：goto label
作用：无条件跳转到指定的标签处执行，可以跳转到同一个函数或代码块内的任意位置。
注意事项：goto语句应该慎用，因为滥用goto会导致代码难以理解和维护。

示例代码：

go 复制代码

func main() {
    i := 0
Loop:
    if i < 5 {
        fmt.Println(i)
        i++
        goto Loop
    }
}

break语句：

语法：break
作用：跳出循环体或switch语句，结束当前循环或switch语句的执行，继续执行循环或switch之后的代码。
注意事项：break语句只能用于循环体或switch语句的内部，不可用于其他地方。

示例代码：

go 复制代码

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break
        }
        fmt.Println(i)
    }
}

continue语句：

语法：continue
作用：终止当前迭代，跳过本次循环中continue语句之后的代码，开始下一次迭代。
注意事项：continue语句只能用于循环体内部，不可用于其他地方。

示例代码：

go 复制代码

func main() {
    for i := 0; i < 5; i++ {
        if i == 2 {
            continue
        }
        fmt.Println(i)
    }
}

goto语句用于无条件跳转到指定位置执行，慎用。
break语句用于结束当前循环或switch语句的执行，继续执行之后的代码。
continue语句用于跳过本次循环的剩余代码，开始下一次迭代。