Rust 用 `&&`、`||`、`!` 把条件组合起来

1 阅读5分钟

条件太简单?你需要「组合」

前几章我们学会了 if / else / else if,但里面的条件一直很简单——一次只判断一件事:x > 3、score >= 90。

现实里的规则往往要同时考虑好几件事:

  • 「至少 18 岁 并且 是学生」才能享受学生票;
  • 「周末 或者 节假日」不用上班;
  • 「没有 下雨」才出去散步。

要把多个条件拼成一个判断,就要用到逻辑运算符。本章目标:

用 &&(and)、||(or)、!(not)组合多个条件。

Rust 里一共三个逻辑运算符,下面逐个拆解。


&& —— 逻辑与(AND)

两边都为 true,结果才是 true。

fn main() {
    let age = 24;
    let is_student = true;

    if age >= 18 && is_student {
        println!("An adult student");
    }
}

推演:24 >= 18 是 true,is_student 也是 true——两边都成立,整体为 true,输出:

An adult student

如果把 age 改成 15,那么 15 >= 18 是 false。无论 is_student 是真是假,整个 && 都是 false,什么都不打印。

真值表(记住这张表,&& 就掌握了):

ABA && B
truetruetrue
truefalsefalse
falsetruefalse
falsefalsefalse

口诀:一假即假,全真才真。


|| —— 逻辑或(OR)

只要一边为 true,结果就是 true。

fn main() {
    let is_weekend = false;
    let is_holiday = true;

    if is_weekend || is_holiday {
        println!("No work today!");
    }
}

虽然 is_weekend 是 false,但 is_holiday 是 true——一个 true 就够了,整体成立,输出:

No work today!

真值表:

ABA || B
truetruetrue
truefalsetrue
falsetruetrue
falsefalsefalse

口诀:一真即真,全假才假。


! —— 逻辑非(NOT)

把 true 变 false,false 变 true。

和前两个不同,! 是一元运算符,只作用于一个值:

fn main() {
    let raining = false;

    if !raining {
        println!("Let's go out for a walk!");
    }
}

raining 是 false,前面加 ! 变成 true,条件成立,输出:

Let's go out for a walk!

读法很自然:if not raining —— 「如果没下雨,就出去散步」。

A!A
truefalse
falsetrue

扩展一:短路求值(short-circuit)—— 原文没讲,但很重要

三个运算符的核心是「组合条件」,而 Rust 在组合时有个关键行为:短路求值。

  • 对 A && B:如果 A 是 false,结果注定是 false,那么 B 根本不会被执行;
  • 对 A || B:如果 A 是 true,结果注定是 true,那么 B 根本不会被执行。

为什么要在意?因为右边可能是有「副作用」或会出错的表达式。看这个经典例子:

fn main() {
    let v = vec![1, 2, 3];

    // ✅ 安全:i < v.len() 为 false 时,右边的索引访问不会发生
    if v.len() > 0 && v[0] == 1 {
        println!("first is 1");
    }
}

如果 Rust 不做短路(两边都算),那在空向量上 v[0] 就会越界 panic。正因为 && 左假即止,右边被保护住了。

再看一个直观的副作用演示:

fn main() {
    let a = false;
    let b = true;

    // b 那一行根本不会执行
    if a && side_effect(b) {
        println!("never");
    }
}

fn side_effect(x: bool) -> bool {
    println!("side_effect called!"); // 不会被打印
    x
}

因为 a 是 false,&& 直接短路,side_effect 从未被调用。记住这条:把便宜/安全的判断放左边,把昂贵/可能出错的放右边。


扩展二:优先级与括号

当 &&、||、! 混用时,Rust 按固定优先级计算(高到低):

!   >   &&   >   ||

也就是:非 > 与 > 或。所以

!a && b || c

等价于:

((!a) && b) || c

虽然语言有优先级规则,但在复杂表达式里主动加括号是强烈推荐的习惯——它让读代码的人不用在脑子里背规则:

if (age >= 18 && is_student) || has_permission {
    // 清晰:成年学生,或有特别许可
}

扩展三:& / | 与 && / || 的区别

Rust 里还有单符号的 & 和 |。它们对 bool 值时行为很接近,但有一个本质区别:

运算符类型是否短路
&& / ||逻辑运算,仅用于 bool✅ 短路
& / |位的按位运算(也可用于 bool)❌ 总是两边都算

对 bool 来说,true & false 和 true && false 结果一样,但 & 会强制计算两边。所以写条件判断时永远用 && / ||;单符号版本是给整数按位运算用的。

顺带一提:! 对整数是按位取反(!0i32 == -1),只有对 bool 才是逻辑非。类型不同,语义不同。


扩展四:和前面几章串起来

逻辑运算符不是孤立的,它把前面学的东西都串起来了:

fn main() {
    let age = 20;
    let is_student = true;
    let has_ticket = false;

    // 组合多个条件 + else if 多路分支
    if age >= 18 && is_student {
        println!("student discount");
    } else if age >= 65 || !has_ticket {
        println!("special handling");
    } else {
        println!("standard");
    }
}

这里同时用到了:

  • && / || / ! 组合条件(本章);
  • else if 多路分支(第四篇);
  • 条件必须是 bool(第一篇)——逻辑运算符的结果天然是 bool,正好满足 if 的要求。

常见坑小结

坑说明正确做法
把 & / | 当 && / || 用不短路,可能 panic布尔条件一律用双符号
依赖右边一定执行短路会让右边的副作用丢失别在条件里塞副作用
复杂表达式不加括号优先级易读错主动加括号明确意图
把 ! 用在整数上变成按位取反,结果意外逻辑非只作用于 bool
条件写得过于冗长可读性差抽成布尔变量或函数

一个提升可读性的小技巧——把复杂条件命名化:

let is_eligible = age >= 18 && is_student && !has_violation;
if is_eligible {
    println!("eligible");
}

小结

回到本章目标:用 &&、||、! 组合多个条件。

这一节我们掌握了:

  • &&(and):两边都为 true 才为 true;
  • ||(or):一边为 true 就为 true;
  • !(not):反转布尔值;
  • 短路求值:&& 左假即停、|| 左真即停,可用来保护右边可能出错的表达式;
  • 优先级 ! > && > ||,复杂表达式主动加括号;
  • 布尔条件用 && / ||,别误用按位的 & / |;
  • 把复杂条件抽成变量,让判断更清晰。

至此,条件判断这块拼图彻底完整了:if → scope → else → else if → 逻辑运算符。你已经能表达相当复杂的业务规则了。下一步通常是循环(loop / while / for)或 match,我们下篇继续。Happy coding with Rust! 🦀


参考资料: