编辑“︁Go 嵌套循环”︁

{{DISPLAYTITLE:Go嵌套循环}}

'''Go嵌套循环'''是指在Go语言中，一个循环结构（如<code>for</code>）内部包含另一个循环结构的编程技术。嵌套循环常用于处理多维数据结构（如二维数组）或需要多层迭代的场景。本文将详细介绍Go嵌套循环的基本语法、实际应用及注意事项。

== 基本概念 ==
嵌套循环是指在一个循环体内部再定义一个或多个循环。外层循环每执行一次，内层循环会完整执行一遍。在Go语言中，<code>for</code>是唯一的循环结构，但可以通过嵌套实现复杂的迭代逻辑。

=== 语法结构 ===
以下是Go嵌套循环的基本语法：
<syntaxhighlight lang="go">
for 初始化语句; 条件表达式; 后置语句 {
    // 外层循环代码
    for 初始化语句; 条件表达式; 后置语句 {
        // 内层循环代码
    }
}
</syntaxhighlight>

== 代码示例 ==
=== 示例1：打印乘法表 ===
以下代码演示了如何使用嵌套循环打印一个简单的乘法表：
<syntaxhighlight lang="go">
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, j*i)
        }
        fmt.Println()              // 每行结束后换行
    }
}
</syntaxhighlight>

'''输出结果：'''
<pre>
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
...
1*9=9	2*9=18	...	9*9=81
</pre>

=== 示例2：遍历二维数组 ===
嵌套循环常用于处理二维数组：
<syntaxhighlight lang="go">
package main

import "fmt"

func main() {
    matrix := [3][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }

    for i := 0; i < len(matrix); i++ {         // 遍历行
        for j := 0; j < len(matrix[i]); j++ {  // 遍历列
            fmt.Printf("%d ", matrix[i][j])
        }
        fmt.Println()
    }
}
</syntaxhighlight>

'''输出结果：'''
<pre>
1 2 3 
4 5 6 
7 8 9 
</pre>

== 实际应用场景 ==
=== 场景1：图像处理 ===
在图像处理中，嵌套循环可用于遍历像素矩阵。例如，将彩色图像转换为灰度图：
<syntaxhighlight lang="go">
for y := 0; y < height; y++ {
    for x := 0; x < width; x++ {
        r, g, b := getPixel(x, y)
        gray := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
        setPixel(x, y, uint8(gray))
    }
}
</syntaxhighlight>

=== 场景2：游戏开发 ===
在棋盘类游戏（如围棋）中，嵌套循环用于检测棋盘状态：
<syntaxhighlight lang="go">
for row := 0; row < boardSize; row++ {
    for col := 0; col < boardSize; col++ {
        if board[row][col] == opponentStone {
            checkSurroundings(row, col)
        }
    }
}
</syntaxhighlight>

== 性能注意事项 ==
* '''时间复杂度'''：嵌套循环的时间复杂度通常是<math>O(n^2)</math>，需谨慎处理大数据集。
* '''循环优化'''：可通过以下方式优化：
  * 减少内层循环的计算量（如提前计算常量）
  * 使用<code>break</code>提前终止循环

== 流程图示例 ==
以下Mermaid流程图展示了嵌套循环的执行逻辑：
<mermaid>
flowchart TD
    A[外层循环开始] --> B{外层条件满足?}
    B -->|是| C[内层循环开始]
    C --> D{内层条件满足?}
    D -->|是| E[执行内层代码]
    E --> D
    D -->|否| F[外层循环迭代]
    F --> B
    B -->|否| G[结束]
</mermaid>

== 常见错误与调试 ==
* '''无限循环'''：确保内/外层循环的终止条件可被满足。
* '''变量覆盖'''：避免内外层循环使用同名变量（如均用<code>i</code>）。
* '''边界错误'''：检查循环条件是否包含等号（如<code><=</code>与<code><</code>）。

== 进阶技巧 ==
* '''标签跳出'''：使用标签直接跳出多层循环：
<syntaxhighlight lang="go">
outerLoop:
for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
        if condition {
            break outerLoop  // 直接跳出外层循环
        }
    }
}
</syntaxhighlight>

* '''并行化处理'''：对于计算密集型任务，可在内层循环使用goroutine（需注意同步问题）。

== 总结 ==
Go嵌套循环是处理多维数据和多层逻辑的重要工具。通过合理设计循环结构和优化性能，可以高效解决复杂问题。初学者应通过实际练习（如打印图形、矩阵运算）逐步掌握其应用场景。

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 控制流]]