Rust 比较运算符:不只是 `==` 和 `<`,那些新手必踩的坑

4 阅读8分钟

如果说算术运算让程序学会"计算",那么比较运算让程序学会"判断"。它是所有分支、循环、排序、查找的地基——而它的返回值,只有两种:true 或 false。这个类型在 Rust 里叫 bool。

今天我们从一个最朴素的问题开始:5 和 5 相等吗?

fn main() {
    println!("{}", 5 == 5);
}

输出是 true。看起来简单,但 Rust 的比较运算符里藏着几个连老手都会愣一下的细节。我们从头讲起。


一、六个运算符,一次记全

Rust 的比较运算符一共六个,和大多数语言一致:

运算符含义示例结果
==等于5 == 5true
!=不等于5 != 3true
<小于3 < 5true
>大于10 > 7true
<=小于或等于5 <= 5true
>=大于或等于8 >= 10false

逐个跑一遍:

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。

比较运算看着简单,但正是这些"不起眼的细节",决定了你的代码是稳稳当当,还是在某个边界上悄悄出错。把这几个坑记牢,后面写分支、排序、查找都会顺很多。


参考来源