Go for语句的循环策略 - 摩柯技术社区

Go for 语句基础

在 Go 语言中，for 语句是实现循环操作的主要方式。与许多其他编程语言不同，Go 语言仅使用 for 这一种关键字来实现各种循环需求，包括类似 while 的循环以及传统的 C 风格 for 循环。

基本语法结构

Go 语言中 for 语句最基本的形式如下：

for init; condition; post {
    // 循环体代码
}

init：这是一个可选的语句，一般用于初始化循环控制变量。例如 i := 0。
condition：这是一个布尔表达式，每次循环迭代前都会进行求值。如果为 true，则继续执行循环体；如果为 false，则循环终止。例如 i < 10。
post：这是一个可选的语句，在每次循环体执行完毕后执行，通常用于更新循环控制变量。例如 i++。

示例代码

以下是一个简单的示例，展示了基本的 for 循环结构：

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Printf("当前 i 的值为: %d\n", i)
    }
}

在上述代码中，i := 0 初始化变量 i 为 0，i < 5 作为条件判断，只要 i 小于 5 就会继续循环，每次循环结束后执行 i++ 更新 i 的值。最终输出 i 从 0 到 4 的值。

省略初始化和后置语句

类似 while 循环的形式

Go 语言允许省略 for 语句中的 init 和 post 部分，从而实现类似其他语言中 while 循环的功能。语法如下：

for condition {
    // 循环体代码
}

示例代码

下面是一个使用类似 while 循环形式的例子：

package main

import "fmt"

func main() {
    i := 0
    for i < 5 {
        fmt.Printf("当前 i 的值为: %d\n", i)
        i++
    }
}

在这个例子中，我们在 for 循环外部初始化了变量 i，然后在循环体内部更新 i 的值。只要 i < 5 条件为 true，循环就会继续执行。

无限循环

语法形式

Go 语言通过省略 for 语句中的所有条件部分来实现无限循环。语法如下：

for {
    // 循环体代码
}

示例代码

以下是一个简单的无限循环示例，在实际应用中，通常需要配合 break 语句来终止循环：

package main

import "fmt"

func main() {
    i := 0
    for {
        fmt.Printf("当前 i 的值为: %d\n", i)
        if i == 5 {
            break
        }
        i++
    }
}

在上述代码中，我们使用 if 语句结合 break 来在 i 等于 5 时终止无限循环。

循环嵌套

基本概念

在 Go 语言中，for 循环可以嵌套使用，即一个 for 循环内部可以包含另一个 for 循环。外层循环每执行一次，内层循环都会完整地执行一遍。

示例代码

以下是一个打印九九乘法表的示例，展示了循环嵌套的用法：

package main

import "fmt"

func main() {
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d x %d = %d\t", j, i, i*j)
        }
        fmt.Println()
    }
}

在这个例子中，外层循环控制行数，从 1 到 9。对于每一行，内层循环控制该行的乘法运算数量，从 1 到当前行号 i。通过这种方式，我们可以打印出完整的九九乘法表。

使用 break 语句跳出循环

break 语句功能

break 语句用于立即终止当前所在的循环，程序会继续执行循环之后的语句。

示例代码

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break
        }
        fmt.Printf("当前 i 的值为: %d\n", i)
    }
    fmt.Println("循环结束")
}

在上述代码中，当 i 的值等于 5 时，break 语句被执行，循环立即终止，程序接着打印出 “循环结束”。

使用 continue 语句跳过本次循环

continue 语句功能

continue 语句用于跳过当前循环体中剩余的语句，直接开始下一次循环迭代。

示例代码

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            continue
        }
        fmt.Printf("当前 i 的值为: %d\n", i)
    }
}

在这个例子中，当 i 等于 5 时，continue 语句被执行，当前循环体中 continue 之后的语句被跳过，直接进入下一次循环，因此不会打印 i 等于 5 时的信息。

range 关键字在 for 循环中的应用

range 概述

range 关键字在 Go 语言的 for 循环中用于遍历数组、切片、字符串、映射（map）以及通道（channel）。它会返回两个值：索引（对于数组、切片和字符串）或键（对于映射），以及对应的值。

遍历数组和切片

示例代码

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("索引 %d 对应的值为 %d\n", index, value)
    }
}

在上述代码中，range 遍历切片 numbers，同时返回索引 index 和对应的值 value。

遍历字符串

示例代码

package main

import "fmt"

func main() {
    str := "Hello, 世界"
    for index, char := range str {
        fmt.Printf("索引 %d 对应字符 %c\n", index, char)
    }
}

这里需要注意，Go 语言中的字符串是 UTF - 8 编码的字节序列，range 遍历字符串时，返回的是字符的 Unicode 码点（rune 类型）及其索引。

遍历映射

示例代码

package main

import "fmt"

func main() {
    m := map[string]int{"one": 1, "two": 2, "three": 3}
    for key, value := range m {
        fmt.Printf("键 %s 对应的值为 %d\n", key, value)
    }
}

range 遍历映射时，会随机返回键值对，每次遍历的顺序可能不同。

只获取索引或键

在使用 range 遍历时，如果只需要索引（对于数组、切片和字符串）或键（对于映射），可以忽略第二个返回值。例如：

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for index := range numbers {
        fmt.Printf("索引 %d\n", index)
    }
}

只获取值

同样，如果只需要值，可以使用下划线 _ 来忽略索引或键。例如：

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    for _, value := range numbers {
        fmt.Printf("值 %d\n", value)
    }
}

多重循环中的 break 和 continue

带标签的 break 和 continue

在多重循环（嵌套循环）中，break 和 continue 默认作用于最内层的循环。如果想要作用于外层循环，可以使用带标签的 break 和 continue。

带标签 break 示例

package main

import "fmt"

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

在上述代码中，outerLoop 是一个标签，当 i == 1 且 j == 1 时，break outerLoop 会终止外层循环。

带标签 continue 示例

package main

import "fmt"

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

这里，当 i == 1 且 j == 1 时，continue outerLoop 会跳过外层循环本次迭代剩余的部分，直接开始下一次外层循环迭代。

循环性能优化策略

减少循环体内的开销

在循环体中，应尽量减少不必要的计算和操作。例如，如果某些计算结果在每次循环中都不会改变，可以将其移到循环外部。

package main

import "fmt"

func main() {
    // 计算在循环外部
    result := 10 * 20
    for i := 0; i < 1000; i++ {
        // 循环体只包含必要操作
        fmt.Println(result * i)
    }
}

避免频繁内存分配

在循环体中频繁进行内存分配会导致性能下降，尤其是在高并发场景下。例如，尽量避免在循环内部使用 make 分配新的切片或映射。

package main

import "fmt"

func main() {
    // 预分配切片
    data := make([]int, 1000)
    for i := 0; i < 1000; i++ {
        data[i] = i
    }
    for _, value := range data {
        fmt.Println(value)
    }
}

使用合适的数据类型

选择合适的数据类型对于循环性能也很重要。例如，如果循环控制变量不需要很大的范围，使用 int8 或 int16 等较小的数据类型可以减少内存占用和计算开销。

package main

import "fmt"

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

总结 for 语句循环策略要点

基本形式：熟悉 for 语句的基本语法结构，包括初始化、条件判断和后置操作部分，能够灵活运用实现各种循环逻辑。
省略形式：掌握省略初始化和后置语句的 for 循环形式，实现类似 while 循环的功能，以及通过省略所有部分实现无限循环。
循环控制语句：合理使用 break 和 continue 语句，在需要时跳出循环或跳过本次循环。在多重循环中，要学会使用带标签的 break 和 continue 控制外层循环。
range 关键字：熟练运用 range 关键字遍历数组、切片、字符串、映射和通道，了解如何根据需求获取索引、键或值。
性能优化：注意循环性能优化，减少循环体内的开销，避免频繁内存分配，选择合适的数据类型等，以提高程序的执行效率。

通过深入理解和灵活运用这些循环策略，开发者可以编写出高效、简洁的 Go 语言代码，更好地满足各种编程需求。无论是简单的数值计算循环，还是复杂的并发数据处理循环，都能游刃有余地应对。