golang-基础-Go语言循环语句

Go语言中的循环结构是其核心控制流之一，尽管Go语言只提供一种循环关键字for，但通过灵活的语法变体，它可以实现其他语言中的while、do-while等循环功能。以下是Go语言循环语句的详细解析，涵盖各种类型、适用场景及代码示例。

一、基础for循环（经典三段式）

适用场景

• 已知循环次数：例如遍历固定长度的数组或切片。
• 需要初始化、条件判断和后置操作的场景。

语法

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

代码示例

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 10; i++ {
        sum += i
    }
    fmt.Println("1到10的和是：", sum) // 输出：55
}

关键点

• 初始化语句：在循环开始前执行一次，通常用于定义循环变量（如i := 1）。
• 条件表达式：每次循环前判断，若为true则继续循环。
• 后置语句：每次循环结束后执行，通常用于更新循环变量（如i++）。

二、模拟while循环（省略初始化和后置语句）

适用场景

• 条件驱动的循环：例如动态终止条件（如用户输入验证、等待事件触发）。

语法

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

代码示例

package main

import "fmt"

func main() {
    n := 5
    for n > 0 {
        fmt.Println(n)
        n-- // 手动更新条件变量
    }
    // 输出：5 4 3 2 1
}

关键点

• 需手动更新条件变量：否则可能导致无限循环。
• 灵活性：适用于条件逻辑复杂的场景。

三、无限循环（省略条件表达式）

适用场景

• 持续运行的任务：例如服务器监听、事件循环、定时任务等。
• 需要手动退出的场景（如用户输入退出指令）。

语法

for {
    // 循环体
}

代码示例

package main

import (
    "fmt"
    "time"
)

func main() {
    count := 0
    for {
        fmt.Println("Count:", count)
        count++
        time.Sleep(1 * time.Second) // 模拟任务间隔
        if count >= 3 {
            break // 手动退出循环
        }
    }
    // 输出：Count: 0, Count: 1, Count: 2
}

关键点

• 必须包含退出条件：否则程序会卡死。
• 常与break或return配合使用。

四、for range循环（遍历数据结构）

适用场景

• **遍历数组、切片、字符串、映射（map）、通道（channel）**等集合类型。
• 需要索引和值的场景。

语法

for 索引/键, 值 := range 集合 {
    // 循环体
}

代码示例

1. 遍历切片：

package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry"}
    for index, fruit := range fruits {
        fmt.Printf("Index: %d, Fruit: %s\n", index, fruit)
    }
    // 输出：
    // Index: 0, Fruit: apple
    // Index: 1, Fruit: banana
    // Index: 2, Fruit: cherry
}

2. 遍历映射：

package main

import "fmt"

func main() {
    ages := map[string]int{"Alice": 20, "Bob": 22, "Charlie": 21}
    for name, age := range ages {
        fmt.Printf("Name: %s, Age: %d\n", name, age)
    }
    // 输出：
    // Name: Alice, Age: 20
    // Name: Bob, Age: 22
    // Name: Charlie, Age: 21
}

3. 遍历字符串：

package main

import "fmt"

func main() {
    str := "Go语言"
    for index, char := range str {
        fmt.Printf("Index: %d, Char: %c\n", index, char)
    }
    // 输出：
    // Index: 0, Char: G
    // Index: 1, Char: o
    // Index: 3, Char: 语
    // Index: 4, Char: 言
}

关键点

• 索引和值：range会返回索引（或键）和值，但某些情况下（如字符串）可能只返回索引。

• 跳过索引或值：使用_忽略不需要的部分：

  for _, value := range slice {
      // 只关注值
  }
  

五、循环控制语句（break、continue）

适用场景

• 提前退出循环（break）：例如找到目标元素后立即终止。
• 跳过当前迭代（continue）：例如过滤无效数据。

代码示例

1. break退出循环：

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break // 当i等于5时退出循环
        }
        fmt.Println(i)
    }
    // 输出：0 1 2 3 4
}

2. continue跳过当前迭代：

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue // 跳过偶数
        }
        fmt.Println(i)
    }
    // 输出：1 3 5 7 9
}

3. 标签（Label）配合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("(%d, %d)", i, j)
        }
        fmt.Println()
    }
    // 输出：
    // (0, 0)(0, 1)(0, 2)
    // (1, 0)
}

六、goto语句（跳转控制）

适用场景

• 处理错误或异常：例如跳转到错误处理块。
• 简化复杂逻辑：但需谨慎使用，可能降低代码可读性。

代码示例

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        if i == 3 {
            goto end // 跳转到标签end
        }
        fmt.Println(i)
    }
    return
end:
    fmt.Println("Loop ended at i=3")
    // 输出：
    // 0
    // 1
    // 2
    // Loop ended at i=3
}

关键点

• 慎用goto：可能导致代码结构混乱，建议仅在特殊场景（如错误处理）使用。

七、循环优化建议

1. 减少循环体内的复杂计算：将复杂操作移到循环外。
2. 避免死循环：确保循环条件最终会变为false。
3. 并发优化：在适当场景下使用Go的并发特性（如goroutine和channel）提高效率。
4. 合理使用break和continue：提前终止无效迭代或跳过冗余操作。

八、总结

九、注意事项

1. 避免死循环：确保循环条件最终会退出，尤其是无限循环和while风格循环。
2. 循环变量作用域：初始化变量的作用域仅限于循环内，避免污染外部环境。
3. 性能优化：在循环体内尽量减少复杂的计算或I/O操作，必要时使用并发。
4. 代码可读性：优先使用for和for range，避免过度依赖goto。