编辑“︁Go Break Continue”︁

= Go Break Continue =  
'''Break''' 和 '''Continue''' 是 Go 语言中用于控制循环执行流程的两个关键字。它们在循环结构（如 `for`、`range`）中起到关键作用，帮助开发者更灵活地管理循环行为。  

== 介绍 ==  
在 Go 中，循环通常使用 `for` 关键字实现。`break` 和 `continue` 提供了额外的控制能力：  
* '''`break`'''：立即终止当前循环，跳出循环体。  
* '''`continue`'''：跳过当前循环的剩余部分，直接进入下一次循环迭代。  

这两个关键字可以显著提升代码的可读性和效率，特别是在处理复杂循环逻辑时。  

== `break` 关键字 ==  
`break` 用于提前退出循环，无论循环条件是否满足。  

=== 基本语法 ===  
<syntaxhighlight lang="go">  
for initialization; condition; post {  
    // 循环体  
    if someCondition {  
        break // 立即退出循环  
    }  
}  
</syntaxhighlight>  

=== 示例：在 `for` 循环中使用 `break` ===  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
    for i := 1; i <= 10; i++ {  
        if i == 5 {  
            break // 当 i 等于 5 时退出循环  
        }  
        fmt.Println(i)  
    }  
    fmt.Println("循环结束")  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
1  
2  
3  
4  
循环结束  
</pre>  

'''解释：'''  
当 `i` 的值达到 5 时，`break` 语句执行，循环立即终止，后续的 `i` 值（6 到 10）不再处理。  

=== 实际应用：搜索元素 ===  
假设我们要在一个切片中查找特定元素，找到后立即终止循环：  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
    numbers := []int{2, 4, 6, 8, 10}  
    target := 6  
    found := false  

    for _, num := range numbers {  
        if num == target {  
            found = true  
            break  
        }  
    }  

    if found {  
        fmt.Printf("找到目标值 %d\n", target)  
    } else {  
        fmt.Println("未找到目标值")  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
找到目标值 6  
</pre>  

== `continue` 关键字 ==  
`continue` 用于跳过当前循环迭代的剩余部分，直接进入下一次循环。  

=== 基本语法 ===  
<syntaxhighlight lang="go">  
for initialization; condition; post {  
    // 循环体  
    if someCondition {  
        continue // 跳过剩余代码，进入下一次迭代  
    }  
    // 其他代码  
}  
</syntaxhighlight>  

=== 示例：跳过偶数 ===  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
    for i := 1; i <= 10; i++ {  
        if i%2 == 0 {  
            continue // 跳过偶数  
        }  
        fmt.Println(i)  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
1  
3  
5  
7  
9  
</pre>  

'''解释：'''  
当 `i` 是偶数时，`continue` 跳过 `fmt.Println(i)`，直接进入下一次循环，因此只有奇数被打印。  

=== 实际应用：过滤无效数据 ===  
在处理数据时，可能需要跳过不符合条件的记录：  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
    data := []int{-1, 2, 0, 4, -5, 6}  

    for _, val := range data {  
        if val <= 0 {  
            continue // 跳过非正数  
        }  
        fmt.Println("有效数据:", val)  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
有效数据: 2  
有效数据: 4  
有效数据: 6  
</pre>  

== `break` 与 `continue` 对比 ==  
以下表格总结了二者的区别：  

{| class="wikitable"  
|+ '''`break` vs `continue`'''  
! 关键字 !! 行为 !! 适用场景  
|-  
| `break` || 立即终止整个循环 || 提前退出循环（如找到目标）  
|-  
| `continue` || 跳过当前迭代，进入下一次循环 || 过滤特定条件的数据  
|}  

== 嵌套循环中的 `break` 和 `continue` ==  
在嵌套循环中，`break` 和 `continue` 默认只影响最内层的循环。如果需要控制外层循环，可以使用 '''标签（Label）'''。  

=== 带标签的 `break` ===  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
outerLoop:  
    for i := 1; i <= 3; i++ {  
        for j := 1; j <= 3; j++ {  
            if i == 2 && j == 2 {  
                break outerLoop // 跳出外层循环  
            }  
            fmt.Printf("i=%d, j=%d\n", i, j)  
        }  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
i=1, j=1  
i=1, j=2  
i=1, j=3  
i=2, j=1  
</pre>  

=== 带标签的 `continue` ===  
<syntaxhighlight lang="go">  
package main  

import "fmt"  

func main() {  
outerLoop:  
    for i := 1; i <= 3; i++ {  
        for j := 1; j <= 3; j++ {  
            if i == 2 && j == 2 {  
                continue outerLoop // 跳过外层循环的当前迭代  
            }  
            fmt.Printf("i=%d, j=%d\n", i, j)  
        }  
    }  
}  
</syntaxhighlight>  

'''输出：'''  
<pre>  
i=1, j=1  
i=1, j=2  
i=1, j=3  
i=2, j=1  
i=3, j=1  
i=3, j=2  
i=3, j=3  
</pre>  

== 性能考虑 ==  
* `break` 和 `continue` 通常不会显著影响性能，但过度使用可能降低代码可读性。  
* 在嵌套循环中，带标签的 `break` 和 `continue` 可以避免冗余的条件检查，提高效率。  

== 总结 ==  
* `break` 用于立即退出循环。  
* `continue` 用于跳过当前迭代，进入下一次循环。  
* 在嵌套循环中，可以使用标签控制外层循环的行为。  
* 合理使用这两个关键字可以优化循环逻辑，提升代码清晰度。  

通过本文的学习，你应该能够熟练运用 `break` 和 `continue` 来优化 Go 程序中的循环结构。

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