Rust语言从入门到精通系列 - 深入理解From和Into特征

Rust 是一种系统编程语言，其设计目标是提供安全性、速度和并发性。Rust 的安全性特别强，这是因为它在编译时就会检查代码中的内存安全问题。Rust 还具有良好的性能和并发性，这使得它成为了开发高性能、可靠和安全的系统级应用的首选语言。

Rust 中的 From 和 Into 是两个重要的 trait，它们可以帮助我们进行类型转换。From trait 允许我们从一个类型转换到另一个类型，而 Into trait 则允许我们将一个类型转换为另一个类型。这两个 trait 的实现可以帮助我们更好地处理类型转换的问题。

本教程将介绍 Rust 中的 From 和 Into trait 的基础使用方法和进阶用法。

基础用法#

从字符串转换为数字#

我们可以使用 From trait 将一个字符串转换为数字类型。例如，我们将字符串”123”转换为 i32 类型。

1
let num: i32 = "123".parse::<i32>().unwrap();

从数字转换为字符串#

我们可以使用 Into trait 将一个数字类型转换为字符串。例如，我们将数字 123 转换为字符串类型。

1
let num: i32 = 123;
2
let str: String = String::from(num.to_string());

从一个类型转换为另一个类型#

我们可以使用 From trait 将一个类型转换为另一个类型。例如，我们将一个 i32 类型的变量转换为一个 u32 类型的变量。

1
let num: i32 = 123;
2
let new_num: u32 = num.try_into().unwrap();

从一个类型转换为另一个类型#

我们可以使用 Into trait 将一个类型转换为另一个类型。例如，我们将一个 i32 类型的变量转换为一个 u32 类型的变量。

1
let num: i32 = 123;
2
let new_num: u32 = num.try_into().unwrap();

从一个 Option 类型转换为另一个 Option 类型#

我们可以使用 From trait 将一个 Option 类型转换为另一个 Option 类型。例如，我们将一个 Option类型的变量转换为一个 Option类型的变量。

1
let num: Option<i32> = Some(123);
2
let new_num: Option<u32> = num.map(|n| n as u32);

从一个 Vec 类型转换为另一个 Vec 类型#

我们可以使用 From trait 将一个 Vec 类型转换为另一个 Vec 类型。例如，我们将一个 Vec类型的变量转换为一个 Vec类型的变量。

1
let vec: Vec<i32> = vec![1, 2, 3];
2
let new_vec: Vec<u32> = vec.into_iter().map(|x| x as u32).collect::<Vec<u32>>();

从一个数组类型转换为另一个数组类型#

我们可以使用 From trait 将一个数组类型转换为另一个数组类型。例如，我们将一个[i32; 3]类型的数组转换为一个[u32; 3]类型的数组。

1
let arr: [i32; 3] = [1, 2, 3];
2
let new_arr: [u32; 3] = arr.map(|x| x as u32);

从一个枚举类型转换为另一个枚举类型#

我们可以使用 From trait 将一个枚举类型转换为另一个枚举类型。例如，我们将一个 Option类型的枚举转换为一个 Option类型的枚举。

1
enum OptionInt {
2
    Some(i32),
3
    None,
4
}
5

6
enum OptionUint {
7
    Some(u32),
8
    None,
9
}
10

11
impl From<OptionInt> for OptionUint {
12
    fn from(option_int: OptionInt) -> OptionUint {
13
        match option_int {
14
            OptionInt::Some(n) => OptionUint::Some(n as u32),
15
            OptionInt::None => OptionUint::None,
16
        }
17
    }
18
}
19

20
let option_int = OptionInt::Some(123);
21
let option_uint: OptionUint = OptionUint::from(option_int);

进阶用法#

为自定义类型实现 From trait#

我们可以为自定义类型实现 From trait，以便将自定义类型转换为其他类型。例如，我们为自定义类型 MyInt 实现 From trait，以便将它转换为 i32 类型。

1
struct MyInt(i32);
2

3
impl From<MyInt> for i32 {
4
    fn from(my_int: MyInt) -> i32 {
5
        my_int.0
6
    }
7
}
8

9
let my_int = MyInt(123);
10
let num: i32 = my_int.into();

为自定义类型实现 Into trait#

我们可以为自定义类型实现 Into trait，以便将其他类型转换为自定义类型。例如，我们为自定义类型 MyInt 实现 Into trait，以便将 i32 类型转换为它。

1
struct MyInt(i32);
2

3
impl Into<MyInt> for i32 {
4
    fn into(self) -> MyInt {
5
        MyInt(self)
6
    }
7
}
8

9
let num: i32 = 123;
10
let my_int: MyInt = num.into();

使用泛型实现 From trait#

我们可以使用泛型实现 From trait，以便将任意类型转换为另一个类型。例如，我们使用泛型实现 From trait，以便将任意类型转换为字符串类型。

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> From<MyStruct<T>> for String {
4
    fn from(my_struct: MyStruct<T>) -> String {
5
        format!("{}", my_struct.0)
6
    }
7
}
8

9
let my_struct = MyStruct(123);
10
let str: String = my_struct.into();

使用泛型实现 Into trait#

我们可以使用泛型实现 Into trait，以便将任意类型转换为另一个类型。例如，我们使用泛型实现 Into trait，以便将任意类型转换为字符串类型。

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> Into<String> for MyStruct<T> {
4
    fn into(self) -> String {
5
        format!("{}", self.0)
6
    }
7
}
8

9
let my_struct = MyStruct(123);
10
let str: String = my_struct.into();

最佳实践#

在 Rust 中，From 和 Into trait 是非常有用的，它们可以帮助我们进行类型转换。在实现 From 和 Into trait 时，我们需要注意以下几点：

实现 From 和 Into trait 时，需要考虑类型转换的安全性和正确性。
实现 From 和 Into trait 时，需要考虑性能问题，避免不必要的类型转换。
在实现 From 和 Into trait 时，需要遵循 Rust 的惯例和规范，以便代码更易于理解和维护。

下面是一些最佳实践示例代码：

为自定义类型实现 From 和 Into trait#

1
struct MyInt(i32);
2

3
impl From<MyInt> for i32 {
4
    fn from(my_int: MyInt) -> i32 {
5
        my_int.0
6
    }
7
}
8

9
impl Into<MyInt> for i32 {
10
    fn into(self) -> MyInt {
11
        MyInt(self)
12
    }
13
}

使用泛型实现 From 和 Into trait#

1
struct MyStruct<T>(T);
2

3
impl<T: std::fmt::Display> From<MyStruct<T>> for String {
4
    fn from(my_struct: MyStruct<T>) -> String {
5
        format!("{}", my_struct.0)
6
    }
7
}
8

9
impl<T: std::fmt::Display> Into<String> for MyStruct<T> {
10
    fn into(self) -> String {
11
        format!("{}", self.0)
12
    }
13
}

使用 From 和 Into trait 进行类型转换#

1
let my_int = MyInt(123);
2
let num: i32 = my_int.into();
3

4
let my_struct = MyStruct(123);
5
let str: String = my_struct.into();

总结#

在本教程中，我们介绍了 Rust 中的 From 和 Into trait 的基础使用方法和进阶用法。From trait 允许我们从一个类型转换到另一个类型，而 Into trait 则允许我们将一个类型转换为另一个类型。我们还提供了一些示例代码和最佳实践，以帮助您更好地理解和应用 From 和 Into trait。

音乐

音乐

基础用法#

从字符串转换为数字#

从数字转换为字符串#

从一个类型转换为另一个类型#

从一个类型转换为另一个类型#

从一个 Option 类型转换为另一个 Option 类型#

从一个 Vec 类型转换为另一个 Vec 类型#

从一个数组类型转换为另一个数组类型#

从一个枚举类型转换为另一个枚举类型#

进阶用法#

为自定义类型实现 From trait#

为自定义类型实现 Into trait#

使用泛型实现 From trait#

使用泛型实现 Into trait#

最佳实践#

为自定义类型实现 From 和 Into trait#

使用泛型实现 From 和 Into trait#

使用 From 和 Into trait 进行类型转换#

总结#

支持与分享

评论区

音乐

文章目录