Rust中复杂条件下if-else链的可读性替代方案

1. 用match true模拟无参数Switch #

这是最贴近Go无参数switch写法的方案，直接将每个条件作为match的分支模式，利用Rust的匹配守卫（guard）实现任意条件判断：

fn check_thing(t: Thing) -> CarryRule {
    let allowed = vec!["birds","dogs","cats","elefants","unknown","veggies","meat"];
    let max_carry_size = 30;
    let max_carry_unknown_size = 3;
    let max_carry_dog_size = 5;
    let typ = t.typ.as_str();

    match true {
        _ if t.size > max_carry_size => CarryRule::Forbidden,
        _ if !allowed.contains(&typ) => CarryRule::Forbidden,
        _ if typ == "unknown" && t.size > max_carry_unknown_size => CarryRule::Forbidden,
        _ if typ == "dogs" && t.size > max_carry_dog_size => CarryRule::Forbidden,
        _ if typ == "birds" => CarryRule::UseCage,
        _ => CarryRule::UseBox,
    }
}

每个分支的_ if 条件结构等价于Go的switch case，按顺序匹配第一个满足条件的分支，逻辑和原if-else链完全一致，但结构更规整。

2. 提取判断逻辑为辅助函数 #

如果条件逻辑复杂，可以把每个判断拆成独立的小函数，让主函数的逻辑更直观：

fn check_thing(t: Thing) -> CarryRule {
    let allowed = vec!["birds","dogs","cats","elefants","unknown","veggies","meat"];
    let max_carry_size = 30;
    let max_carry_unknown_size = 3;
    let max_carry_dog_size = 5;
    let typ = t.typ.as_str();

    if is_over_size_limit(t.size, max_carry_size) {
        CarryRule::Forbidden
    } else if !is_type_allowed(typ, &allowed) {
        CarryRule::Forbidden
    } else if is_unknown_over_limit(typ, t.size, max_carry_unknown_size) {
        CarryRule::Forbidden
    } else if is_dog_over_limit(typ, t.size, max_carry_dog_size) {
        CarryRule::Forbidden
    } else if typ == "birds" {
        CarryRule::UseCage
    } else {
        CarryRule::UseBox
    }
}

// 辅助函数示例
fn is_over_size_limit(size: u32, max: u32) -> bool {
    size > max
}

fn is_type_allowed(typ: &str, allowed: &[&str]) -> bool {
    allowed.contains(&typ)
}

fn is_unknown_over_limit(typ: &str, size: u32, max: u32) -> bool {
    typ == "unknown" && size > max
}

fn is_dog_over_limit(typ: &str, size: u32, max: u32) -> bool {
    typ == "dogs" && size > max
}

这种方式通过语义化的函数名，让主逻辑一眼就能看懂每个判断的意图，后续维护也更方便。

3. 结合模式匹配与守卫的混合写法 #

如果想利用Rust模式匹配的优势，同时避免过度包装，可以针对t.typ的特定值结合守卫条件，把类型相关的判断整合到match中，通用条件放在前面：

fn check_thing(t: Thing) -> CarryRule {
    let allowed = vec!["birds","dogs","cats","elefants","unknown","veggies","meat"];
    let max_carry_size = 30;
    let max_carry_unknown_size = 3;
    let max_carry_dog_size = 5;
    let typ = t.typ.as_str();

    // 先处理全局禁止的通用条件
    if t.size > max_carry_size || !allowed.contains(&typ) {
        return CarryRule::Forbidden;
    }

    // 针对特定类型做匹配+守卫检查
    match typ {
        "unknown" if t.size > max_carry_unknown_size => CarryRule::Forbidden,
        "dogs" if t.size > max_carry_dog_size => CarryRule::Forbidden,
        "birds" => CarryRule::UseCage,
        _ => CarryRule::UseBox,
    }
}

这种写法把全局通用的判断提前，剩下的类型专属逻辑用match处理，兼顾了模式匹配的简洁性和逻辑的分层。

内容的提问来源于stack exchange，提问作者Juve