Go For 循环

Go For循环

For循环是Go语言中用于重复执行代码块的核心控制结构之一。它提供了灵活的方式来处理迭代任务，支持传统的计数器循环、条件循环以及无限循环等模式。与其他语言不同，Go仅通过`for`关键字实现所有循环逻辑，去除了`while`和`do-while`语法。

基本语法

Go的`for`循环有三种主要形式：

1. 计数器循环

最经典的循环形式，包含初始化、条件和后置操作：

for 初始化语句; 条件表达式; 后置语句 {
    // 循环体
}

示例：

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println("当前值:", i)
    }
}

输出：

当前值: 0
当前值: 1
当前值: 2
当前值: 3
当前值: 4

2. 条件循环（类似while）

省略初始化语句和后置语句，仅保留条件表达式：

for 条件表达式 {
    // 循环体
}

示例：

package main

import "fmt"

func main() {
    count := 3
    for count > 0 {
        fmt.Println("倒计时:", count)
        count--
    }
}

输出：

倒计时: 3
倒计时: 2
倒计时: 1

3. 无限循环

完全省略所有表达式：

for {
    // 循环体（需配合break使用）
}

示例：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    for {
        num := rand.Intn(10)
        fmt.Println("随机数:", num)
        if num == 7 {
            break
        }
    }
}

循环控制语句

Go提供了两个关键控制语句：

• break：立即终止循环
• continue：跳过当前迭代，进入下一次循环

示例：

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue // 跳过偶数
        }
        if i > 7 {
            break // 大于7时终止循环
        }
        fmt.Println("处理奇数:", i)
    }
}

输出：

处理奇数: 1
处理奇数: 3
处理奇数: 5
处理奇数: 7

实际应用案例

1. 遍历集合

Go的`for`循环配合`range`可以优雅地遍历数组、切片、映射等集合类型：

package main

import "fmt"

func main() {
    fruits := []string{"苹果", "香蕉", "橙子"}
    
    // 遍历切片（索引+值）
    for index, value := range fruits {
        fmt.Printf("索引:%d 值:%s\n", index, value)
    }
    
    // 仅遍历值
    for _, fruit := range fruits {
        fmt.Println("水果:", fruit)
    }
}

2. 文件处理

循环读取文件直到遇到EOF（文件结束）：

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    file, _ := os.Open("data.txt")
    scanner := bufio.NewScanner(file)
    
    for scanner.Scan() {
        line := scanner.Text()
        fmt.Println("读取行:", line)
    }
    
    if err := scanner.Err(); err != nil {
        fmt.Println("读取错误:", err)
    }
}

性能考虑

Go编译器会对`for`循环进行优化，但开发者仍需注意： 1. 避免在循环条件中调用耗时函数 2. 预分配大容量切片以减少内存分配 3. 对于性能关键代码，可测试展开循环的效果

优化示例：

// 非优化版本
for i := 0; i < len(slice); i++ {
    // 每次循环都计算len(slice)
}

// 优化版本
length := len(slice)
for i := 0; i < length; i++ {
    // 只计算一次长度
}

常见错误

初学者常犯的错误包括： 1. 修改循环计数器导致意外行为 2. 无限循环缺少退出条件 3. 误用`range`返回的副本而非原值

错误示例：

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    for _, num := range numbers {
        num *= 2 // 无效，修改的是副本
    }
    fmt.Println(numbers) // 输出[1 2 3]，未改变原切片
}

进阶用法

标签与嵌套循环控制

Go允许使用标签配合`break`/`continue`控制外层循环：

package main

import "fmt"

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

并发循环

结合goroutine实现并行处理（需注意竞态条件）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    data := []string{"A", "B", "C"}
    
    for _, item := range data {
        wg.Add(1)
        go func(s string) {
            defer wg.Done()
            fmt.Println("处理:", s)
        }(item)
    }
    wg.Wait()
}

可视化流程

graph TD A[开始] --> B{条件为真?} B -- 是 --> C[执行循环体] C --> D[执行后置语句] D --> B B -- 否 --> E[结束]

数学表示

`for`循环的执行次数可以用数学公式表示。对于标准形式： $fori:=a;i<b;i++$ 循环次数为： $N=\max (0,b-a)$

对于条件循环： $whileP(x)$ 循环次数取决于谓词$P(x)$的真值变化。