break 'label 标签跳出 ​

什么是循环标签 ​

循环标签(Loop Label)是给循环起一个名字,语法是在循环前加 '标签名:。在嵌套循环中,break 和 continue 默认作用于最内层循环。如果你需要从内层循环中退出外层循环,就需要用标签来指定目标。

标签名以单引号 ' 开头,后跟一个标识符,通常用小写蛇形命名。

rust
fn main() {
    // 给外层循环加标签 'outer
    'outer: for i in 0..5 {
        for j in 0..5 {
            if i + j == 6 {
                println!("i={}, j={} 时退出外层循环", i, j);
                break 'outer;  // 退出外层循环
            }
        }
    }
    println!("循环结束");
}

没有标签时的问题 ​

rust
fn main() {
    // 没有标签:break 只退出内层循环
    for i in 0..3 {
        for j in 0..3 {
            if j == 1 {
                break;  // 只退出内层 for j 循环
            }
            println!("i={}, j={}", i, j);
        }
        // 外层循环继续执行
    }
    // 输出:
    // i=0, j=0
    // i=1, j=0
    // i=2, j=0

    println!("---");

    // 有标签:break 'outer 退出外层循环
    'outer: for i in 0..3 {
        for j in 0..3 {
            if j == 1 {
                break 'outer;  // 退出外层循环
            }
            println!("i={}, j={}", i, j);
        }
    }
    // 输出:
    // i=0, j=0
}

标签与 loop ​

rust
fn main() {
    let mut outer_count = 0;

    // loop 也可以加标签
    let result = 'search: loop {
        outer_count += 1;
        let mut inner_count = 0;

        loop {
            inner_count += 1;

            if outer_count * inner_count == 12 {
                // 从外层 loop 退出并返回值
                break 'search (outer_count, inner_count);
            }

            if inner_count >= 10 {
                break;  // 只退出内层 loop
            }
        }

        if outer_count >= 10 {
            break 'search (0, 0);  // 安全退出
        }
    };

    println!("找到:{} * {} = 12", result.0, result.1);
}

标签与 continue ​

continue 也可以配合标签使用,跳到指定外层循环的下一次迭代。

rust
fn main() {
    // continue 'outer 跳过外层循环的当前迭代
    'outer: for i in 0..5 {
        for j in 0..5 {
            if j == 2 {
                // 跳过外层循环的当前 i 值,进入下一个 i
                continue 'outer;
            }
            print!("({},{}) ", i, j);
        }
        // 因为 continue 'outer,这里在 j=2 时不会执行
        println!();  // 不会打印
    }
    println!();
    // 输出:(0,0) (0,1) (1,0) (1,1) (2,0) (2,1) (3,0) (3,1) (4,0) (4,1)
}

多层嵌套标签 ​

可以给多层循环分别加标签。

rust
fn main() {
    'level1: for i in 0..3 {
        'level2: for j in 0..3 {
            for k in 0..3 {
                if k == 1 {
                    continue 'level2;  // 跳到 level2 的下一次 j 迭代
                }
                if i == 1 && j == 1 {
                    break 'level1;  // 直接退出最外层
                }
                println!("i={}, j={}, k={}", i, j, k);
            }
        }
    }
}

标签与 break 返回值 ​

标签化的 loop 也支持 break 返回值。

rust
fn main() {
    // 在二维数据中搜索目标值
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];
    let target = 5;

    let position = 'search: loop {
        for (row, line) in matrix.iter().enumerate() {
            for (col, &val) in line.iter().enumerate() {
                if val == target {
                    break 'search Some((row, col));
                }
            }
        }
        break None;  // 遍历完了没找到
    };

    match position {
        Some((r, c)) => println!("找到 {} 在 ({}, {})", target, r, c),
        None => println!("{} 不在矩阵中", target),
    }
}

基本示例 ​

在嵌套结构中查找数据:

rust
struct Department {
    name: String,
    teams: Vec<Team>,
}

struct Team {
    name: String,
    members: Vec<String>,
}

fn find_member(departments: &[Department], target: &str) -> Option<(String, String)> {
    let mut result = None;

    'search: for dept in departments {
        for team in &dept.teams {
            for member in &team.members {
                if member == target {
                    result = Some((dept.name.clone(), team.name.clone()));
                    break 'search;  // 找到后立即退出所有循环
                }
            }
        }
    }

    result
}

fn main() {
    let company = vec![
        Department {
            name: String::from("工程部"),
            teams: vec![
                Team {
                    name: String::from("前端组"),
                    members: vec![String::from("张三"), String::from("李四")],
                },
                Team {
                    name: String::from("后端组"),
                    members: vec![String::from("王五"), String::from("赵六")],
                },
            ],
        },
        Department {
            name: String::from("产品部"),
            teams: vec![
                Team {
                    name: String::from("设计组"),
                    members: vec![String::from("钱七"), String::from("孙八")],
                },
            ],
        },
    ];

    let targets = ["王五", "孙八", "周九"];
    for name in &targets {
        match find_member(&company, name) {
            Some((dept, team)) => println!("{} 在 {} 的 {}", name, dept, team),
            None => println!("{} 不在公司中", name),
        }
    }
}

常见问题 ​

问题一:标签命名有什么规则?

标签以 ' 开头,后跟标识符。常用命名如 'outer、'inner、'search、'retry 等。标签名应该能表达循环的用途。

问题二:标签只能用在循环上吗?

循环标签只能加在 loop、while、for 前面。不能用在 if、match 等其他结构上。但 Rust 也支持块标签(block label),可以给代码块加标签然后 break 出去。

rust
fn main() {
    // 块标签(不是循环)
    let result = 'block: {
        if true {
            break 'block 42;
        }
        0
    };
    println!("{}", result);  // 42
}

问题三:break 'label 可以跳到不包含当前代码的循环吗?

不可以。break 'label 只能跳到包含当前位置的外层循环。不能跳到不相关的循环。

问题四:标签会影响性能吗?

不会。标签只是编译期的语法标记,不生成额外的运行时代码。

适用场景 ​

  • 嵌套循环中退出外层:在多层循环中找到目标后一次性退出
  • 嵌套循环中跳过外层迭代:用 continue 'label 跳到外层的下一次迭代
  • 多维数据搜索:在矩阵、树、嵌套集合中查找数据
  • 带返回值的嵌套搜索:配合 loop 标签和 break 返回值

注意事项 ​

  • 标签以 ' 开头,放在循环关键字前面
  • break 'label 退出指定标签的循环
  • continue 'label 跳到指定标签循环的下一次迭代
  • break 'label value 可以从标签化的 loop 返回值
  • 标签只能指向包含当前位置的外层循环
  • 不要过度使用标签——如果嵌套太深,考虑提取函数来简化
  • 标签名应该有意义,能表达循环的目的

总结 ​

循环标签让你能在嵌套循环中精确控制 break 和 continue 的目标。语法是在循环前加 '标签名:,然后用 break '标签名 退出指定的循环,或用 continue '标签名 跳到指定循环的下一次迭代。标签化的 loop 还支持 break '标签名 值 的返回值语法。标签最常见的用途是在多层嵌套循环中找到目标后一次性退出,避免设置标志变量然后逐层检查的繁琐写法。