continue 跳过迭代 ​

什么是 continue ​

continue 用在循环中,作用是跳过当前这次迭代的剩余代码,直接进入下一次迭代。它可以用在 for、while 和 loop 三种循环中。遇到 continue 时,循环体中 continue 之后的代码不会执行,循环条件会被重新检查(for 和 while)或直接进入下一轮(loop)。

rust
fn main() {
    // 跳过偶数,只打印奇数
    for i in 1..=10 {
        if i % 2 == 0 {
            continue;  // 跳过本次迭代,直接进入下一个 i
        }
        println!("{}", i);
    }
    // 输出:1 3 5 7 9
}

在不同循环中使用 ​

rust
fn main() {
    // 在 for 循环中:跳到下一个迭代器元素
    print!("for: ");
    for ch in "Hello, World!".chars() {
        if !ch.is_alphabetic() {
            continue;  // 跳过非字母字符
        }
        print!("{}", ch);
    }
    println!();  // HelloWorld

    // 在 while 循环中:重新检查条件
    print!("while: ");
    let mut n = 0;
    while n < 10 {
        n += 1;
        if n % 3 == 0 {
            continue;  // 跳过 3 的倍数
        }
        print!("{} ", n);
    }
    println!();  // 1 2 4 5 7 8 10

    // 在 loop 中:跳到循环体开头
    print!("loop: ");
    let mut count = 0;
    loop {
        count += 1;
        if count > 10 {
            break;
        }
        if count % 2 != 0 {
            continue;  // 跳过奇数
        }
        print!("{} ", count);
    }
    println!();  // 2 4 6 8 10
}

continue 与 break 的对比 ​

特性continuebreak
作用跳过当前迭代的剩余代码退出整个循环
循环是否继续继续下一次迭代完全停止
能否携带值不能在 loop 中可以
能否配合标签可以(continue 'label)可以(break 'label)
rust
fn main() {
    let data = [5, -3, 8, -1, 12, 0, 7];

    // continue:跳过负数,继续处理后面的
    print!("continue 效果:");
    for &val in &data {
        if val < 0 {
            continue;  // 跳过负数
        }
        print!("{} ", val);
    }
    println!();  // 5 8 12 0 7

    // break:遇到负数就停止
    print!("break 效果:");
    for &val in &data {
        if val < 0 {
            break;  // 遇到负数就退出
        }
        print!("{} ", val);
    }
    println!();  // 5
}

continue 与标签 ​

在嵌套循环中,continue 默认跳过最内层循环的当前迭代。用 continue 'label 可以跳到外层循环的下一次迭代。

rust
fn main() {
    // 打印一个不含对角线元素的矩阵
    println!("跳过对角线:");
    'row: for i in 0..4 {
        for j in 0..4 {
            if i == j {
                // 跳过对角线位置,但只是内层循环
                continue;
            }
            print!("({},{}) ", i, j);
        }
        println!();
    }

    println!();

    // continue 'label:跳到外层循环的下一次迭代
    println!("遇到特定条件跳过整行:");
    'outer: for i in 0..4 {
        for j in 0..4 {
            if i + j > 4 {
                // i+j 超过 4 时跳过这一行剩余的所有元素
                continue 'outer;
            }
            print!("({},{}) ", i, j);
        }
        println!();
    }
    println!();
}

while 循环中 continue 的陷阱 ​

在 while 循环中使用 continue 时要特别注意:如果递增变量的代码在 continue 之后,会导致死循环。

rust
fn main() {
    // 错误示范:continue 跳过了 i += 1,导致死循环
    // let mut i = 0;
    // while i < 10 {
    //     if i == 5 {
    //         continue;  // 跳过了下面的 i += 1,i 永远是 5
    //     }
    //     println!("{}", i);
    //     i += 1;
    // }

    // 正确做法:把递增放在 continue 之前
    let mut i = 0;
    while i < 10 {
        i += 1;  // 先递增
        if i == 5 {
            continue;  // 跳过打印,但 i 已经递增了
        }
        println!("{}", i);
    }

    // 或者更好:用 for 循环避免这个问题
    for i in 0..10 {
        if i == 5 {
            continue;  // for 循环自动处理迭代,不会死循环
        }
        println!("{}", i);
    }
}

基本示例 ​

数据清洗——过滤和处理数据:

rust
fn main() {
    // 原始数据,包含各种需要跳过的情况
    let raw_data = vec![
        "  张三  ", "42", "", "  ", "李四", "abc", "28",
        "王五", "35", "not_a_number", "赵六", "22",
    ];

    // 解析姓名-年龄对,跳过无效数据
    let mut records: Vec<(String, u32)> = Vec::new();
    let mut iter = raw_data.iter();

    loop {
        // 取姓名
        let name = loop {
            match iter.next() {
                None => {
                    // 数据用完了
                    println!("\n解析完成");
                    println!("有效记录:");
                    for (name, age) in &records {
                        println!("  {} - {} 岁", name, age);
                    }
                    return;
                }
                Some(s) => {
                    let trimmed = s.trim();
                    if trimmed.is_empty() {
                        continue;  // 跳过空白条目
                    }
                    // 如果是数字则不是姓名,跳过
                    if trimmed.parse::<u32>().is_ok() {
                        continue;
                    }
                    break trimmed.to_string();
                }
            }
        };

        // 取年龄
        let age = loop {
            match iter.next() {
                None => return,
                Some(s) => {
                    let trimmed = s.trim();
                    if trimmed.is_empty() {
                        continue;  // 跳过空白
                    }
                    match trimmed.parse::<u32>() {
                        Ok(n) => break n,
                        Err(_) => {
                            println!("跳过无效年龄:'{}'", trimmed);
                            continue;
                        }
                    }
                }
            }
        };

        records.push((name, age));
    }
}

常见问题 ​

问题一:continue 后面的代码还会执行吗?

不会。continue 之后、循环体结尾之前的代码都会被跳过。编译器会对 continue 之后的不可达代码发出警告。

问题二:continue 能用在 match 分支里吗?

可以,只要 match 在循环内部。continue 会跳过包含这个 match 的循环的当前迭代。

rust
fn main() {
    let items = vec![Ok(1), Err("bad"), Ok(3), Err("fail"), Ok(5)];

    let mut sum = 0;
    for item in &items {
        match item {
            Ok(n) => sum += n,
            Err(e) => {
                println!("跳过错误:{}", e);
                continue;  // 跳过这次 for 循环的迭代
            }
        }
        // 只有 Ok 的情况才会执行到这里
        println!("当前累计:{}", sum);
    }
}

问题三:continue 和 return 有什么区别?

continue 跳过当前迭代继续循环,return 直接退出整个函数。continue 的作用范围是循环,return 的作用范围是函数。

问题四:什么时候用 continue,什么时候用 if 包裹?

两种写法等价,但 continue 适合在循环开头做"过滤",减少缩进层级。

rust
fn main() {
    let items = vec![1, -2, 3, -4, 5];

    // 用 continue 过滤(扁平结构,推荐)
    for &x in &items {
        if x < 0 { continue; }
        println!("处理:{}", x);
    }

    // 用 if 包裹(多一层缩进)
    for &x in &items {
        if x >= 0 {
            println!("处理:{}", x);
        }
    }
}

适用场景 ​

  • 数据过滤:跳过不满足条件的元素
  • 输入验证:跳过无效输入,继续处理下一个
  • 异常跳过:遇到错误时跳过当前条目,不中断整体流程
  • 条件排除:在循环开头排除不需要处理的情况,减少嵌套

注意事项 ​

  • continue 默认作用于最内层循环
  • 在 while 循环中,确保 continue 不会跳过递增变量的代码,否则会死循环
  • for 循环中使用 continue 不会有死循环风险,因为迭代器自动推进
  • continue 'label 可以跳到外层循环的下一次迭代
  • continue 后面的代码不会执行
  • 过多的 continue 会让控制流变得难以理解,适度使用

总结 ​

continue 用于跳过循环中当前迭代的剩余代码,直接进入下一次迭代。它最常见的用法是在循环开头做"过滤"——不满足条件的元素直接跳过,让后续代码只处理有效数据,减少缩进层级。在 while 循环中使用时要注意不要跳过递增代码导致死循环。配合标签可以跳到外层循环的下一次迭代。continue 和 break 的核心区别是:continue 跳过当前迭代但循环继续,break 直接退出整个循环。