异常教程

Go 语言 continue 语句（超详细）

更新时间:

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

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

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

前言

在编程世界中，循环结构是解决问题的核心工具之一。无论是遍历数组、处理数据流，还是构建复杂算法，开发者都需要通过循环高效地执行重复性任务。然而，当遇到需要**“跳过当前迭代”**的场景时，如何优雅地控制循环的流程成为关键问题。在 Go 语言中，continue 语句正是为此而生的解决方案。它如同循环中的“暂停键”，允许程序在满足特定条件时跳过当前迭代的剩余代码，直接进入下一次循环的判断阶段。

本文将深入解析 Go 语言 continue 语句 的核心用法、适用场景及进阶技巧。通过对比实际案例与代码示例，帮助开发者理解其工作原理，并掌握如何通过 continue 提升代码的简洁性与可读性。无论是编程初学者还是中级开发者，都能从中获得实用的技巧与启发。

Continue 语句的基础语法

在 Go 语言中，continue 语句的语法非常简洁：

continue

它的作用是立即终止当前循环迭代的执行，并跳转到循环的条件判断阶段，准备开始下一次迭代。

与 break 的对比

continue 和 break 是 Go 语言中两个控制循环流程的关键语句，但它们的行为截然不同：

  • break：终止整个循环的执行，跳出循环体。
  • continue：仅终止当前迭代，进入下一次循环的条件检查。

对比示例

for i := 0; i < 5; i++ {  
    if i == 2 {  
        continue // 跳过 i=2 的后续代码  
    }  
    fmt.Println("Current i:", i)  
}  
// 输出：  
// Current i: 0  
// Current i: 1  
// Current i: 3  
// Current i: 4

在此示例中，当 i=2 时，continue 语句会跳过 fmt.Println 的执行，直接进入下一轮循环的条件判断。

在单层循环中的使用场景

场景 1：过滤特定条件

假设需要遍历一个整数数组，仅打印偶数：

numbers := []int{1, 2, 3, 4, 5, 6}  
for _, num := range numbers {  
    if num%2 != 0 {  
        continue // 跳过奇数  
    }  
    fmt.Printf("偶数: %d\n", num)  
}  
// 输出：  
// 偶数: 2  
// 偶数: 4  
// 偶数: 6

比喻：这就像在流水线上筛选产品，当检测到不符合条件的产品时，直接将其“跳过”而不进行后续加工。

场景 2：提前终止当前迭代

在计算过程中，若某次迭代的结果无效，可直接跳过后续逻辑：

for i := 1; i <= 5; i++ {  
    if i == 3 {  
        fmt.Println("跳过 i=3 的计算")  
        continue  
    }  
    result := i * 2  
    fmt.Printf("i=%d 的结果: %d\n", i, result)  
}  
// 输出：  
// i=1 的结果: 2  
// i=2 的结果: 4  
// 跳过 i=3 的计算  
// i=4 的结果: 8  
// i=5 的结果: 10

通过 continue，我们避免了在 i=3 时执行冗余的乘法运算，提升了代码的执行效率。

多层循环中的高级用法

在嵌套循环中，continue 可能需要配合 标签（label） 来控制跳转范围。例如，当外层循环需要根据内层循环的条件跳过当前迭代时：

示例：二维数组中的条件跳过

matrix := [][]int{{1, 2}, {3, 4}, {5, 6}}  
OuterLoop:  
for i := 0; i < len(matrix); i++ {  
    for j := 0; j < len(matrix[i]); j++ {  
        if matrix[i][j] == 4 {  
            continue OuterLoop // 跳回外层循环的下一次迭代  
        }  
        fmt.Printf("元素值: %d\n", matrix[i][j])  
    }  
}  
// 输出：  
// 元素值: 1  
// 元素值: 2  
// 元素值: 5  
// 元素值: 6

关键点解释：

  • 标签 OuterLoop 标记了外层循环。
  • 当内层循环遇到值为 4 的元素时，continue OuterLoop 会直接跳转到外层循环的下一轮迭代，从而跳过内层循环的剩余元素。

比喻：这如同在迷宫中，当发现一条死路（值为 4）时，直接回到上一层路径的入口，继续探索其他分支。

注意事项与最佳实践

1. 避免滥用 continue

过度使用 continue 可能导致代码逻辑混乱。例如：

// 不良示例：条件判断过于复杂  
for i := 0; i < 10; i++ {  
    if i%2 == 0 { continue }  
    if i > 5 { continue }  
    // 其他复杂条件...  
    // ...  
}

改进建议：通过重构条件或调整循环结构，让代码更易读：

for i := 0; i < 10; i++ {  
    if i%2 == 0 || i > 5 {  
        continue  
    }  
    // 简化的逻辑分支  
}

2. 标签命名规范

在多层循环中使用标签时，建议采用有意义的名称，如 OuterLoop 或 RowLoop，而非 Loop1，以增强代码可读性。

3. 结合 if 语句的简洁写法

Go 语言支持将 if 条件与 continue 直接结合，减少代码层级：

for _, num := range numbers {  
    if num%2 != 0 { continue } // 简洁写法  
    // 后续逻辑  
}

实战案例：过滤无效数据

场景描述

假设需要从一个包含 nil 值的切片中，提取有效数据并计算总和：

type Item struct {  
    Value int  
}  
items := []Item{  
    {Value: 10},  
    {Value: 0}, // 无效数据（假设 Value=0 表示无效）  
    {Value: 20},  
    {},          // 结构体未初始化，Value 为零值 0  
}

解决方案

使用 continue 跳过无效项：

sum := 0  
for _, item := range items {  
    if item.Value == 0 {  
        continue // 跳过 Value=0 的项  
    }  
    sum += item.Value  
}  
fmt.Println("总和:", sum) // 输出：总和: 30

扩展思考：若需要同时处理未初始化的结构体（如 item 的零值），可添加额外条件：

if item.Value == 0 && item != (Item{}) { continue } // 仅跳过 Value=0 但非零值的项

总结

continue 语句是 Go 语言中控制循环流程的重要工具，它通过跳过当前迭代的剩余代码，帮助开发者高效处理条件分支。无论是单层循环的简单过滤，还是多层循环的复杂逻辑，合理使用 continue 都能提升代码的简洁性与可维护性。

通过本文的示例与分析，读者应能掌握以下核心要点：

  • 基础语法：continue 的基本用法与与 break 的区别。
  • 单层循环场景：条件过滤与逻辑跳转的典型应用。
  • 多层循环技巧：标签的使用与嵌套结构的优化。
  • 最佳实践：避免滥用 continue，保持代码清晰。

在实际开发中，建议结合具体业务场景，灵活运用 continue 语句，同时注重代码的可读性与可维护性。通过不断实践与优化，开发者将能更高效地掌控 Go 语言的循环逻辑，构建出优雅且高效的解决方案。

最新发布

查看更多文章