From d6675774e53485c1b4826629176364370fb3c2cd Mon Sep 17 00:00:00 2001 From: Allan Downey Date: Sat, 29 Jan 2022 22:22:26 +0800 Subject: [PATCH] Update: unified format --- book/contents/basic/trait/advance-trait.md | 20 +++---- book/contents/basic/trait/generic.md | 34 ++++++------ book/contents/basic/trait/intro.md | 2 +- book/contents/basic/trait/trait-object.md | 24 ++++---- book/contents/basic/trait/trait.md | 64 +++++++++++----------- 5 files changed, 72 insertions(+), 72 deletions(-) diff --git a/book/contents/basic/trait/advance-trait.md b/book/contents/basic/trait/advance-trait.md index 9ec67bf2..138b7ed1 100644 --- a/book/contents/basic/trait/advance-trait.md +++ b/book/contents/basic/trait/advance-trait.md @@ -1,6 +1,6 @@ # 深入了解特征 -特征之于Rust更甚于接口之于其他语言，因此特征在Rust中很重要也相对较为复杂，我们决定把特征分为两篇进行介绍，[第一篇](./trait.md)在之前已经讲过，现在就是第二篇：关于特征的进阶篇，会讲述一些不常用到但是你该了解的特性。 +特征之于 Rust 更甚于接口之于其他语言，因此特征在 Rust 中很重要也相对较为复杂，我们决定把特征分为两篇进行介绍，[第一篇](./trait.md)在之前已经讲过，现在就是第二篇：关于特征的进阶篇，会讲述一些不常用到但是你该了解的特性。 ## 关联类型 在方法一章中，我们讲到了[关联函数](../method.md#关联函数)，但是实际上关联类型和关联函数并没有任何交集，虽然它们的名字有一半的交集。 @@ -46,7 +46,7 @@ pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable { } ``` -例如上面的代码， `Address` 的写法自然远比 `AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash` 要简单的多，而且含义清晰。 +例如上面的代码，`Address` 的写法自然远比 `AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash` 要简单的多，而且含义清晰。 再例如，如果使用泛型，你将得到以下的代码： ```rust @@ -108,7 +108,7 @@ fn main() { Point { x: 3, y: 3 }); } ``` -上面的代码主要干了一件事，就是为 `Point` 结构体提供 `+` 的能力，这就是**运算符重载**，不过Rust并不支持创建自定义运算符，你也无法为所有运算符进行重载，目前来说，只有定义在 `std::ops` 中的运算符才能进行重载。 +上面的代码主要干了一件事，就是为 `Point` 结构体提供 `+` 的能力，这就是**运算符重载**，不过 Rust 并不支持创建自定义运算符，你也无法为所有运算符进行重载，目前来说，只有定义在 `std::ops` 中的运算符才能进行重载。 跟 `+` 对应的特征是 `std::ops::Add`，我们在之前也看过它的定义 `trait Add`，但是上面的例子中并没有为 `Point` 实现 `Add` 特征，而是实现了 `Add` 特征（没有默认泛型类型参数），这意味着我们使用了 `RHS` 的默认类型，也就是 `Self`。换句话说，我们这里定义的是两个相同的 `Point` 类型相加，因此无需指定 `RHS`。 @@ -264,16 +264,16 @@ fn main() { println!("A baby dog is called a {}", ::baby_name()); } ``` -在尖括号中，通过 `as` 关键字，我们向Rust编译器提供了类型注解，也就是 `Animal` 就是 `Dog`，而不是其他动物，因此最终会调用 `impl Animal for Dog` 中的方法，获取到其它动物对狗宝宝的称呼：**puppy**。 +在尖括号中，通过 `as` 关键字，我们向 Rust 编译器提供了类型注解，也就是 `Animal` 就是 `Dog`，而不是其他动物，因此最终会调用 `impl Animal for Dog` 中的方法，获取到其它动物对狗宝宝的称呼：**puppy**。 言归正题，完全限定语法定义为： ```rust ::function(receiver_if_method, next_arg, ...); ``` -上面定义中，第一个参数是方法接收器`receiver`(三种`self`)，只有方法才拥有，例如关联函数就没有`receiver`。 +上面定义中，第一个参数是方法接收器 `receiver` （三种 `self`），只有方法才拥有，例如关联函数就没有 `receiver`。 -完全限定语法可以用于任何函数或方法调用，那么我们为何很少用到这个语法？原因是Rust编译器能根据上下文自动推导出调用的路径，因此大多数时候，我们都无需使用完全限定语法。只有当存在多个同名函数或方法，且Rust无法区分出你想调用的目标函数时，该用法才能真正有用武之地。 +完全限定语法可以用于任何函数或方法调用，那么我们为何很少用到这个语法？原因是 Rust 编译器能根据上下文自动推导出调用的路径，因此大多数时候，我们都无需使用完全限定语法。只有当存在多个同名函数或方法，且 Rust 无法区分出你想调用的目标函数时，该用法才能真正有用武之地。 @@ -299,7 +299,7 @@ trait OutlinePrint: Display { 等等，这里有一个眼熟的语法: `OutlinePrint: Display`，感觉很像之前讲过的**特征约束**，只不过用在了特征定义中而不是函数的参数中，是的，在某种意义上来说，这和特征约束非常类似，都用来说明一个特征需要实现另一个特征，这里就是：如果你想要实现 `OutlinePrint` 特征，首先你需要实现 `Display` 特征。 -想象一下，假如没有这个特征约束，那么 `self.to_string` 还能够调用吗( `to_string` 方法会为实现 `Display` 特征的类型自动实现)？编译器肯定是不愿意的，会报错说当前作用域中找不到用于 `&Self` 类型的方法 `to_string` ： +想象一下，假如没有这个特征约束，那么 `self.to_string` 还能够调用吗（ `to_string` 方法会为实现 `Display` 特征的类型自动实现）？编译器肯定是不愿意的，会报错说当前作用域中找不到用于 `&Self` 类型的方法 `to_string` ： ```rust struct Point { x: i32, @@ -378,13 +378,13 @@ fn main() { } ``` -其中， `struct Wrapper(Vec)` 就是一个元组结构体，它定义了一个新类型 `Wrapper`，代码很简单，相信大家也很容易看懂。 +其中，`struct Wrapper(Vec)` 就是一个元组结构体，它定义了一个新类型 `Wrapper`，代码很简单，相信大家也很容易看懂。 -既然`new type`有这么多好处，它有没有不好的地方呢？答案是肯定的。注意到我们怎么访问里面的数组吗？`self.0.join(", ")`，是的，很啰嗦，因为需要先从 `Wrapper` 中取出数组: `self.0`，然后才能执行 `join` 方法。 +既然 `new type` 有这么多好处，它有没有不好的地方呢？答案是肯定的。注意到我们怎么访问里面的数组吗？`self.0.join(", ")`，是的，很啰嗦，因为需要先从 `Wrapper` 中取出数组: `self.0`，然后才能执行 `join` 方法。 类似的，任何数组上的方法，你都无法直接调用，需要先用 `self.0` 取出数组，然后再进行调用。 -当然，解决办法还是有的，要不怎么说Rust是极其强大灵活的编程语言！Rust提供了一个特征叫[ `Deref` ](../../traits/deref.md)，实现该特征后，可以自动做一层类似类型转换的操作，可以将 `Wrapper` 变成 `Vec` 来使用。这样就会像直接使用数组那样去使用 `Wrapper`，而无需为每一个操作都添加上 `self.0`。 +当然，解决办法还是有的，要不怎么说 Rust 是极其强大灵活的编程语言！Rust 提供了一个特征叫 [`Deref`](../../traits/deref.md)，实现该特征后，可以自动做一层类似类型转换的操作，可以将 `Wrapper` 变成 `Vec` 来使用。这样就会像直接使用数组那样去使用 `Wrapper`，而无需为每一个操作都添加上 `self.0`。 同时，如果不想 `Wrapper` 暴漏底层数组的所有方法，我们还可以为 `Wrapper` 去重载这些方法，实现隐藏的目的。 diff --git a/book/contents/basic/trait/generic.md b/book/contents/basic/trait/generic.md index ce1b88b2..402bf426 100644 --- a/book/contents/basic/trait/generic.md +++ b/book/contents/basic/trait/generic.md @@ -1,6 +1,6 @@ # 泛型Generics -Go语言在2022年，就要正式引入泛型，被视为在1.0版本后，语言特性发展迈出的一大步，为什么泛型这么重要？到底什么是泛型？Rust的泛型有几种？ +Go 语言在 2022 年，就要正式引入泛型，被视为在 1.0 版本后，语言特性发展迈出的一大步，为什么泛型这么重要？到底什么是泛型？Rust 的泛型有几种？ 本章将一一为你讲解。 我们在编程中，经常有这样的需求：用同一功能的函数处理不同类型的数据，例如两个数的加法，无论是整数还是浮点数，甚至是自定义类型，都能进行支持。在不支持泛型的编程语言中，通常需要为每一种类型编写一个函数： @@ -22,9 +22,9 @@ fn main() { } ``` -上述代码可以正常运行，但是很啰嗦，如果你要支持更多的类型，那么会更繁琐。程序员或多或少都有强迫症，一个好程序员的公认特征就是 - 懒，这么勤快的写一大堆代码，显然不是咱们的优良传统，是不？ +上述代码可以正常运行，但是很啰嗦，如果你要支持更多的类型，那么会更繁琐。程序员或多或少都有强迫症，一个好程序员的公认特征就是 —— 懒，这么勤快的写一大堆代码，显然不是咱们的优良传统，是不？ -在开始讲解Rust的泛型之前，先来看看什么是多态。 +在开始讲解 Rust 的泛型之前，先来看看什么是多态。 在编程的时候，我们经常利用多态。通俗的讲，多态就是好比坦克的炮管，既可以发射普通弹药，也可以发射制导炮弹（导弹），也可以发射贫铀穿甲弹，甚至发射子母弹，没有必要为每一种炮弹都在坦克上分别安装一个专用炮管，即使生产商愿意，炮手也不愿意，累死人啊。所以在编程开发中，我们也需要这样“通用的炮管”，这个“通用的炮管”就是多态。 @@ -40,10 +40,10 @@ fn main() { println!("add f64: {}", add(1.23, 1.23)); } ``` -将之前的代码改成上面这样，就是Rust泛型的初印象，这段代码虽然很简洁，但是并不能编译通过，我们会在后面进行详细讲解，现在只要对泛型有个大概的印象即可。 +将之前的代码改成上面这样，就是 Rust 泛型的初印象，这段代码虽然很简洁，但是并不能编译通过，我们会在后面进行详细讲解，现在只要对泛型有个大概的印象即可。 ## 泛型详解 -上面代码的 `T` 就是**泛型参数**，实际上在Rust中，泛型参数的名称你可以任意起，但是出于惯例，我们都用 `T` ( `T` 是 `type` 的首字母)来作为首选，这个名称越短越好，除非需要表达含义，否则一个字母是最完美的。 +上面代码的 `T` 就是**泛型参数**，实际上在 Rust 中，泛型参数的名称你可以任意起，但是出于惯例，我们都用 `T` ( `T` 是 `type` 的首字母)来作为首选，这个名称越短越好，除非需要表达含义，否则一个字母是最完美的。 使用泛型参数，有一个先决条件，必需在使用前对其进行声明： ```rust @@ -222,7 +222,7 @@ fn main() { } ``` -使用泛型参数前，依然需要提前声明：`impl`，只有提前声明了，我们才能在`Point`中使用它，这样Rust就知道 `Point` 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 `Point` 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 `Point` 而不再是 `Point`。 +使用泛型参数前，依然需要提前声明：`impl`，只有提前声明了，我们才能在`Point`中使用它，这样 Rust 就知道 `Point` 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 `Point` 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 `Point` 而不再是 `Point`。 除了结构体中的泛型参数，我们还能在该结构体的方法中定义额外的泛型参数，就跟泛型函数一样： @@ -268,7 +268,7 @@ impl Point { -## const泛型（Rust 1.51版本引入的重要特性） +## const 泛型（Rust 1.51 版本引入的重要特性） 在之前的泛型中，可以抽象为一句话：针对类型实现的泛型，所有的泛型都是为了抽象不同的类型，那有没有针对值的泛型？可能很多同学感觉很难理解，值怎么使用泛型？不急，我们先从数组讲起。 在[数组](../compound-type/array.md)那节，有提到过很重要的一点：`[i32; 2]` 和 `[i32; 3]` 是不同的数组类型，比如下面的代码： @@ -327,11 +327,11 @@ fn main() { } ``` -也不难，唯一要注意的是需要对T加一个限制 `std::fmt::Debug`，该限制表明 `T` 可以用在 `println!("{:?}", arr)`中，因为 `{:?}` 形式的格式化输出需要 `arr` 实现该特征。 +也不难，唯一要注意的是需要对T加一个限制 `std::fmt::Debug`，该限制表明 `T` 可以用在 `println!("{:?}", arr)` 中，因为 `{:?}` 形式的格式化输出需要 `arr` 实现该特征。 -通过引用，我们可以很轻松的解决处理任何类型数组的问题，但是如果在某些场景下引用不适宜用或者干脆不能用呢？你们知道为什么以前Rust的一些数组库，在使用的时候都限定长度不超过32吗？因为它们会为每个长度都单独实现一个函数，简直。。。毫无人性。难道没有什么办法可以解决这个问题吗？ +通过引用，我们可以很轻松的解决处理任何类型数组的问题，但是如果在某些场景下引用不适宜用或者干脆不能用呢？你们知道为什么以前 Rust 的一些数组库，在使用的时候都限定长度不超过32吗？因为它们会为每个长度都单独实现一个函数，简直。。。毫无人性。难道没有什么办法可以解决这个问题吗？ -好在，现在咱们有了const泛型，也就是针对值的泛型，正好可以用于处理数组长度的问题： +好在，现在咱们有了 const 泛型，也就是针对值的泛型，正好可以用于处理数组长度的问题： ```rust fn display_array(arr: [T; N]) { println!("{:?}", arr); @@ -347,12 +347,12 @@ fn main() { 如上所示，我们定义了一个类型为 `[T; N]` 的数组，其中 `T` 是一个基于类型的泛型参数，这个和之前讲的泛型没有区别，而重点在于 `N` 这个泛型参数，它是一个基于值的泛型参数！因为它用来替代的是数组的长度。 -`N` 就是const泛型，定义的语法是 `const N: usize`，表示const泛型N，它基于的值类型是 `usize`。 +`N` 就是 const 泛型，定义的语法是 `const N: usize`，表示 const 泛型 `N` ，它基于的值类型是 `usize`。 -在泛型参数之前，Rust完全不适合复杂矩阵的运算，自从有了const泛型，一切即将改变。 +在泛型参数之前，Rust 完全不适合复杂矩阵的运算，自从有了 const 泛型，一切即将改变。 -#### const泛型表达式 -假设我们某段代码需要在内存很小的平台上工作，因此需要限制函数参数占用的内存大小，此时就可以使用const泛型表达式来实现： +#### const 泛型表达式 +假设我们某段代码需要在内存很小的平台上工作，因此需要限制函数参数占用的内存大小，此时就可以使用 const 泛型表达式来实现： ```rust // 目前只能在nightly版本下使用 #![allow(incomplete_features)] @@ -361,7 +361,7 @@ fn main() { fn something(val: T) where Assert<{ core::mem::size_of::() < 768 }>: IsTrue, - // ^-----------------------------^ 这里是一个const表达式，换成其它的const表达式也可以 + // ^-----------------------------^ 这里是一个 const 表达式，换成其它的 const 表达式也可以 { // } @@ -392,9 +392,9 @@ impl IsTrue for Assert { ## 泛型的性能 -在Rust中泛型是零成本的抽象，意味着你在使用泛型时，完全不用担心性能上的问题。 +在 Rust 中泛型是零成本的抽象，意味着你在使用泛型时，完全不用担心性能上的问题。 -但是任何选择都是权衡得失的，既然我们获得了性能上的巨大优势，那么又失去了什么呢？Rust是在编译期为泛型对应的多个类型，生成各自的代码，因此损失了编译速度和增大了最终生成文件的大小。 +但是任何选择都是权衡得失的，既然我们获得了性能上的巨大优势，那么又失去了什么呢？Rust 是在编译期为泛型对应的多个类型，生成各自的代码，因此损失了编译速度和增大了最终生成文件的大小。 具体来说： diff --git a/book/contents/basic/trait/intro.md b/book/contents/basic/trait/intro.md index 5cb8213e..e9be7bba 100644 --- a/book/contents/basic/trait/intro.md +++ b/book/contents/basic/trait/intro.md @@ -1,3 +1,3 @@ # 泛型和特征 -泛型和特征是Rust中最最重要的抽象类型，也是你在学习Rust路上的拦路虎，但是挑战往往与乐趣并存，一旦学会，在后面学习Rust的路上，你将一往无前。 +泛型和特征是 Rust 中最最重要的抽象类型，也是你在学习 Rust 路上的拦路虎，但是挑战往往与乐趣并存，一旦学会，在后面学习 Rust 的路上，你将一往无前。 diff --git a/book/contents/basic/trait/trait-object.md b/book/contents/basic/trait/trait-object.md index fdfc504d..51caa131 100644 --- a/book/contents/basic/trait/trait-object.md +++ b/book/contents/basic/trait/trait-object.md @@ -17,7 +17,7 @@ fn returns_summarizable(switch: bool) -> impl Summary { 其中 `Post` 和 `Weibo` 都实现了 `Summary` 特征，因此上面的函数试图通过返回 `impl Summary` 来返回这两个类型，但是编译器却无情地报错了，原因是 `impl Trait` 的返回值类型并不支持多种不同的类型返回，那如果我们想返回多种类型，该怎么办？ -再来考虑一个问题：现在在做一款游戏，需要将多个对象渲染在屏幕上，这些对象属于不同的类型，存储在列表中，渲染的时候，需要循环该列表并顺序渲染每个对象，在Rust中该怎么实现？ +再来考虑一个问题：现在在做一款游戏，需要将多个对象渲染在屏幕上，这些对象属于不同的类型，存储在列表中，渲染的时候，需要循环该列表并顺序渲染每个对象，在 Rust 中该怎么实现？ 聪明的同学可能已经能想到一个办法，利用枚举： ```rust @@ -43,19 +43,19 @@ fn draw(o: UiObject) { } ``` -Bingo，这个确实是一个办法，但是问题来了，如果你的对象集合并不能事先明确地知道呢？或者别人想要实现一个UI组件呢？此时枚举中的类型是有些缺少的，是不是还要修改你的代码增加一个枚举成员？ +Bingo，这个确实是一个办法，但是问题来了，如果你的对象集合并不能事先明确地知道呢？或者别人想要实现一个 UI 组件呢？此时枚举中的类型是有些缺少的，是不是还要修改你的代码增加一个枚举成员？ -总之，在编写这个UI库时，我们无法知道所有的UI对象类型，只知道的是： -- UI对象的类型不同 +总之，在编写这个 UI 库时，我们无法知道所有的 UI 对象类型，只知道的是： +- UI 对象的类型不同 - 需要一个统一的类型来处理这些对象，无论是作为函数参数还是作为列表中的一员 - 需要对每一个对象调用 `draw` 方法 在拥有继承的语言中，可以定义一个名为 `Component` 的类，该类上有一个 `draw` 方法。其他的类比如 `Button`、`Image` 和 `SelectBox` 会从 `Component` 派生并因此继承 `draw` 方法。它们各自都可以覆盖 `draw` 方法来定义自己的行为，但是框架会把所有这些类型当作是 `Component` 的实例，并在其上调用 `draw`。不过 Rust 并没有继承，我们得另寻出路。 ## 特征对象定义 -为了解决上面的所有问题，Rust引入了一个概念 - 特征对象。 +为了解决上面的所有问题，Rust 引入了一个概念 —— **特征对象**。 -在介绍特征对象之前，先来为之前的UI组件定义一个特征： +在介绍特征对象之前，先来为之前的 UI 组件定义一个特征： ```rust pub trait Draw { fn draw(&self); @@ -88,7 +88,7 @@ impl Draw for SelectBox { } ``` -此时，还需要一个动态数组来存储这些UI对象： +此时，还需要一个动态数组来存储这些 UI 对象： ```rust pub struct Screen { pub components: Vec, @@ -98,7 +98,7 @@ pub struct Screen { **特征对象**指向实现了 `Draw` 特征的类型的实例，也就是指向了 `Button` 或者 `SelectBox` 的实例，这种映射关系是存储在一张表中，可以在运行时通过特征对象找到具体调用的类型方法。 -可以通过`&`引用或者`Box`智能指针的方式来创建特征对象: +可以通过 `&` 引用或者 `Box` 智能指针的方式来创建特征对象: ```rust trait Draw { fn draw(&self) -> String; @@ -182,7 +182,7 @@ impl Screen 但是这种写法限制了 `Screen` 实例的 `Vec` 中的每个元素必须是 `Button` 类型或者全是 `SelectBox` 类型。如果只需要同质（相同类型）集合，更倾向于这种写法：使用泛型和 特征约束，因为实现更清晰，且性能更好(特征对象，需要在运行时从 `vtable` 动态查找需要调用的方法。 -现在来运行渲染下咱们精心设计的UI组件列表： +现在来运行渲染下咱们精心设计的 UI 组件列表： ```rust fn main() { let screen = Screen { @@ -207,7 +207,7 @@ fn main() { screen.run(); } ``` -上面使用 `Box::new(T)` 的方式来创建了两个 `Box` 特征对象，如果以后还需要增加一个UI组件，那么让该组件实现 `Draw` 特征，则可以很轻松的将其渲染在屏幕上，甚至用户可以引入我们的库作为三方库，然后在自己的库中为自己的类型实现 `Draw` 特征，然后进行渲染。 +上面使用 `Box::new(T)` 的方式来创建了两个 `Box` 特征对象，如果以后还需要增加一个 UI 组件，那么让该组件实现 `Draw` 特征，则可以很轻松的将其渲染在屏幕上，甚至用户可以引入我们的库作为三方库，然后在自己的库中为自己的类型实现 `Draw` 特征，然后进行渲染。 在动态类型语言中，有一个很重要的概念： **鸭子类型**（*duck typing*），简单来说，就是只关心值长啥样，而不关心它实际是什么。当一个东西走起来像鸭子，叫起来像鸭子，那么它就是一只鸭子，就算它实际上是一个奥特曼，也不重要，我们就当它是鸭子。 @@ -231,7 +231,7 @@ fn main() { #### &dyn和Box\的区别 前文提到， `&dyn` 和 `Box` 都可以用于特征对象，因此在功能上 `&dyn` 和 `Box` 几乎没有区别，唯一的区别就是：`&dyn` 减少了一次指针调用。 -因为 `Box` 是一个宽指针(`fat pointer`)，它需要一次额外的解引用后，才能获取到指向`vtable`的指针，然后再通过该指针访问 `vtable` 查询到具体的函数指针，最后进行调用。 +因为 `Box` 是一个宽指针（`fat pointer`），它需要一次额外的解引用后，才能获取到指向 `vtable` 的指针，然后再通过该指针访问 `vtable` 查询到具体的函数指针，最后进行调用。 所以，如果你在乎性能，又想使用特征对象简化代码，可以优先考虑 `&dyn`。 @@ -262,7 +262,7 @@ help: function arguments must have a statically known size, borrowed types alway 当使用特征对象时，Rust 必须使用动态分发。编译器无法知晓所有可能用于特征对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust 在运行时使用特征对象中的指针来知晓需要调用哪个方法。动态分发也阻止编译器有选择的内联方法代码，这会相应的禁用一些优化。 ## Self与self -在Rust中，有两个`self`，一个指代当前的实例对象，一个指代特征或者方法类型的别名： +在 Rust 中，有两个`self`，一个指代当前的实例对象，一个指代特征或者方法类型的别名： ```rust trait Draw { fn draw(&self) -> Self; diff --git a/book/contents/basic/trait/trait.md b/book/contents/basic/trait/trait.md index 13db556e..155f1785 100644 --- a/book/contents/basic/trait/trait.md +++ b/book/contents/basic/trait/trait.md @@ -1,22 +1,22 @@ # 特征Trait -如果我们想定义一个文件系统，那么把该系统跟底层存储解耦是很重要的。文件操作主要包含三个：`open`、`write`、`read`，这些操作可以发生在硬盘，也可以发生在缓存，可以通过网络也可以通过(我实在编不下去了，大家来帮帮我)。总之如果你要为每一种情况都单独实现一套代码，那这种实现将过于繁杂，而且也没那个必要。 +如果我们想定义一个文件系统，那么把该系统跟底层存储解耦是很重要的。文件操作主要包含三个：`open` 、`write`、`read`，这些操作可以发生在硬盘，也可以发生在缓存，可以通过网络也可以通过(我实在编不下去了，大家来帮帮我)。总之如果你要为每一种情况都单独实现一套代码，那这种实现将过于繁杂，而且也没那个必要。 -要解决上述问题，需要把这些行为抽象出来，就要使用Rust中的特征 `trait` 概念。可能你是第一次听说这个名词，但是不要怕，如果学过其他语言，那么大概率你听说过接口，没错，特征很类似接口。 +要解决上述问题，需要把这些行为抽象出来，就要使用 Rust 中的特征 `trait` 概念。可能你是第一次听说这个名词，但是不要怕，如果学过其他语言，那么大概率你听说过接口，没错，特征很类似接口。 -在之前的代码中，我们也多次见过特征的使用，例如 `#[derive(Debug)]`，它在我们定义的类型（struct）上自动派生 `Debug` 特征，接着可以使用 `println!("{:?}",x)` 打印这个类型；再例如： +在之前的代码中，我们也多次见过特征的使用，例如 `#[derive(Debug)]`，它在我们定义的类型（`struct`）上自动派生 `Debug` 特征，接着可以使用 `println!("{:?}", x)` 打印这个类型；再例如： ```rust fn add>(a:T, b:T) -> T { a + b } ``` -通过 `std::ops::Add` 特征来限制`T`，只有 `T` 实现了 `std::ops::Add` 才能进行合法的加法操作，毕竟不是所有的类型都能进行相加。 +通过 `std::ops::Add` 特征来限制 `T`，只有 `T` 实现了 `std::ops::Add` 才能进行合法的加法操作，毕竟不是所有的类型都能进行相加。 这些都说明一个道理，特征定义了**一个可以被共享的行为，只要实现了特征，你就能使用该行为**。 ## 定义特征 如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征。**定义特征**是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。 -例如，我们现在有文章`Post`和微博`Weibo`两种内容载体，而我们想对相应的内容进行总结，也就是无论是文章内容，还是微博内容，都可以在某个时间点进行总结，那么总结这个行为就是共享的，因此可以用特征来定义： +例如，我们现在有文章 `Post` 和微博 `Weibo` 两种内容载体，而我们想对相应的内容进行总结，也就是无论是文章内容，还是微博内容，都可以在某个时间点进行总结，那么总结这个行为就是共享的，因此可以用特征来定义： ```rust pub trait Summary { fn summarize(&self) -> String; @@ -61,7 +61,7 @@ impl Summary for Weibo { } ``` -实现特征的语法与为结构体、枚举实现方法很像：`impl Summary for Post`，读作“为`Post`类型实现 `Summary` 特征”，然后在 `impl` 的花括号中实现该特征的具体方法。 +实现特征的语法与为结构体、枚举实现方法很像：`impl Summary for Post`，读作“为 `Post` 类型实现 `Summary` 特征”，然后在 `impl` 的花括号中实现该特征的具体方法。 接下来就可以在这个类型上调用特征的方法： ```rust @@ -76,7 +76,7 @@ fn main() { 运行输出： ```console -文章Rust语言简介, 作者是Sunface +文章 Rust 语言简介, 作者是Sunface sunface发表了微博好像微博没Tweet好用 ``` @@ -85,7 +85,7 @@ sunface发表了微博好像微博没Tweet好用 #### 特征定义与实现的位置(孤儿规则) 上面我们将 `Summary` 定义成了 `pub` 公开的。这样，如果他人想要使用我们的 `Summary` 特征，则可以引入到他们的包中，然后再进行实现。 -关于特征实现与定义的位置，有一条非常重要的原则：**如果你想要为类型 `A` 实现特征 `T`，那么 `A` 或者 `T `至少有一个是在当前作用域中定义的！**。例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征，这是因为 `Post` 类型定义在当前的作用域中。同时，我们也可以在当前包中为 `String` 类型实现 `Summary` 特征，因为 `Summary` 定义在当前作用域中。 +关于特征实现与定义的位置，有一条非常重要的原则：**如果你想要为类型 `A` 实现特征 `T`，那么 `A` 或者 `T` 至少有一个是在当前作用域中定义的！**。例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征，这是因为 `Post` 类型定义在当前的作用域中。同时，我们也可以在当前包中为 `String` 类型实现 `Summary` 特征，因为 `Summary` 定义在当前作用域中。 但是你无法在当前作用域中，为 `String` 类型实现 `Display` 特征，因为它们俩都定义在标准库中，其定义所在的位置都不在当前作用域，跟你半毛钱关系都没有，看看就行了。 @@ -112,7 +112,7 @@ impl Summary for Weibo { } ``` -可以看到，`Post`选择了默认实现，而`Weibo`重载了该方法，调用和输出如下： +可以看到，`Post` 选择了默认实现，而 `Weibo` 重载了该方法，调用和输出如下： ```rust println!("{}",post.summarize()); println!("{}",weibo.summarize()); @@ -168,7 +168,7 @@ pub fn notify(item: &T) { println!("Breaking news! {}", item.summarize()); } ``` -真正的完整书写形式如上所述，形如`T:Summary`被称为**特征约束**。 +真正的完整书写形式如上所述，形如 `T: Summary` 被称为**特征约束**。 在简单的场景下 `impl Trait` 的语法就足够使用，但是对于复杂的场景，特征约束可以让我们拥有更大的灵活性和语法表现能力，例如一个函数接受两个 `impl Summary` 的参数： ```rust @@ -192,7 +192,7 @@ pub fn notify(item: &(impl Summary + Display)) { ```rust pub fn notify(item: &T) {} ``` -通过这两个特征，就可以使用 `item.summarize` 方法，以及通过 `println!("{}",item)` 来格式化输出 `item`。 +通过这两个特征，就可以使用 `item.summarize` 方法，以及通过 `println!("{}", item)` 来格式化输出 `item`。 #### Where约束 当特征约束变得很多时，函数的签名将变得很复杂： @@ -237,7 +237,7 @@ impl Pair { } ``` -`cmd_display` 方法，并不是所有的 `Pair` 结构体对象都可以拥有，只有 `T` 同时实现了 `Display + PartialOrd`的`Part` 才可以拥有此方法。 +`cmd_display` 方法，并不是所有的 `Pair` 结构体对象都可以拥有，只有 `T` 同时实现了 `Display + PartialOrd` 的 `Part` 才可以拥有此方法。 该函数可读性会更好，因为泛型参数、参数、返回值都在一起，可以快速的阅读，同时每个泛型参数的特征也在新的代码行中通过**特征约束**进行了约束。 **也可以有条件的实现特征**, 例如，标准库为任何实现了 `Display` 特征的类型实现了 `ToString` 特征： @@ -253,8 +253,8 @@ let s = 3.to_string(); ``` -## 函数返回中的`impl Trait` -可以通过`impl Trait`来说明一个函数返回了一个类型，该类型实现了某个特征： +## 函数返回中的 `impl Trait` +可以通过 `impl Trait` 来说明一个函数返回了一个类型，该类型实现了某个特征： ```rust fn returns_summarizable() -> impl Summary { Weibo { @@ -268,7 +268,7 @@ fn returns_summarizable() -> impl Summary { 因为 `Weibo` 实现了 `Summary`，因此这里可以用它来作为返回值。要注意的是，虽然我们知道这里是一个 `Weibo` 类型，但是对于 `returns_summarizable` 的调用者而言，他只知道返回了一个实现了 `Summary` 特征的对象，但是并不知道返回了一个 `Weibo` 类型。 -这种 `impl Trait` 形式的返回值，在一种场景下非常非常有用，那就是返回的真实类型非常复杂，你不知道该怎么声明时(毕竟Rust要求你必须标出所有的类型)，此时就可以用 `impl Trait` 的方式简单返回。例如，闭包和迭代器就是很复杂，只有编译器才知道那玩意的真实类型，如果让你写出来它们的具体类型，我估计想杀人的心都有，好在你可以用 `impl Iterator` 来告诉调用者，返回了一个迭代器，因为所有迭代器都会实现 `Iterator` 特征。 +这种 `impl Trait` 形式的返回值，在一种场景下非常非常有用，那就是返回的真实类型非常复杂，你不知道该怎么声明时(毕竟 Rust 要求你必须标出所有的类型)，此时就可以用 `impl Trait` 的方式简单返回。例如，闭包和迭代器就是很复杂，只有编译器才知道那玩意的真实类型，如果让你写出来它们的具体类型，我估计想杀人的心都有，好在你可以用 `impl Iterator` 来告诉调用者，返回了一个迭代器，因为所有迭代器都会实现 `Iterator` 特征。 但是这种返回值方式有一个很大的限制：只能有一个具体的类型，例如： ```rust @@ -304,10 +304,10 @@ expected struct `Post`, found struct `Weibo` 报错提示我们 `if` 和 `else` 返回了不同的类型。如果想要实现返回不同的类型，需要使用下一章节中的[特征对象](./trait-object.md)。 -## 修复上一节中的`largest`函数 -还记得上一节中的[例子](./generic#泛型详解)吧,当时留下一个疑问，该如何解决编译报错： +## 修复上一节中的 `largest` 函数 +还记得上一节中的[例子](./generic#泛型详解)吧，当时留下一个疑问，该如何解决编译报错： ```rust -error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在`T`类型上应用`>`运算符 +error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在 `T` 类型上应用`>`运算符 --> src/main.rs:5:17 | 5 | if item > largest { @@ -315,13 +315,13 @@ error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在`T` | | | T | -help: consider restricting type parameter `T` // 考虑使用以下的特征来约束T +help: consider restricting type parameter `T` // 考虑使用以下的特征来约束 `T` | 1 | fn largest(list: &[T]) -> T { | ^^^^^^^^^^^^^^^^^^^^^^ ``` -在 `largest` 函数体中我们想要使用大于运算符（>）比较两个 `T` 类型的值。这个运算符是标准库中特征 `std::cmp::PartialOrd` 的一个默认方法。所以需要在 `T` 的特征约束中指定 `PartialOrd`，这样 `largest` 函数可以用于内部元素类型可比较大小的数组切片。 +在 `largest` 函数体中我们想要使用大于运算符（`>`）比较两个 `T` 类型的值。这个运算符是标准库中特征 `std::cmp::PartialOrd` 的一个默认方法。所以需要在 `T` 的特征约束中指定 `PartialOrd`，这样 `largest` 函数可以用于内部元素类型可比较大小的数组切片。 由于 `PartialOrd` 位于 `prelude` 中所以并不需要通过 `std::cmp` 手动将其引入作用域。所以可以将 `largest` 的签名修改为如下： ```rust @@ -349,9 +349,9 @@ error[E0507]: cannot move out of borrowed content | cannot move out of borrowed content ``` -错误的核心是 `cannot move out of type [T], a non-copy slice`， 原因是`T`没有[实现`Copy`特性](../ownership/ownership.md#拷贝(浅拷贝))，因此我们只能把所有权进行转移，毕竟只有`i32`等基础类型才实现了 `Copy` 特性，可以存储在栈上，而 `T` 可以指代任何类型(严格来说是实现了`PartialOrd`特征的所有类型)。 +错误的核心是 `cannot move out of type [T], a non-copy slice`，原因是 `T` 没有[实现 `Copy` 特性](../ownership/ownership.md#拷贝(浅拷贝))，因此我们只能把所有权进行转移，毕竟只有 `i32` 等基础类型才实现了 `Copy` 特性，可以存储在栈上，而 `T` 可以指代任何类型（严格来说是实现了 `PartialOrd` 特征的所有类型）。 -因此，为了让T拥有 `Copy` 特性，我们可以增加特征约束： +因此，为了让 `T` 拥有 `Copy` 特性，我们可以增加特征约束： ```rust fn largest(list: &[T]) -> T { let mut largest = list[0]; @@ -378,21 +378,21 @@ fn main() { } ``` -如果并不希望限制 `largest` 函数只能用于实现了 `Copy` 特征的类型，我们可以在 `T` 的特征约束中指定 [`Clone`特征](../ownership/ownership.md#克隆(深拷贝)) 而不是 `Copy` 特征。并克隆 `list` 中的每一个值使得 `largest` 函数拥有其所有权。使用 `clone` 函数意味着对于类似 `String` 这样拥有堆上数据的类型，会潜在地分配更多堆上空间，而堆分配在涉及大量数据时可能会相当缓慢。 +如果并不希望限制 `largest` 函数只能用于实现了 `Copy` 特征的类型，我们可以在 `T` 的特征约束中指定 [`Clone` 特征](../ownership/ownership.md#克隆(深拷贝)) 而不是 `Copy` 特征。并克隆 `list` 中的每一个值使得 `largest` 函数拥有其所有权。使用 `clone` 函数意味着对于类似 `String` 这样拥有堆上数据的类型，会潜在地分配更多堆上空间，而堆分配在涉及大量数据时可能会相当缓慢。 另一种 `largest` 的实现方式是返回在 `list` 中 `T` 值的引用。如果我们将函数返回值从 `T` 改为 `&T` 并改变函数体使其能够返回一个引用，我们将不需要任何 `Clone` 或 `Copy` 的特征约束而且也不会有任何的堆分配。尝试自己实现这种替代解决方式吧！ -## 通过`derive`派生特征 +## 通过 `derive` 派生特征 在本书中，形如 `#[derive(Debug)]` 的代码已经出现了很多次，这种是一种特征派生语法，被 `derive` 标记的对象会自动实现对应的默认特征代码，继承相应的功能。 -例如 `Debug` 特征，它有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 `println!("{:?}",s)` 的形式打印该结构体的对象。 +例如 `Debug` 特征，它有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 `println!("{:?}", s)` 的形式打印该结构体的对象。 再如 `Copy` 特征，它也有一套自动实现的默认代码，当标记到一个类型上时，可以让这个类型自动实现 `Copy` 特征，进而可以调用 `copy` 方法，进行自我复制。 -总之，`derive` 派生出来的是Rust默认给我们提供的特征，在开发过程中极大的简化了自己手动实现相应特征的需求，当然，如果你有特殊的需求，还可以自己手动重载该实现。 +总之，`derive` 派生出来的是 Rust 默认给我们提供的特征，在开发过程中极大的简化了自己手动实现相应特征的需求，当然，如果你有特殊的需求，还可以自己手动重载该实现。 -详细的 `derive` 列表参加[附录-派生特征](../../appendix/derive.md)。 +详细的 `derive` 列表参见[附录-派生特征](../../appendix/derive.md)。 ## 调用方法需要引入特征 在一些场景中，使用 `as` 关键字做类型转换会有比较大的限制，因为你想要在类型转换上拥有完全的控制，例如处理转换错误，那么你将需要 `TryInto`： @@ -415,13 +415,13 @@ fn main() { 上面代码中引入了 `std::convert::TryInto` 特征，但是却没有使用它，可能有些同学会为此困惑，主要原因在于**如果你要使用一个特征的方法，那么你需要引入该特征到当前的作用域中**，我们在上面用到了 `try_into` 方法，因此需要引入对应的特征。 -但是Rust又提供了一个非常便利的办法，即把最常用的标准库中的特征通过[`std::prelude`](std::convert::TryInto)模块提前引入到当前作用域中，其中包括了 `std::convert::TryInto`，你可以尝试删除第一行的代码 `use ...`，看看是否会报错. +但是 Rust 又提供了一个非常便利的办法，即把最常用的标准库中的特征通过 [`std::prelude`](std::convert::TryInto) 模块提前引入到当前作用域中，其中包括了 `std::convert::TryInto`，你可以尝试删除第一行的代码 `use ...`，看看是否会报错。 ## 几个综合例子 -#### 为自定义类型实现`+`操作 -在Rust中除了数值类型的加法，`String` 也可以做[加法](../compound-type/string-slice.md#操作字符串)，因为Rust为该类型实现了 `std::ops::Add` 特征，同理，如果我们为自定义类型实现了该特征，那就可以自己实现 `Point1 + Point2` 的操作: +#### 为自定义类型实现 `+` 操作 +在 Rust 中除了数值类型的加法，`String` 也可以做[加法](../compound-type/string-slice.md#操作字符串)，因为 Rust 为该类型实现了 `std::ops::Add` 特征，同理，如果我们为自定义类型实现了该特征，那就可以自己实现 `Point1 + Point2` 的操作: ```rust use std::ops::Add; @@ -527,7 +527,7 @@ fn main() { ``` -以上两个例子较为复杂，目的是为读者展示下真实的使用场景长什么样，因此需要读者细细阅读，最终消化这些知识对于你的Rust之路会有莫大的帮助。 +以上两个例子较为复杂，目的是为读者展示下真实的使用场景长什么样，因此需要读者细细阅读，最终消化这些知识对于你的 Rust 之路会有莫大的帮助。 -最后，特征和特征约束，是Rust中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就可以进入下一节的学习。 +最后，特征和特征约束，是 Rust 中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就可以进入下一节的学习。