GO语言基础教程（42）Go循环语句之循环嵌套：套娃大法好！Go语言循环嵌套全攻略，别被绕晕了

一、循环嵌套：编程界的"套娃艺术"

老铁们，如果你觉得单层循环已经够简单了，那今天咱们要聊的循环嵌套，就是要把简单事情玩出花来！想象一下俄罗斯套娃，大娃娃里面装小娃娃，小娃娃里面还有更小的娃娃——循环嵌套就是这个道理。

在Go语言里，循环嵌套说白了就是在一个循环体内再写另一个循环。听起来是不是有点绕？别担心，这其实是处理复杂问题的神器！比如你要处理一个Excel表格，有行有列，单层循环就搞不定了，这时候嵌套循环就派上用场了。

我刚开始学嵌套的时候，脑子里也是一团浆糊。但当我真正理解后，才发现这玩意儿真香！它能让你用少量代码解决复杂问题，绝对是Go程序员必备技能。

二、Go循环基础回顾：磨刀不误砍柴工

在深入"套娃"之前，咱得先把基本的循环语法搞清楚。Go语言就一种循环结构——for循环，但玩出了三种花样：

1. 经典for循环

for i := 0; i < 5; i++ {
    fmt.Println("这是第", i, "次循环")
}

这种最常用，初始化、条件判断、步进操作一气呵成。

2. while风格的for循环

count := 0
for count < 5 {
    fmt.Println("count值为:", count)
    count++
}

Go里面没有while关键字，用for一样能实现同样效果。

3. 无限循环

for {
    fmt.Println("我一直循环，直到遇见break")
    // 通常配合break使用
    if condition {
        break
    }
}

这种要小心使用，不然真成"死循环"了。

三、循环嵌套实战：从入门到精通

好了，重头戏来了！咱们直接上代码，看看循环嵌套到底怎么用。

案例1：打印九九乘法表

这是最经典的嵌套循环案例，能帮你直观理解执行流程：

package main

import "fmt"

func main() {
    // 外层循环控制行
    for i := 1; i <= 9; i++ {
        // 内层循环控制列
        for j := 1; j <= i; j++ {
            fmt.Printf("%d×%d=%d\t", j, i, i*j)
        }
        // 每行结束后换行
        fmt.Println()
    }
}

运行结果就是咱们小时候背的九九乘法表！这里的执行顺序是：外层循环走一步，内层循环走一圈。当i=1时，j从1到1循环一次；当i=2时，j从1到2循环两次，依此类推。

案例2：遍历二维数组

二维数组简直就是为嵌套循环量身定做的：

package main

import "fmt"

func main() {
    // 定义一个3x3的二维数组
    matrix := [3][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }
    
    fmt.Println("二维数组遍历结果:")
    
    // 外层循环遍历行
    for i := 0; i < 3; i++ {
        // 内层循环遍历列
        for j := 0; j < 3; j++ {
            fmt.Printf("matrix[%d][%d] = %d  ", i, j, matrix[i][j])
        }
        fmt.Println() // 换行
    }
}

这就像你在教室里找座位一样，先确定第几排（外层循环），再确定第几列（内层循环）。

四、进阶玩法：多重嵌套与算法实现

如果你觉得两层嵌套已经够用了，那就太小看Go循环了！咱们来看个三重重嵌套的实战案例——冒泡排序。

案例3：冒泡排序算法

package main

import "fmt"

func main() {
    arr := [5]int{64, 34, 25, 12, 22}
    fmt.Println("排序前:", arr)
    
    length := len(arr)
    
    // 外层循环控制排序轮数
    for i := 0; i < length-1; i++ {
        // 内层循环进行相邻元素比较交换
        for j := 0; j < length-i-1; j++ {
            if arr[j] > arr[j+1] {
                // 交换元素
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
        fmt.Printf("第%d轮排序结果: %v\n", i+1, arr)
    }
    
    fmt.Println("排序后:", arr)
}

这个例子中，外层循环控制比较的轮数，内层循环在每一轮中进行相邻元素的比较和交换。通过两层嵌套，我们实现了一个经典的排序算法。

五、避坑指南与性能优化

嵌套循环虽然强大，但用不好也会掉坑里。下面这几个坑，我当年都踩过：

坑1：循环变量混淆

// 错误示范
for i := 0; i < 3; i++ {
    for i := 0; i < 2; i++ { // 内外层都用i，乱套了！
        fmt.Println(i)
    }
}

// 正确做法
for i := 0; i < 3; i++ {
    for j := 0; j < 2; j++ { // 内外层用不同变量名
        fmt.Printf("i=%d, j=%d\n", i, j)
    }
}

坑2：无限循环陷阱

// 小心这种写法！
for i := 0; i < 5; i++ {
    for j := 0; i < 5; j++ { // 条件判断写错了！
        // 这里可能变成无限循环
    }
}

性能优化技巧：

减少内层循环工作量：把能提前计算的东西放在外层
避免在循环内部分配内存：尽量复用变量
适时使用break和continue：提前结束不必要的循环

// 优化前
for i := 0; i < 1000; i++ {
    for j := 0; j < 1000; j++ {
        result := heavyCalculation(i, j) // 每次循环都调用
    }
}

// 优化后
for i := 0; i < 1000; i++ {
    temp := preCalculate(i) // 提前计算
    for j := 0; j < 1000; j++ {
        result := lightCalculation(temp, j) // 简化内层计算
    }
}

六、实际应用场景

学会了循环嵌套，你在实际开发中能做什么呢？

游戏开发：遍历地图上的每个格子
数据分析：处理Excel表格的行和列
图像处理：操作图片的像素点
Web开发：渲染动态表格数据

比如生成一个简单的网页表格：

package main

import "fmt"

func main() {
    data := [3][3]string{
        {"产品", "价格", "库存"},
        {"手机", "2999", "100"},
        {"电脑", "5999", "50"},
    }
    
    fmt.Println("<table>")
    for i := 0; i < 3; i++ {
        fmt.Println("  <tr>")
        for j := 0; j < 3; j++ {
            fmt.Printf("    <td>%s</td>\n", data[i][j])
        }
        fmt.Println("  </tr>")
    }
    fmt.Println("</table>")
}