如果说算术运算让程序学会"计算",那么比较运算让程序学会"判断"。它是所有分支、循环、排序、查找的地基——而它的返回值,只有两种:true 或 false。这个类型在 Rust 里叫 bool。
今天我们从一个最朴素的问题开始:5 和 5 相等吗?
fn main() {
println!("{}", 5 == 5);
}
输出是 true。看起来简单,但 Rust 的比较运算符里藏着几个连老手都会愣一下的细节。我们从头讲起。
一、六个运算符,一次记全
Rust 的比较运算符一共六个,和大多数语言一致:
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
== | 等于 | 5 == 5 | true |
!= | 不等于 | 5 != 3 | true |
< | 小于 | 3 < 5 | true |
> | 大于 | 10 > 7 | true |
<= | 小于或等于 | 5 <= 5 | true |
>= | 大于或等于 | 8 >= 10 | false |
逐个跑一遍:
fn main() {
println!("{}", 5 == 5); // true
println!("{}", 5 != 3); // true
println!("{}", 3 < 5); // true
println!("{}", 10 > 7); // true
println!("{}", 5 <= 5); // true,相等也算成立
println!("{}", 8 >= 10); // false
}
注意 <= 和 >= 的语义——"小于或等于",所以 5 <= 5 是成立的;而 8 >= 10 两个条件都不满足,结果是 false。
比较的结果还能参与逻辑运算,这是它真正的用武之地:
fn main() {
let score = 85;
let passed = score >= 60 && score <= 100; // 判断分数是否在合法区间
println!("{}", passed); // true
}
二、第一个坑:= 不是 ==
这是几乎所有新手的第一道坎:
let x = 5; // 一个等号 = :赋值,把 5 放进变量 x
println!("{}", x == 5); // 两个等号 == :比较,问 x 是不是等于 5
记不住的话,可以这么想:= 是"动作"(把右边塞给左边),== 是"提问"(两边是否相等)。
值得一提的是,在很多语言里(比如 C / JavaScript),把 == 误写成 = 有时能"合法地"编译通过,埋下难查的 bug。而 Rust 在设计上挡住了这类错误——在需要 bool 的地方写赋值表达式,编译器会直接报错。这是 Rust "编译期尽量拦住错误"哲学的一个缩影。
三、第二个坑:Rust 不支持链式比较
如果你从 Python 过来,一定会想写这种代码:
let x = 5;
println!("{}", 1 < x < 10); // 想表达 "x 在 1 和 10 之间"
这在 Rust 里编译不过。实际报错是:
error: comparison operators cannot be chained
--> src/main.rs:1:40
|
1 | println!("{}", 1 < x < 10);
| ^ ^
|
help: split the comparison into two
|
1 | println!("{}", 1 < x && x < 10);
| ++++
原因很直接:1 < x 先算出 bool,程序就变成了拿 bool 去和 10 比较——类型对不上。Rust 的选择是干脆禁止链式比较,而不是像 Python 那样引入特殊语义。正确写法是用 && 把两次比较连起来:
println!("{}", 1 < x && x < 10); // true
四、第三个坑:类型不同,不能比较
Rust 没有隐式类型转换,两个不同类型的值不能直接比较:
fn main() {
let a: i32 = 5;
let b: i64 = 5;
println!("{}", a == b); // 编译错误
}
编译器报错 mismatched types,并贴心地给出修改建议:
error[E0308]: mismatched types
|
1 | println!("{}", a == b);
| ^ expected `i32`, found `i64`
|
help: you can convert `a` from `i32` to `i64`
|
1 | println!("{}", i64::from(a) == b);
必须显式转换到同一类型:
println!("{}", i64::from(a) == b); // true
这条规则看似繁琐,实则防止了一大类隐蔽 bug——你不会再因为无意识的整数精度提升而得到错误结果。
五、第四个坑:NaN 不等于它自己
这是比较运算里最反直觉的一条,而且不止 Rust,所有遵循 IEEE 754 浮点标准的语言都是如此:
fn main() {
let nan = f64::NAN;
println!("{}", nan == nan); // false !
println!("{}", nan != nan); // true !
println!("{}", nan < 0.0); // false
}
NaN(Not a Number)表示"无效的计算结果",语义上它不是任何一个确定的值,所以它和自己也不相等,和任何数比较大小也都是 false。这在写浮点判断时是个真实的陷阱:如果你用一个浮点数是否 == 某个值来判断,而它可能是 NaN,判断就会悄悄失效。
Rust 提供了两个应对工具:
f64::is_nan():显式检测是不是NaN;total_cmp():提供全序比较,把NaN排到所有正常浮点数之上(实测f64::NAN.total_cmp(&1.0).is_gt()为true),适合需要给浮点数排序的场景。
if value.is_nan() {
// 单独处理无效值,而不是拿它去比较
}
六、底层原理:比较其实是在调用 trait
前面我们用得很顺手,但 Rust 是怎么知道 5 == 5 该比什么、"a" < "b" 又该比什么的?答案是 trait(可以粗略理解为"能力接口")。
| 运算符 | 背后的 trait | 含义 |
|---|---|---|
== / != | PartialEq | 部分相等:允许"两边不可比"的情况存在 |
< / > / <= / >= | PartialOrd | 部分有序:同样允许不可比 |
cmp() | Ord | 全序:任意两个值都能分出高下 |
Partial(部分)这个前缀,正是为 NaN 这类"无法比较"的值留的口子——所以浮点数只实现了 PartialOrd,没有实现 Ord。而整数这类"任何两个值都能比出大小"的类型,才同时实现 Ord。
自定义类型想支持比较,只需派生对应 trait:
#[derive(Debug, PartialEq, PartialOrd)]
struct Version(u32, u32);
fn main() {
let v1 = Version(1, 9);
let v2 = Version(1, 10);
println!("{}", v1 < v2); // true
}
派生 PartialOrd 后,Rust 会按字段声明顺序逐个比较——这里先比主版本号,相等再比次版本号。于是 1.9 < 1.10 得到正确的 true(如果用字符串字典序比,结果可就反了)。如果还需要排序、二分查找,再加 Eq 和 Ord 即可(要求所有字段都满足相应约束)。
动手实现 Eq:两种写法
上面留了个尾巴——Eq 到底怎么写?先看它的定义,其实简单到有点意外:
pub trait Eq: PartialEq {} // 标准库里的真实形态:一个没有任何方法的标记 trait
Eq 是标记 trait(marker trait),没有方法需要你实现。它的作用只是向编译器声明:"这个类型的相等关系是自反、对称、传递的,任何两个值都能明确比较。"代价是:想实现 Eq,必须先实现 PartialEq。
写法一:derive(推荐) —— 字段都满足时,让编译器自动生成:
use std::collections::{BTreeSet, HashMap};
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct UserId(u64);
fn main() {
let u1 = UserId(7);
let u2 = UserId(7);
println!("{}", u1 == u2); // true
// Eq + Hash 才能当 HashMap 的 key:u1、u2 相等,所以是同一个 key
let mut scores = HashMap::new();
scores.insert(u1.clone(), 100);
scores.insert(u2, 90);
println!("{:?}", scores.get(&u1)); // Some(90)
// Eq + Ord 才能进 BTreeSet,并自动有序
let mut ids = BTreeSet::new();
ids.insert(UserId(3));
ids.insert(UserId(1));
ids.insert(UserId(2));
println!("{:?}", ids); // {UserId(1), UserId(2), UserId(3)}
}
这正是 Eq 的实用价值:它是 HashMap、HashSet、BTreeSet 等容器正确工作的前提——容器要靠"相等"来判断 key 是否重复。
写法二:手写 PartialEq + 空实现 Eq —— 当比较逻辑需要定制时:
#[derive(Debug)]
struct Money {
cents: i64,
currency: &'static str,
}
impl PartialEq for Money {
fn eq(&self, other: &Self) -> bool {
// 金额相等还不够,币种也必须相同
self.cents == other.cents && self.currency == other.currency
}
}
impl Eq for Money {} // 声明"上面的相等关系是全序的",空实现即可
fn main() {
let cny1 = Money { cents: 100, currency: "CNY" };
let cny2 = Money { cents: 100, currency: "CNY" };
let usd = Money { cents: 100, currency: "USD" };
println!("{}", cny1 == cny2); // true
println!("{}", cny1 == usd); // false,币种不同
}
为什么浮点数是反例? 因为 NaN != NaN 破坏了自反性(任何值都必须等于自己),而 Eq 要求自反——所以 f64 只实现 PartialEq,不能实现 Eq。试着给含 f64 的结构体 derive(Eq) 会直接编译失败。这也解释了这两个 trait 名字里"Partial(部分)"的由来:它诚实地承认"有些值之间的相等关系是 undefined 的"。
以上两个示例均在
rustc 1.100.0下编译运行通过,输出与注释一致。
七、cmp 与 Ordering:一次比较拿到三种结果
==、< 这些运算符给你的是 bool,只能回答"是/否"。而 cmp() 一次就能告诉你"小于、等于还是大于",返回值是 std::cmp::Ordering 枚举:
use std::cmp::Ordering;
fn main() {
println!("{}", 3.cmp(&5) == Ordering::Less); // true
println!("{}", 5.cmp(&5) == Ordering::Equal); // true
}
Ordering 有三个变体:Less、Equal、Greater。排序、优先队列等场景用的都是它——因为一次比较就拿到完整信息,比连续调用多个运算符更高效、也更不易出错。
顺带一提,字符串的比较是按字节的字典序进行的:
println!("{}", "a" < "b"); // true
println!("{}", "apple" < "banana"); // true
println!("{}", "Rust" == "rust"); // false,大小写敏感
总结
一张表收尾:
- 六个运算符:
==!=<><=>=,结果都是bool。 =赋值,==比较,别混。- 不能链式比较:用
&&代替1 < x < 10。 - 类型必须一致:不一致就显式转换。
- NaN 不等于自己:用
is_nan()/total_cmp()处理。 - 底层是 trait:
PartialEq/Eq、PartialOrd/Ord;自定义类型可derive。 - 要三态结果就用
cmp()+Ordering。
比较运算看着简单,但正是这些"不起眼的细节",决定了你的代码是稳稳当当,还是在某个边界上悄悄出错。把这几个坑记牢,后面写分支、排序、查找都会顺很多。
参考来源
- Learning Rust from Zero — Comparison Operators