Rust语言从入门到精通系列 - 如何判断对象是否相等？ - TinyZ's Blog

TinyZ

找不到相关结果。

主题色相

250

壁纸设置

文章布局

981 字

5 分钟

Rust语言从入门到精通系列 - 如何判断对象是否相等？

2023-04-03

Rust

/

从入门到精通

/

Eq

/

PartialEq

在 Rust 语言中，PartialEq 和 Eq 是两个非常重要的 trait。它们用于比较类型的值，PartialEq 用于比较部分相等（不需要完全相等），而 Eq 用于比较完全相等。

在 Rust 中，任何类型都可以实现 PartialEq 和 Eq，因此这两个 trait 非常灵活。

基础用法#

比较整数#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

比较字符串#

1
fn main() {
2
    let a = "hello";
3
    let b = "world";
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

比较自定义类型#

1
#[derive(PartialEq, Eq)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
fn main() {
8
    let p1 = Person {
9
        name: "Alice".to_string(),
10
        age: 30,
11
    };
12
    let p2 = Person {
13
        name: "Bob".to_string(),
14
        age: 30,
15
    };
16
    if p1 == p2 {
17
        println!("p1 equals p2");
18
    } else {
19
        println!("p1 does not equal p2");
20
    }
21
}

输出：

1
p1 does not equal p2

比较浮点数#

1
fn main() {
2
    let a = 0.1 + 0.2;
3
    let b = 0.3;
4
    if a == b {
5
        println!("a equals b");
6
    } else {
7
        println!("a does not equal b");
8
    }
9
}

输出：

1
a does not equal b

自定义比较函数#

1
struct Person {
2
    name: String,
3
    age: u8,
4
}
5

6
impl PartialEq for Person {
7
    fn eq(&self, other: &Self) -> bool {
8
        self.age == other.age
9
    }
10
}
11

12
impl Eq for Person {}
13

14
fn main() {
15
    let p1 = Person {
16
        name: "Alice".to_string(),
17
        age: 30,
18
    };
19
    let p2 = Person {
20
        name: "Bob".to_string(),
21
        age: 30,
22
    };
23
    if p1 == p2 {
24
        println!("p1 equals p2");
25
    } else {
26
        println!("p1 does not equal p2");
27
    }
28
}

输出：

1
p1 equals p2

比较枚举类型#

1
#[derive(PartialEq, Eq)]
2
enum Color {
3
    Red,
4
    Blue,
5
}
6

7
fn main() {
8
    let c1 = Color::Red;
9
    let c2 = Color::Blue;
10
    if c1 == c2 {
11
        println!("c1 equals c2");
12
    } else {
13
        println!("c1 does not equal c2");
14
    }
15
}

输出：

1
c1 does not equal c2

使用 assert_eq!宏#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    assert_eq!(a, b);
5
}

输出：

1
thread 'main' panicked at 'assertion failed: `(left == right)`
2
  left: `10`,
3
 right: `20`', src/main.rs:4:5
4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

使用 assert_ne!宏#

1
fn main() {
2
    let a = 10;
3
    let b = 20;
4
    assert_ne!(a, b);
5
}

输出：

1
thread 'main' panicked at 'assertion failed: `(left != right)`
2
  left: `10`,
3
 right: `10`', src/main.rs:4:5
4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

进阶用法#

自定义比较函数#

1
struct Person {
2
    name: String,
3
    age: u8,
4
}
5

6
impl PartialEq for Person {
7
    fn eq(&self, other: &Self) -> bool {
8
        self.age == other.age
9
    }
10
}
11

12
impl Eq for Person {}
13

14
fn main() {
15
    let p1 = Person {
16
        name: "Alice".to_string(),
17
        age: 30,
18
    };
19
    let p2 = Person {
20
        name: "Bob".to_string(),
21
        age: 40,
22
    };
23
    if p1 == p2 {
24
        println!("p1 equals p2");
25
    } else {
26
        println!("p1 does not equal p2");
27
    }
28
}

输出：

1
p1 does not equal p2

使用泛型#

1
#[derive(PartialEq, Eq)]
2
struct Pair<T> {
3
    first: T,
4
    second: T,
5
}
6

7
fn main() {
8
    let p1 = Pair {
9
        first: 1,
10
        second: 2,
11
    };
12
    let p2 = Pair {
13
        first: 2,
14
        second: 1,
15
    };
16
    if p1 == p2 {
17
        println!("p1 equals p2");
18
    } else {
19
        println!("p1 does not equal p2");
20
    }
21
}

输出：

1
p1 does not equal p2

使用 PartialOrd 和 Ord#

1
#[derive(PartialEq, Eq, PartialOrd, Ord)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
fn main() {
8
    let p1 = Person {
9
        name: "Alice".to_string(),
10
        age: 30,
11
    };
12
    let p2 = Person {
13
        name: "Bob".to_string(),
14
        age: 40,
15
    };
16
    if p1 < p2 {
17
        println!("p1 is younger than p2");
18
    } else {
19
        println!("p1 is older than or equal to p2");
20
    }
21
}

输出：

1
p1 is younger than p2

使用 Debug 和 Display#

1
#[derive(Debug, PartialEq, Eq)]
2
struct Person {
3
    name: String,
4
    age: u8,
5
}
6

7
use std::fmt;
8

9
impl fmt::Display for Person {
10
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
11
        write!(f, "{} ({})", self.name, self.age)
12
    }
13
}
14

15
fn main() {
16
    let p1 = Person {
17
        name: "Alice".to_string(),
18
        age: 30,
19
    };
20
    let p2 = Person {
21
        name: "Bob".to_string(),
22
        age: 40,
23
    };
24
    println!("p1: {}", p1);
25
    println!("p2: {}", p2);
26
}

输出：

1
p1: Alice (30)
2
p2: Bob (40)

最佳实践#

在实现 PartialEq 和 Eq 时，应该考虑以下几点：

对于自定义类型，应该比较所有的成员变量，而不仅仅是一部分。
对于浮点数，应该使用近似比较而不是精确比较。
对于枚举类型，应该比较所有的成员变量，而不仅仅是枚举值本身。
如果需要比较的类型实现了 PartialOrd 和 Ord，应该优先使用这两个 trait。

结论#

在 Rust 语言中，PartialEq 和 Eq 是非常重要的 trait，用于比较类型的值。这两个 trait 非常灵活，任何类型都可以实现它们。在实现 PartialEq 和 Eq 时，应该考虑到类型的特点，比较所有的成员变量，使用近似比较等。

支持与分享

如果这篇文章对你有帮助，欢迎分享给更多人或赞助支持！

Rust语言从入门到精通系列 - 如何判断对象是否相等？

https://tinyzzh.github.io/posts/2023-04-03-rust_lang_tutorial_125_trait_eq_partialeq/

作者

TinyZ Zzh

发布于

2023-04-03

许可协议

CC BY-NC-SA 4.0

Rust语言从入门到精通系列 - 不可变引用智能指针RefCell特征

Rust语言从入门到精通系列 - Default特征

相关文章智能推荐

Rust语言从入门到精通系列 - 生命周期

Rust 2023-03-17

Rust语言从入门到精通系列 - 格式化输出

Rust 2023-03-14

Rust语言从入门到精通系列 - 日志库

Rust 2023-03-14

Rust语言从入门到精通系列 - Rust泛型

Rust 2023-03-13

Rust语言从入门到精通系列 - Hello World!

Rust 2023-03-12

随机文章随机推荐

评论区

分享你的想法，与大家交流讨论

文章目录