异常教程

Go 语言循环语句（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程世界中，循环语句如同工厂中的传送带，能够高效地重复执行特定任务，是解决问题的核心工具之一。对于学习 Go 语言的开发者而言，掌握其循环语句的特性与最佳实践，是提升代码效率和可读性的关键。本文将从基础语法到高级应用，结合生动的比喻和实战案例，帮助读者系统理解 Go 语言循环语句的全貌。

一、循环语句的核心作用与 Go 的独特设计

循环语句的三大核心功能是：重复执行代码块、处理大量数据、自动化流程控制。
与 C、Java 等语言不同，Go 语言仅提供一种循环结构——for，但它通过灵活的语法设计，实现了 while、do-while 甚至其他语言中复杂循环的逻辑。这种设计体现了 Go 的极简主义哲学：用单一语法覆盖所有需求，降低学习成本。

比喻：循环是“智能快递分拣系统”

想象一个快递分拣中心，传送带（循环体）不断运送包裹，每个包裹（数据项）经过扫描（条件判断），根据目的地（分支逻辑）被分到不同区域。Go 的 for 循环就像这个系统：

  • 初始化：启动传送带前的准备工作（如设置计数器）
  • 条件判断：扫描包裹的条形码（决定是否继续循环）
  • 迭代操作：包裹处理后的状态更新（如计数器递增）

二、基础语法：for 循环的三种经典用法

1. 基础结构与计数循环

Go 的 for 循环语法如下：

for 初始化; 条件判断; 迭代操作 {  
    // 循环体  
}

示例：计算 1 到 10 的和

sum := 0  
for i := 1; i <= 10; i++ {  
    sum += i  
}  
fmt.Println("总和为:", sum) // 输出：55

这里，i 是循环变量，仅在循环体内有效。初始化和迭代操作可省略，例如：

// 省略初始化和迭代，类似 while  
count := 0  
for count < 5 {  
    fmt.Println("当前计数:", count)  
    count++  
}

2. 条件循环（模拟 while）

通过省略初始化和迭代部分，for 可直接作为 while 使用：

password := "123456"  
for !checkPassword(password) { // 条件不满足时循环  
    fmt.Println("密码错误，请重新输入：")  
    fmt.Scanln(&password)  
}  
fmt.Println("登录成功！")

3. 无限循环与终止条件

省略所有表达式时，循环会无限执行，需通过 break 或外部条件终止：

for { // 无限循环  
    input := readInput()  
    if input == "exit" {  
        break // 遇到退出指令时终止循环  
    }  
    process(input)  
}

三、控制流程：break、continue 与标签循环

1. break：立即跳出循环

break 可终止当前最近的 for 循环，常用于提前结束循环：

for i := 1; i <= 10; i++ {  
    if i == 5 {  
        break // 当 i=5 时跳出循环  
    }  
    fmt.Print(i, " ") // 输出：1 2 3 4  
}

2. continue：跳过本次循环剩余代码

continue 会直接跳到下一次循环的条件判断阶段：

for i := 1; i <= 5; i++ {  
    if i%2 == 0 {  
        continue // 跳过偶数  
    }  
    fmt.Print(i, " ") // 输出：1 3 5  
}

3. 标签循环：多层循环的精准控制

通过标签（Label）可控制嵌套循环的 break 或 continue：

SearchLoop:  
for i := 0; i < 3; i++ {  
    for j := 0; j < 3; j++ {  
        if i == 1 && j == 1 {  
            break SearchLoop // 直接跳出外层循环  
        }  
        fmt.Printf("(%d,%d) ", i, j)  
    }  
}  
// 输出：(0,0) (0,1) (0,2) (1,0)

四、遍历集合：数组、切片与映射

1. 遍历数组与切片

Go 使用 range 关键字遍历集合，返回索引和元素值：

numbers := []int{10, 20, 30, 40}  
for index, value := range numbers {  
    fmt.Printf("索引 %d 的值为 %d\n", index, value)  
}  
// 输出：  
// 索引 0 的值为 10  
// 索引 1 的值为 20  
// ...

2. 遍历映射

遍历映射时，range 返回键和值：

scores := map[string]int{"Alice": 95, "Bob": 88}  
for name, score := range scores {  
    fmt.Printf("%s 的成绩是 %d 分\n", name, score)  
}

3. 只获取元素值（省略索引/键）

若不需要索引或键，可用下划线 _ 忽略：

for _, value := range "Go语言循环" {  
    fmt.Printf("%c ", value) // 输出各字符的 Unicode 码点  
}

五、高级技巧：并行循环与通道（Channel）

1. 并行处理与 Goroutine

结合 Go 的并发特性，可实现高效并行循环：

func processTask(task string) {  
    fmt.Println("处理任务:", task)  
}  

tasks := []string{"任务1", "任务2", "任务3"}  
for _, task := range tasks {  
    go processTask(task) // 每个任务启动一个 Goroutine  
}  
time.Sleep(time.Second) // 防止主线程提前退出

2. 通道与有限并发控制

通过通道限制并发数量，避免资源耗尽：

func worker(id int, jobs <-chan int, results chan<- int) {  
    for j := range jobs {  
        fmt.Printf("Worker %d 处理任务 %d\n", id, j)  
        results <- j * 2  
    }  
}  

jobs := make(chan int, 100)  
results := make(chan int, 100)  
for w := 1; w <= 3; w++ {  
    go worker(w, jobs, results)  
}  
// 发送任务并收集结果...

六、实战案例：文件行处理与统计

案例：统计文本文件中特定单词的出现次数

package main  

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

func countWord(filename, target string) (int, error) {  
    file, err := os.Open(filename)  
    if err != nil {  
        return 0, err  
    }  
    defer file.Close()  

    count := 0  
    scanner := bufio.NewScanner(file)  
    for scanner.Scan() { // 遍历每一行  
        line := scanner.Text()  
        words := strings.Fields(line) // 拆分单词  
        for _, word := range words {  
            if word == target {  
                count++  
            }  
        }  
    }  
    return count, scanner.Err()  
}  

func main() {  
    count, err := countWord("example.txt", "Go")  
    if err != nil {  
        fmt.Println("错误:", err)  
        return  
    }  
    fmt.Printf("单词 'Go' 出现 %d 次\n", count)  
}

关键点解析：

  1. 使用 bufio.Scanner 高效逐行读取文件
  2. for scanner.Scan() 自动循环直到文件末尾
  3. 双重循环：外层遍历行，内层遍历单词

结论

Go 语言的循环语句以简洁的 for 结构实现了强大的控制能力，从基础计数到复杂并发场景都能灵活应对。通过理解其语法设计逻辑（如 range 遍历、标签控制），开发者可以编写出高效且可维护的代码。无论是处理数据流、构建网络服务器，还是实现算法逻辑，掌握循环语句的“传送带”原理，都能让编程之路更加顺畅。

在实际开发中，建议结合 “提前终止条件” 和 “资源管理”（如及时关闭文件），避免无限循环或内存泄漏。随着 Go 的并发模型与循环结合，开发者能进一步释放多核计算能力，应对大数据和高并发挑战。希望本文能成为读者探索 Go 语言循环世界的指南针！

最新发布

查看更多文章