一起来聊一聊 PartialEq 与 Eq

在开发过程中。我们总会遇到“判断两个对象是否相等”的场景，比如比较两个变量的值、在集合中查找目标元素、去重等。与其他编程语言不同，默认就支持对象的相等判断。Rust 需要用到 PartialEq 与 Eq 这两个特征来判断是否相等。为什么 Rust 要搞这么复杂？今天我们一起来聊一聊，Rust 判断对象相等的根本原因。还有这两个主要特征的使用方法，帮你一次性搞懂。

为什么 Rust 不默认实现“对象相等”？

为什么其他语言能默认实现相等判断，Rust 却不行？答案很简单，那就是：“相等”的语义。从来都不是固定的。

如果 Rust 像其他语言那样。默认实现“所有字段都相等才算对象相等”，那在只需要比较部分字段的场景里我们就得额外写代码覆盖默认逻辑，反而更麻烦。说起来，Rust 选择了更严谨的方式：不提供默认的相等判断。而是通过 PartialEq 和 Eq 两个特征，让我们根据自己的业务场景自定义“相等”的规则。按理说，

PartialEq 与 Eq 有什么区别？

这两个特征是 Rust 判断对象相等的主要。二者是“继承关系”，但语义上有明显区别。我们一个个来聊，先从最常用的 PartialEq 开始。

PartialEq：“部分相等”，最常用的相等判断

PartialEq 翻译过来是“部分相等”。它的作用很简单：定义两个对象“在某种程度上”是否相等，支持我们使用 == 和 != 这两个运算符比较一下。

pub trait PartialEq {
// 判断 self 和 or 是否相等
fn eq -> bool;// 判断是否不相等，默认是 eq 方法取反
fn ne -> bool {
self.eq
}
}

从定义能看出来只要我们实现了 eq 方法。就可以直接用 ==来比较对象了。

痛点1：很多新手误以为实现了 equals/`cmp`** 就能直接使用 `==`，实际只有实现了 `PartialEq` 才会让编译器把 `==` “解包”为 `eq` 调用。

那为什么叫“部分相等”呢？主要是它不要求满足“自反性”. 简单说就是存在某个值 a,使得 a == a` 的结果是 ``。

典型案例——浮点数 NaN：

fn main {
let nan = f32::NAN;println，;// 输出：false
}

正因为浮点数存在这种“自己不等于自己”的情况。所以 Rust 只为浮点数默认实现了 PartialEq,而没有实现 E q 。这也正是 “ 部分 相 等 ” 的主要含义：不是所有值都能和自己相 等。

Eq ： “ 完 全 相 等 ”。更 强 的 契约约束

在 讲 完 了 Partial Eq 后,再 看 Eq。它 翻译过 来 是 “ 完全 相 等 ”,是 在 Partial Eq 的 基础 上,增 加 了 更 强 的 契约约束 . 它 的 定义 更 简 单,甚至 没有 附加 方法,只是 继 承 了 Partial Eq :

 pub trait Eq: PartialEq { // 没有额外方法。仅仅是一个 “契约标记” }

虽然没有额外方法，但 Eq 有 三 个 必须 满足 的 契约:

• 自反性 : 对于 任意 值 a,a == a 必须 恒 为 true;
• 对称性 : 如果 a == b,那么 b == a 也必须 为 true;
• 传递性 : 如果 a == b 且 b == c,那么 a == c 也必须 为 true .

哪些 类型 实现了 Eq?我们 平时 使用 的 基础 类型，比如 i32 、 bool 、 String 、 Vec 等，都 实现了 Eq,因为 它们 均 满足 上 面 的 三 个 契约 . 而 浮点 数 因 为 存 在 NaN,无法 满 足 自反 性，所以 不 能 实现 Eq .

给 自 定义 类型 实现 相 等 判断

自动 派 生

如果 自 定义 类型 中，所有 字段 都 实现了 Partial Eq 或 Eq。那 我们 根本 不 用 手动 写代码,只需要 在 类型 定义 前 添加 上 派生 宏,Rust 就 会 自动 帮 我们 实现 相 等 判断 逻辑 . 这种 方 式适 合 大 多数 场 景,简 单 又 不 容易 出 错 .

 // 自动派生 PartialEq 和 Eq
#
struct Point {
x: i32,y: i32,}
fn main {
let p1 = Point { x: 1,y: 2 };let p2 = Point { x: 1,y: 2 };let p3 = Point { x: 2,y: 3 };怎么说呢，println!，// 输出：true
println!，// 输出：false
}

手 动 实现

如果 自动 派 生 的 逻辑 不 符 合 我们 的需求,那 就 必 须 手 动 实现 Partial_eq,自己 定义 eq 方法 的 判定 logic .

示例 : 当 圆形 半径 相 同 即 被视 为 相 同 圆形 .

 #
struct Circle {
radius这方面。f64,x: f64,y: f64,}
// 手动实现 PartialEq
impl PartialEq for Circle {
fn eq -> bool {
// 只比较半径，忽略圆心坐标
self.radius == or.radius
}
}
fn main {
let c1 = Circle { radius: 5.0,x:0.0,y:0.0 };let c2 = Circle { radius:5.0。x:10.0,y:-10.0 };println，;
// 输出：true
}

容 易 混淆 的 点 ： 值 相 等 vs 引 用 相 等

聊 完了 Partial_eq 和 Eq,还有 一个 新 手 很 容易 踩 坑 的 点 : Rust 中 的 “ 值 相 等 ” 和 “ 引 用 相 等 ” 到底 不 一 样?老实说，简 单 来说 :

• 值 相 等 : 通过 Partial_eq / Eq 判断。比 较的是 两 个 对象 内容 是否 相 等;
• 引 用 相 等 : 判断 两 个 引 用 是否 指 向 同 一个 内存 地址，和 内容 无关 .

我们 平时 用 ``==`` 比 较 的 都 是 值 相 等;要 判断 引 用 相 等 则 使用 ``std::ptr::eq`` 函数 . 示例 :

 use std::ptr;fn main {
let a = 5;let b =5，let ref_a =&a;// 指向 a 的引用
let ref_b =&b;// 指向 b 的引用
let ref_a2 =&a;//
指向 a
// 值相等：ref_a 和 ref_b 指向的内容都是5，所以认为值相等
println!，// true
// 引用相等：ref_a 指向 a。ref_b 指向 b，内存地址不同
println!: {}",ptr::eq);// false
// ref_a 与 ref_a2 指向同一个地址
println!: {}",ptr::eq);话说回来，// true
}

: 很多人误把 ``==`` 当作指针比较。一旦涉及智能指针 就会产生 subtle bug。记住这方面，值比较走 ``Partial_eq/Eq``；指针比较走 ``ptr::eq`` 或对应智能指针专属 API。

智 能指针专属 API 示例   

 use std::sync::Arc;fn main {
let a = Arc::new;let b = Arc::clone;let c = Arc::new;assert，);// true，同一块堆内存
assert!)，// false，不同分配
}

避坑教程

痛点一 ： 用 ``Partial_eq`` 替代 ``Eq`` 随便用    

虽然 ``Partial_eq`` 更通用。但有些场景必须使用 ``E q``，最典型的就是 ``HashMap` 中键类型 K 必须实现 ``E q``。如果键类型不满足自反性，会导致查找、删除出现异常。至于示例，

 use std::collections::HashMap;老实说，fn main {
let mut map: HashMap=HashMap::new;map.insert，// 编译错误：f32 未实现 E q
}

痛点二 ： 手动实现 ``Partial_eq`` 时违背契约    

手动实现时一定要遵守对称性、传递性，否则逻辑错误难以被编译器捕获。例如只为 A 实现 B 的比较，而未为 B 实现 A：

 # struct A;# struct B，impl PartialEq for A {
fn eq -> bool {
self.0 == or.0 + 1
}
}
fn main {
let a=A;let b=B，println!，// true
// b==a 编译错误，因为没有对应 impl
}

痛点三 ： 派生 E q 时忽略字段的 E q 实现    ​​​​​​​​​​​​​​​​​​​​​​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​ ​​​​​​​​​​

​​‏‏‏‏‏‏‏‏‏‏‏‎ ‎ ‎ ‎ ‎ ‎‎‎‎

rust // 编译报错：f64 未实现 E q。无⎔⎔⎔⎔⎔⎔⎔⎔⎔⎔ ⓘ ⓘ ⓘ ⓘ ⓘ ⓘ ⓘ

struct Circle{ radius:f64,x:i32,y:i32 }

解决办法要想派生 E q，需要确保所有成员也都满足 E q；怎么说呢，否则只能只派生 Part ial_eq 并自行决定是否提供自定义 E q。

🎯️️️️️️️️️️‍♂️‍♀️‍⚖‍🧠🚀💡✍🏻💪🏻💥🌟⚙🧩📚🧭⚖︎︎︎︎︎︎︎︎︎︎︎︎︎︎︎۞۞۞۞۞۞۝۝۝۝۝☂☂☂☁🌈🗒🐱‍👤🐱‍💻🐱‍🏍🐱‍👽🐱‍🚀🐱‍🔧🦾🤖📈📊📉📁🎉🥳💭✏️✅❌🙅🚫❗🙈🙉🙊🔧⚙🔨🔩🔗⚡✨💫⭐🌟🔥🌪🌈🏁🏆🥇🥈🥉🎖⚜🚩🕰⌛⌚⚡💡👇▶◀➤➡⬅↗↙↖↘⇧⇩⬆⬇➕➖✖÷∗✳✴❣❤♥♦♣♠★☆☀☁☂❄☃⚪⚫▲▼◆◀▶■□▢▣▤▥▦▧▨▩▪▫●○◎⊕⊗⊙⊚⊛⊜⊝⊞⊟※‽⁂⁇⁈⁉⁋←↑→↓↔↕↖↗↘↙⇐⇑⇒⇓⇐⇒←→↑↓—―‑‑‒–—‐‑…···⋅•·˙¨´‘’”“„‹›«»‹›«»«‹»″′″′〝〟⌜⌝﹁﹂﹃﹄＂＇‘ ’『』〔〕｛｝〈〉《》「」〚〛〖〗＜＞≪≫∽≈≡≅≢∥∦∧∨¬∠∴∞∑√∫≈≈≈≈≈≈≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≈ ≤≥≤≥≤≥≤ ≥ ≤ ≥ ≤ ≥ ≤≥≤≥≤≥≤ ≥ ≤>= <= != === !== ??.?.?.?.... ... ... ... ... ... ………….….. …………………………….. ……………………………….

---

掌握好 `P artialEQ     ` 与 `E Q   ` 两把钥匙。你就可以轻松驾驭 Rust 中任何「比 对」需求，从集合去重到缓存键设计，都不再手忙脚乱！祝编码愉快 🚀.

---