元素，并打印出第一个完成全部过程的标题。让我们开始编写一个函数，它获取一个网页 URL 作为参数，请求该 URL 并返回标题元素的文本：文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # fn main() {\n# // TODO: we'll add this next!\n# }\n# use trpl::Html; async fn page_title(url: &str) -> Option<String> { let response = trpl::get(url).await; let response_text = response.text().await; Html::parse(&response_text) .select_first(\"title\") .map(|title_element| title_element.inner_html())\n} 示例 17-1：定义一个 async 函数来获取一个 HTML 页面的标题元素在示例 17-1 中，我们定义了一个名为 page_title 的函数，并使用了 async 关键字标记。接着我们使用 trpl::get 函数来获取传入的任意 URL，然后使用 await 关键字来等待响应。接着我们调用其 text 方法来获取响应的文本，这里再一次使用 await 关键字等待。这两个步骤都是异步的。对于 get 来说，我们需要等待服务器发送回其响应的第一部分，这会包含 HTTP 头（headers）、cookies 等。这部分响应可以独立于响应体发送。特别是在响应体非常大时候，接收完整响应可能会花费一些时间。因此我们不得不等待响应整体返回，所以 text 方法也是异步。我们必须显示地等待这两个 futures，因为 Rust 中的 futures 是惰性（ lazy ）的：在你使用 await 请求之前它们不会执行任何操作。（事实上，如果你不使用一个 futures，Rust 会显示一个编译警告）这应该会让你想起之前第十三章关于迭代器的讨论。直到你调用迭代器的 next 方法（直接调用或者使用 for 循环或者类似 map 这类在底层使用 next 的方法）之前它们什么也不会做。对于 futures 来说，同样的基本理念也是适用的：除非你显式地请求，否则它们不会执行。惰性使得 Rust 可以避免提前运行异步代码，直到真正需要时才执行。注意：这不同于上一章节中 thread::spawn 的行为，当时传递给另一个线程的闭包会立即开始运行。这也与许多其他语言处理异步的方式不同！但对于 Rust 而言，这一点非常重要。稍后我们会解释原因。当我们有了 response_text 函数，就可以使用 Html::parse 将其解析为一个 Html 类型的实例。不同于原始字符串，现在我们有了一个可以将 HTML 作为更丰富数据结构来操作的数据类型。特别是我们可以使用 select_first 方法来找出给定 CSS 选择器（selector）中第一个匹配元素。通过传递字符串 \"title\"，我们会得到文档中的第一个 <title> 元素，如果它存在的话。由于可能没有任何匹配的元素，select_first 返回一个 Option<ElementRef>。最后我们使用 Option::map 方法，它允许我们在 Option 中有元素时对其进行处理，而在没有时则什么也不做。（这里也可以使用一个 match 表达式，但 map 更符合惯用的写法。）在传递给 map 的函数体中，我们调用了 title_element 上的 inner_html 来获取其内容，这是一个 String。当上面所讲的都完成后，我们会得到一个 Option<String>。注意 Rust 的 await 关键字出现在需要等待的表达式之后而不是之前。也就是说，这是一个后缀关键字（ postfix keyword ）。如果你在其它语言中使用过 async 的话，这可能与你所熟悉的有所不同。Rust 如此选择是因为这使得方法的链式调用更加简洁。因此，我们可以修改 page_url_for 的函数体来链式调用 trpl::get 和 text 并在其之间使用 await，如示例 17-2 所示：文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # use trpl::Html;\n# # fn main() {\n# // TODO: we'll add this next!\n# }\n# # async fn page_title(url: &str) -> Option<String> { let response_text = trpl::get(url).await.text().await;\n# Html::parse(&response_text)\n# .select_first(\"title\")\n# .map(|title_element| title_element.inner_html())\n# } 示例 17-2：使用 `await` 关键字的链式调用这样我们就成功编写了第一个异步函数！在我们向 main 加入一些代码调用它之前，让我们再多了解下我们写了什么以及它的意义。当 Rust 遇到一个 async 关键字标记的代码块时，会将其编译为一个实现了 Future trait 的唯一的、匿名的数据类型。当 Rust 遇到一个被标记为 async 的函数时，会将其编译进一个拥有异步代码块的非异步函数。异步函数的返回值类型是编译器为异步代码块所创建的匿名数据类型。因此，编写 async fn 就等同于编写一个返回类型的 future 的函数。当编译器遇到类似示例 17-1 中 async fn page_title 的函数定义时，它等价于以下定义的非异步函数： # extern crate trpl; // required for mdbook test\nuse std::future::Future;\nuse trpl::Html; fn page_title(url: &str) -> impl Future<Output = Option<String>> + '_ { async move { let text = trpl::get(url).await.text().await; Html::parse(&text) .select_first(\"title\") .map(|title| title.inner_html()) }\n} 让我们挨个看一下转换后版本的每一个部分：它使用了之前第十章 “trait 作为参数” 部分讨论过的 impl Trait 语法它返回的 trait 是一个 Future，它有一个关联类型 Output。注意 Output 的类型是 Option<String>，这与 async fn 版本的 page_title 的原始返回值类型相同。所有原始函数中被调用的代码被封装进一个 async move 块。回忆一下，代码块是表达式。这整个块就是函数所返回的表达式如上所述，这个异步代码块产生一个 Option<String> 类型的值。这个值与返回类型中的 Output 类型一致。这正类似于你已经见过的其它代码块。新版函数的函数体是一个 async move 代码块，因为它如何使用 url 参数决定了这一点。（本章后续部分将更详细地讨论 async 和 async move 之间的区别。）新版本的函数在返回类型中使用了一种我们之前未见过的生命周期标记：'_。因为函数返回的 Future 指向一个引用（在这个例子中是指向 url 参数的引用）我们需要告诉 Rust 引用的生命周期。这里无需命名该生命周期，因为 Rust 足够智能到能理解这里只涉及到唯一一个引用，不过我们必须明确指出返回的 Future 受该生命周期的约束。现在我们可以在 main 中调用 page_title。首先，我们只会获取一个页面的标题。在示例 17-3 中，我们沿用了第十二章中获取命令行参数的相同模式。接着我们传递第一个 URL 给 page_title，并等待结果。因为 future 产生的值是一个 Option<String>，我们使用 match 表达式来根据页面是否有 <title> 来打印不同的信息。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # use trpl::Html;\n# async fn main() { let args: Vec<String> = std::env::args().collect(); let url = &args[1]; match page_title(url).await { Some(title) => println!(\"The title for {url} was {title}\"), None => println!(\"{url} had no title\"), }\n}\n# # async fn page_title(url: &str) -> Option<String> {\n# let response_text = trpl::get(url).await.text().await;\n# Html::parse(&response_text)\n# .select_first(\"title\")\n# .map(|title_element| title_element.inner_html())\n# } 示例 17-3：在 `main` 中通过一个用户提供的参数调用 `page_title` 函数很不幸的是这还不能编译。唯一可以使用 await 关键字的地方是异步函数或者代码块中，同时 Rust 不允许将特殊的 main 函数标记为 async。 error[E0752]: `main` function is not allowed to be `async` --> src/main.rs:6:1 |\n6 | async fn main() { | ^^^^^^^^^^^^^^^ `main` function is not allowed to be `async` main 不能标记为 async 的原因是异步代码需要一个运行时：即一个管理执行异步代码细节的 Rust crate。一个程序的 main 函数可以初始化一个运行时，但是其自身并不是一个运行时。（稍后我们会进一步解释原因。）每一个执行异步代码的 Rust 程序必须至少有一个设置运行时并执行 futures 的地方。大部分支持异步的语言会打包一个运行时在语言中。Rust 则不是，相这里有很多不同的异步运行时，每一个都有适合其目标的权衡取舍。例如，一个拥有很多核心和大量内存的高吞吐 web server 与一个单核、少量内存并且没有堆分配能力的微控制器相比有着截然不同的需求。提供这些运行时的 crate 通常也提供了例如文件或者网络 IO 这类常用功能的异步版本。从这里到本章余下部分，我们会使用 trpl crate 的 run 函数，它获取一个 future 作为参数并运行到结束。在内部，调用 run 会设置一个运行时来运行传递的 future。一旦 future 完成，run 返回 future 返回的任何值。我们可以将 page_title 返回的 future 直接传递给 run。一旦其完成，我们能够匹配返回的 Option<String>，正如示例 17-3 我们尝试的那样。然而，在本章的大部分示例中（以及大多数实际应用中的异步代码中！），我们会执行不止一次异步函数调用，所以相反我们会传递一个 async 块并显式地等待 page_title 调用的结果，如示例 17-4 所示。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # use trpl::Html;\n# fn main() { let args: Vec<String> = std::env::args().collect(); trpl::run(async { let url = &args[1]; match page_title(url).await { Some(title) => println!(\"The title for {url} was {title}\"), None => println!(\"{url} had no title\"), } })\n}\n# # async fn page_title(url: &str) -> Option<String> {\n# let response_text = trpl::get(url).await.text().await;\n# Html::parse(&response_text)\n# .select_first(\"title\")\n# .map(|title_element| title_element.inner_html())\n# } 示例 17-4：等待一个使用异步代码块的 `trpl::run` 当我们运行代码，我们会得到最初预想的行为： $ cargo run \"http://www.rust-lang.org\"\nThe title for http://www.rust-lang.org was Rust Programming Language 我们终于有了一些可以正常工作的异步代码！现在它们可以成功编译并运行。在我们添加代码让两个网址进行竞争之前，让我们简要地回顾一下 future 是如何工作的。每一个 await point ，也就是代码使用 await 关键字的地方，代表将控制权交还给运行时的地方。为此 Rust 需要记录异步代码块中涉及的状态，这样运行时可以去执行其他工作，并在准备好时回来继续推进当前的任务。这就像你通过编写一个枚举来保存每一个 await point 的状态一样： # extern crate trpl; // required for mdbook test\n# enum PageTitleFuture<'a> { Initial { url: &'a str }, GetAwaitPoint { url: &'a str }, TextAwaitPoint { response: trpl::Response },\n} 编写代码来手动控制不同状态之间的转换是非常乏味且容易出错的，特别是之后增加了更多功能和状态的时候。相反，Rust 编译器自动创建并管理异步代码的状态机数据结构。如果你感兴趣的话：是的，正常的借用和所有权也全部适用于这些数据结构。幸运的是，编译器也会为我们处理这些检查，并提供友好的错误信息。本章稍后会讲解一些相关内容！最终需要某个组件来执行状态机。这就是运行时。（这也是为什么在了解运行时的时候，你可能会看到 executors 这个词：executor 是运行时中负责执行异步代码的部分。）现在我们能够理解了之前示例 17-3 中为何编译器阻止我们将 main 本身标记为异步函数了。如果 main 是一个异步函数，需要有其它组件来管理 main futrue 返回的状态机，但是 main 是程序的入口点！为此我们在 main 函数中调用 trpl::run，它设置了一个运行时并运行 async 块返回的 future 并等待它返回 Ready。注意：一些运行时提供了相关的宏所以你可以编写一个异步 main 函数。这些宏将 async fn main() { ... } 重写为正常的 fn main，执行的逻辑与我们在示例 17-5 中手动实现的一样：像 trpl::run 一样调用一个函数运行 future 直到结束。让我们将这些代码片段整理一下来看看如何编写并发代码，这里通过两个来自命令行的不同 URL 来调用 page_title 并使其相互竞争。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# use trpl::{Either, Html}; fn main() { let args: Vec<String> = std::env::args().collect(); trpl::run(async { let title_fut_1 = page_title(&args[1]); let title_fut_2 = page_title(&args[2]); let (url, maybe_title) = match trpl::race(title_fut_1, title_fut_2).await { Either::Left(left) => left, Either::Right(right) => right, }; println!(\"{url} returned first\"); match maybe_title { Some(title) => println!(\"Its page title is: '{title}'\"), None => println!(\"Its title could not be parsed.\"), } })\n} async fn page_title(url: &str) -> (&str, Option<String>) { let text = trpl::get(url).await.text().await; let title = Html::parse(&text) .select_first(\"title\") .map(|title| title.inner_html()); (url, title)\n} 示例 17-5 示例 17-5 中以分别由用户提供的 URL 调用 page_title 开始。我们将调用 page_title 产生的 future 分别保存为 title_fut_1 和 title_fut_2。请记住，它们还没有进行任何工作，因为 future 是惰性的，并且我们还没有 await 它们。接着我们将 futures 传递给 trpl::race，它返回一个值表明哪个传递的 future 最先返回。注意：在内部 race 构建在一个更通用的函数 select 之上，你会在真实的 Rust 代码中更常遇到它。select 函数可以做很多 trpl::race 函数做不了的事，不过它也有一些额外的复杂性，所以目前我们先略过介绍。由于任何一个 future 都可以合理地 “获胜”，所以返回 Result 没有意义。相反 race 返回了一个我们之前没有见过的类型 trpl::Either。Either 类型有点类似于 Result，它也有两个成员。但是不同于 Either，Either 没有内置成功或者失败的概念。相反它使用 Left 和 Right 来表示 “一个或另一个”。 enum Either<A, B> { Left(A), Right(B),\n} race 函数返回 Left，如果第一个参数先完成，并包含该 future 的输出，如果第二个 future 先完成，则返回 Right 和第二个 future 的输出。这匹配调用函数时参数出现的顺序：第一个参数在第二个参数的左边。我们还更新了 page_title 来返回与传递时相同的 URL。如此如果首先返回的页面没有可以解析的 <title>，仍然可以打印出有意义的信息。有了这些信息，我们对 println! 的输出进行了封装和更新，以表明哪个 URL 最先完成，并在页面有 <title> 时打印出它的内容。现在我们完成一个小型网页爬虫的构建了！挑选一对 URL 并运行命令行工具。你会发现某些网站稳定地快于其它网站，而有些情况哪些网站会赢则每次都不同。更重要的是，你已经掌握了处理 futures 的基础知识，因此我们现在可以进一步探索更多异步操作的可能性了。","breadcrumbs":"Async 和 await » Futures 和 async 语法 » 第一个异步程序","id":"316","title":"第一个异步程序"},"317":{"body":"ch17-02-concurrency-with-async.md commit 62d441060d66f9a1c3d3cdfffa8eed40f817d1aa 在这一部分，我们采用异步来应对一些之前第十六章中采用并发面对的相同的问题。因为之前我们已经讨论了很多关键理念了，这一部分我们会专注于线程与 future 的区别。在很多情况下，使用异步处理并发的 API 与使用线程的非常相似。在其它的一些情况，它们则非常不同。即便线程与异步的的 API 看起来很类似，通常它们有着不同的行为，同时它们几乎总是有着不同的性能特点。","breadcrumbs":"Async 和 await » 并发与 async » 并发与 async","id":"317","title":"并发与 async"},"318":{"body":"第十六章中我们应付的第一个任务是在两个不同的线程中计数。让我们用异步来做相同的事。trpl crate 提供了一个 spawn_task 函数，它看起来非常像 thread::spawn API，和一个 sleep 函数，这是 thread::sleep API 的异步版本。我们可以结合它们来实现与采用线程的相同的计数示例，如示例 17-6 所示。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# use std::time::Duration; fn main() { trpl::run(async { trpl::spawn_task(async { for i in 1..10 { println!(\"hi number {i} from the first task!\"); trpl::sleep(Duration::from_millis(500)).await; } }); for i in 1..5 { println!(\"hi number {i} from the second task!\"); trpl::sleep(Duration::from_millis(500)).await; } });\n} 示例 17-6：使用 `spawn_task` 启动两个计数任务作为开始，我们在 main 函数中使用 trpl::run，这样我们的顶层函数可以是异步的。注意：本章从现在开始，每一个示例的 main 中都会包含几乎相同的 trpl::run 封装代码，所以我们经常会连同 main 一同省略。别忘了在你的代码中加入它们！接着我们在代码块中编写了两个循环，每个其中都有一个 trpl::sleep 调用，每一个都在发送下一个信息之前等待半秒钟（500 毫秒）。我们将一个循环放到 trpl::spawn_task 中并将另一个放在顶层的 for 循环中。我们也在 sleep 调用之后加入了一个 await。它做了与基于线程的版本相同的工作，也包括运行时你可能在终端看到消息以不同的顺序出现的事实。 hi number 1 from the second task!\nhi number 1 from the first task!\nhi number 2 from the first task!\nhi number 2 from the second task!\nhi number 3 from the first task!\nhi number 3 from the second task!\nhi number 4 from the first task!\nhi number 4 from the second task!\nhi number 5 from the first task! 这个版本在 main 中的异步代码块中 for 循环结束后就停止了，因为当 main 函数结束时 spawn_task 产生的任务就会关闭。如果运行该任务直到结束，你需要使用一个 join 句柄（join handle）来等待第一个任务完成。对于线程来说，可以使用 join 方法来 “阻塞” 直到线程结束运行。在示例 17-7 中，我们可以使用 await 来做相同的事情，因为任务句柄本身是一个 future。它的 Output 类型是一个 Result，所以我们还需要 unwrap 来 await 它。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # use std::time::Duration;\n# # fn main() {\n# trpl::run(async { let handle = trpl::spawn_task(async { for i in 1..10 { println!(\"hi number {i} from the first task!\"); trpl::sleep(Duration::from_millis(500)).await; } }); for i in 1..5 { println!(\"hi number {i} from the second task!\"); trpl::sleep(Duration::from_millis(500)).await; } handle.await.unwrap();\n# });\n# } 示例 17-7：在一个 join 句柄上使用 `await` 使得任务运行直到结束更新后的版本会运行两个任务直到结束。 hi number 1 from the second task!\nhi number 1 from the first task!\nhi number 2 from the first task!\nhi number 2 from the second task!\nhi number 3 from the first task!\nhi number 3 from the second task!\nhi number 4 from the first task!\nhi number 4 from the second task!\nhi number 5 from the first task!\nhi number 6 from the first task!\nhi number 7 from the first task!\nhi number 8 from the first task!\nhi number 9 from the first task! 目前为止，看起来异步和线程版本给出了基本一样的输出，它们只是使用了不同的语法：在 join 句柄上使用 await 而不是调用 join，和 await sleep 调用。最大的区别是无需再产生另一个操作系统线程来进行工作。事实上，我们甚至不需要产生一个任务。因为异步代码块会编译为匿名 future，我们可以将每一个循环放进一个异步代码块并使用 trpl::join 方法来让运行时将它们两个都运行至完成。在第十六章中，我们展示了如何在 std::thread::spawn 调用返回的 JoinHandle 类型上调用 join 方法。trpl::join 函数也类似，不过它作用于 future。当你传递两个 future，它会产生单独一个 future 但它的输出是一个元组，当两者都完成时其中有每一个传递给它的 future 的输出。因此，在示例 17-8 中，我们使用 trpl::join 来等待 fut1 和 fut2 都结束。我们没有 await fut1 和 fut2，而是等待 `trpl::join 新产生的 future。我们忽略其输出，因为它只是一个包含两个单元值（unit value）的元组。文件名：src/main.rs # extern crate trpl; // required for mdbook test\n# # use std::time::Duration;\n# # fn main() {\n# trpl::run(async { let fut1 = async { for i in 1..10 { println!(\"hi number {i} from the first task!\"); trpl::sleep(Duration::from_millis(500)).await; } }; let fut2 = async { for i in 1..5 { println!(\"hi number {i} from the second task!\"); trpl::sleep(Duration::from_millis(500)).await; } }; trpl::join(fut1, fut2).await;\n# });\n# } 示例 17-8：使用 `trpl::join` 来 await 两个匿名 future 当运行代码我们会看到两个 future 会运行至结束： hi number 1 from the first task!\nhi number 1 from the second task!\nhi number 2 from the first task!\nhi number 2 from the second task!\nhi number 3 from the first task!\nhi number 3 from the second task!\nhi number 4 from the first task!\nhi number 4 from the second task!\nhi number 5 from the first task!\nhi number 6 from the first task!\nhi number 7 from the first task!\nhi number 8 from the first task!\nhi number 9 from the first task! 这里，你每次都会看到完全相同的顺序，这与我们在线程中看到非常不同。这是因为 trpl::join 函数是公平的（ fair ），这意味着它检查每一个 future 的频率一致，使它们交替执行，绝不会让一个任务在其它任务完成后抢先执行。对于线程来说，操作系统会决定该检查哪个线程和会让它运行多长时间。对于异步 Rust 来说，运行时决定检查哪一个任务。（在实践中，细节会更为复杂，因为异步运行时可能在底层使用操作系统线程来作为其并发管理的一部分，所以确保公平性需要比运行时更多的工作，不过这也是可能的！）运行时无需为任何操作保证公平性，同时运行时也经常提供不同的 API 来让你选择是否需要公平性。尝试这些不同的 await future 的变体来观察它们做了什么：去掉一个或者两个循环外的异步代码块。在定义两个异步代码块后立刻 await 它们。直将第一个循环封装进异步代码块，并在第二个循环体之后 await 作为结果的 future。作为额外的挑战，看看你能否在运行代码之前想出每个情况下的输出！","breadcrumbs":"Async 和 await » 并发与 async » 计数","id":"318","title":"计数"},"319":{"body":"","breadcrumbs":"Async 和 await » 使用任意数量的 futures » 使用任意数量的 futures","id":"319","title":"使用任意数量的 futures"},"32":{"body":"要创建一个新项目，进入第一章中创建的 projects 目录，使用 Cargo 新建一个项目，如下： $ cargo new guessing_game\n$ cd guessing_game 第一个命令，cargo new，它获取项目的名称（guessing_game）作为第一个参数。第二个命令进入到新创建的项目目录。看看生成的 Cargo.toml 文件：文件名：Cargo.toml [package]\nname = \"guessing_game\"\nversion = \"0.1.0\"\nedition = \"2021\" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] 正如第一章那样，cargo new 生成了一个 “Hello, world!” 程序。查看 src/main.rs 文件：文件名：src/main.rs fn main() { println!(\"Hello, world!\");\n} 现在使用 cargo run 命令，一步完成 “Hello, world!” 程序的编译和运行： $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.50s Running `target/debug/guessing_game`\nHello, world! 当你需要在项目中快速迭代时，run 命令就能派上用场，正如我们在这个游戏项目中做的，在下一次迭代之前快速测试每一次迭代。重新打开 src/main.rs 文件。我们将会在这个文件中编写全部的代码。","breadcrumbs":"写个猜数字游戏 » 准备一个新项目","id":"32","title":"准备一个新项目"},"320":{"body":"","breadcrumbs":"Async 和 await » 流（Streams） » 流（Streams）","id":"320","title":"流（Streams）"},"321":{"body":"","breadcrumbs":"Async 和 await » 深入理解 async 相关的 traits » 深入理解 async 相关的 traits","id":"321","title":"深入理解 async 相关的 traits"},"322":{"body":"","breadcrumbs":"Async 和 await » Futures，任务（tasks）和线程（threads） » Futures，任务（tasks）和线程（threads）","id":"322","title":"Futures，任务（tasks）和线程（threads）"},"323":{"body":"ch18-00-oop.md commit 398d6f48d2e6b7b15efd51c4541d446e89de3892 面向对象编程（Object-Oriented Programming，OOP）是一种对程序进行建模方式。对象（Object）作为一个编程概念来源于 20 世纪 60 年代的 Simula 编程语言。这些对象影响了 Alan Kay 的编程架构，该架构中对象之间互相传递消息。他在 1967 年创造了面向对象编程（ object-oriented programming ）这个术语。关于 OOP 是什么有很多相互矛盾的定义；在一些定义下，Rust 是面向对象的；在其他定义下，Rust 不是。在本章节中，我们会探索一些被普遍认为是面向对象的特性和这些特性是如何体现在 Rust 语言习惯中的。接着会展示如何在 Rust 中实现面向对象设计模式，并讨论这么做与利用 Rust 自身的一些优势实现的方案相比有什么取舍。","breadcrumbs":"Rust 的面向对象编程特性 » Rust 的面向对象特性","id":"323","title":"Rust 的面向对象特性"},"324":{"body":"ch18-01-what-is-oo.md commit 398d6f48d2e6b7b15efd51c4541d446e89de3892 关于一门语言必须具备哪些特征才能被视为面向对象，目前在编程社区中并没有共识。Rust 受到了许多编程范式的影响，包括面向对象编程（OOP）；例如，在第 13 章中，我们探讨了来自函数式编程的特性。可以说，面向对象的语言共有一些共同的特征，即对象、封装和继承。我们将会讨论这些特征分别是什么，以及 Rust 是否支持它们。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象语言的特点 » 面向对象语言的特征","id":"324","title":"面向对象语言的特征"},"325":{"body":"由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides（Addison-Wesley Professional, 1994）编写的书 Design Patterns: Elements of Reusable Object-Oriented Software ，通称 The Gang of Four (“四人帮”)，是一本面向对象设计模式的目录。它这样定义面向对象编程： Object-oriented programs are made up of objects. An object packages both data and the procedures that operate on that data. The procedures are typically called methods or operations . 面向对象的程序由对象组成。一个对象包含数据和操作这些数据的过程。这些过程通常被称为方法或操作。在这个定义下，Rust 是面向对象的：结构体和枚举包含数据而 impl 块提供了在结构体和枚举之上的方法。虽然带有方法的结构体和枚举并不被称为对象，但是它们提供了与对象相同的功能，参考 The Gang of Four 中对象的定义。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象语言的特点 » 对象包含数据和行为","id":"325","title":"对象包含数据和行为"},"326":{"body":"另一个通常与面向对象编程关联的概念是封装（ encapsulation ）：一个对象的实现细节对使用该对象的代码不可访问。因此，对象交互的唯一方式是通过其公共 API；使用对象的代码不应能直接触及对象的内部并改变数据或行为。这使得程序员能够更改和重构一个对象的内部实现，而无需改变使用该对象的代码。我们在第 7 章讨论了如何控制封装：我们可以使用 pub 关键字来决定代码中的哪些模块、类型、函数和方法是公有的，而默认情况下其他所有内容都是私有的。例如，我们可以定义一个 AveragedCollection 结构体，其中有一个存有 Vec<i32> 的字段。该结构体还可以有一个字段存储其平均值，以便需要时取用。示例 17-1 给出了 AveragedCollection 结构体的定义：文件名：src/lib.rs pub struct AveragedCollection { list: Vec<i32>, average: f64,\n} 示例 17-1: AveragedCollection 结构体维护了一个整型列表及其所有元素的平均值。该结构体被标记为 pub，这样其他代码就可以使用它，但结构体内的字段保持私有。这在这种情况下很重要，因为我们想确保每当列表中添加或删除值时，平均值也会更新。我们通过实现结构体上的 add、remove 和 average 方法来做到这一点，如示例 17-2 所示：文件名：src/lib.rs # pub struct AveragedCollection {\n# list: Vec<i32>,\n# average: f64,\n# }\n# impl AveragedCollection { pub fn add(&mut self, value: i32) { self.list.push(value); self.update_average(); } pub fn remove(&mut self) -> Option<i32> { let result = self.list.pop(); match result { Some(value) => { self.update_average(); Some(value) } None => None, } } pub fn average(&self) -> f64 { self.average } fn update_average(&mut self) { let total: i32 = self.list.iter().sum(); self.average = total as f64 / self.list.len() as f64; }\n} 示例 17-2: 在 AveragedCollection 结构体上实现了 add、remove 和 average 公有方法公有方法 add、remove 和 average 是修改 AveragedCollection 实例的唯一方式。当使用 add 方法把一个元素加入到 list 或者使用 remove 方法来删除时，这些方法的实现同时会调用私有的 update_average 方法来更新 average 字段。 list 和 average 是私有的，所以没有其他方式来使得外部的代码直接向 list 增加或者删除元素，否则 list 改变时可能会导致 average 字段不同步。average 方法返回 average 字段的值，这使得外部的代码只能读取 average 而不能修改它。因为我们已经封装了 AveragedCollection 的实现细节，改动数据结构等内部实现非常简单。例如，可以使用 HashSet<i32> 代替 Vec<i32> 作为 list 字段的类型。只要 add、remove 和 average 这些公有方法的签名保持不变，使用 AveragedCollection 的代码就无需改变。如果我们将 list 设为公有，情况就未必如此： HashSet<i32> 和 Vec<i32> 使用不同的方法增加或移除项，所以如果外部代码直接修改 list ，很可能需要进行更改。如果封装被认为是面向对象语言所必要的特征，那么 Rust 满足这个要求。在代码中不同的部分控制 pub 的使用来封装实现细节。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象语言的特点 » 封装隐藏了实现细节","id":"326","title":"封装隐藏了实现细节"},"327":{"body":"继承（ Inheritance ）是一种机制：一个对象可以从另一个对象的定义中继承元素，从而获得父对象的数据和行为，无需再次定义。如果一种语言必须具有继承才能被认为是面向对象语言，那么 Rust 不是其中之一。Rust 不支持定义一个结构体时继承父结构体的字段和方法，除非使用宏。然而，如果您习惯于在编程过程中使用继承，那么根据运用继承的原因，Rust 提供了其他解决方案。选择继承有两个主要的原因。其一是代码复用：您可以为一种类型实现特定的行为，继承可将其复用到不同的类型上。在 Rust 代码中可以使用默认 trait 方法实现来进行有限的代码复用，就像示例 10-14 中在 Summary trait 上增加的 summarize 方法的默认实现。任何实现了 Summary trait 的类型都可以使用 summarize 方法而无须进一步实现。这类似于父类有一个方法的实现，继承的子类也拥有这个方法的实现。当实现 Summary trait 时也可以选择覆盖 summarize 的默认实现，这类似于子类覆盖从父类继承方法的实现。其二与类型系统有关：子类型可以用于父类型被使用的地方。这也被称为多态（ polymorphism ）：如果多个对象共享某些特征，可以在运行时将它们互相替代。多态（Polymorphism）对很多人来说，多态性与继承同义。但它实际上是一个更广义的概念，指的是可以处理多种类型数据的代码。对继承而言，这些类型通常是子类。 Rust 使用泛型来抽象不同可能的类型，并通过 trait bounds 来约束这些类型所必须提供的内容。这有时被称为 bounded parametric polymorphism 。作为一种语言设计的解决方案，继承在许多新的编程语言中逐渐不被青睐，因为它经常有分享过多代码的风险。子类不应总是共享父类的所有特征，但是继承始终如此。它还引入了在子类上调用方法的可能性，这些方法可能没有意义，或因为方法不适用于子类而导致错误。此外，一些语言只允许单一继承（意味着子类只能从一个类继承），进一步限制了程序设计的灵活性。出于这些原因，Rust 使用 trait 对象而非继承。接下来我们会讨论 Rust 如何使用 trait 对象实现多态性。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象语言的特点 » 继承，作为类型系统与代码共享","id":"327","title":"继承，作为类型系统与代码共享"},"328":{"body":"ch18-02-trait-objects.md commit 96d4b0ec1c5e019b85604c33ceee68b3e2669d40 在第八章中，我们谈到了 vector 只能存储同种类型元素的局限。示例 8-9 中提供了一个替代方案，通过定义 SpreadsheetCell 枚举，来储存整型、浮点型或文本类型的成员。这意味着，我们可以在每个单元中储存不同类型的数据，并仍能拥有一个代表一排单元的 vector。只要我们需存储的值由一组固定的类型组成，并且在代码编译时就知道具体会有哪些类型，那么这种使用枚举的办法是完全可行的。然而有时我们希望库用户在特定情况下能够扩展有效的类型集合。为了展示如何实现这一点，这里将创建一个图形用户接口（Graphical User Interface，GUI）工具的例子，它通过遍历列表并调用每一个项目的 draw 方法来将其绘制到屏幕上 —— 此乃一个 GUI 工具的常见技术。我们将要创建一个叫做 gui 的库 crate，它含一个 GUI 库的结构。这个 GUI 库包含一些可供开发者使用的类型，比如 Button 或 TextField。在此之上，gui 的用户希望创建自定义的可以绘制于屏幕上的类型：比如，一个程序员可能会增加 Image，另一个可能会增加 SelectBox。这个例子中并不会实现一个功能完善的 GUI 库，不过会展示其中各个部分是如何结合在一起的。编写库的时候，我们不可能知晓并定义所有其他程序员希望创建的类型。我们所知晓的是 gui 需要记录一系列不同类型的值，并需要能够对其中每一个值调用 draw 方法。这里无需知道调用 draw 方法时具体会发生什么，只要该值会有那个方法可供我们调用。在拥有继承的语言中，可以定义一个名为 Component 的类，该类上有一个 draw 方法。其他的类比如 Button、Image 和 SelectBox 会从 Component 派生并因此继承 draw 方法。它们各自都可以覆盖 draw 方法来定义自己的行为，但是框架会把所有这些类型当作是 Component 的实例，并在其上调用 draw。不过 Rust 并没有继承，我们得另寻出路。","breadcrumbs":"Rust 的面向对象编程特性 » 顾及不同类型值的 trait 对象 » 顾及不同类型值的 trait 对象","id":"328","title":"顾及不同类型值的 trait 对象"},"329":{"body":"为了实现 gui 所期望的行为，让我们定义一个 Draw trait，其中包含名为 draw 的方法。接着可以定义一个存放 trait 对象（ trait object ）的 vector。trait 对象指向一个实现了我们指定 trait 的类型的实例，以及一个用于在运行时查找该类型的 trait 方法的表。我们通过指定某种指针来创建 trait 对象，例如 & 引用或 Box<T> 智能指针，还有 dyn keyword，以及指定相关的 trait（第二十章 “动态大小类型和 Sized trait” 部分会介绍 trait 对象必须使用指针的原因）。我们可以使用 trait 对象代替泛型或具体类型。任何使用 trait 对象的位置，Rust 的类型系统会在编译时确保任何在此上下文中使用的值会实现其 trait 对象的 trait。如此便无需在编译时就知晓所有可能的类型。之前提到过，Rust 刻意不将结构体与枚举称为 “对象”，以便与其他语言中的对象相区别。在结构体或枚举中，结构体字段中的数据和 impl 块中的行为是分开的，不同于其他语言中将数据和行为组合进一个称为对象的概念中。trait 对象将数据和行为两者相结合，从这种意义上说则其更类似其他语言中的对象。不过 trait 对象不同于传统的对象，因为不能向 trait 对象增加数据。trait 对象并不像其他语言中的对象那么通用：其（trait 对象）具体的作用是允许对通用行为进行抽象。示例 17-3 展示了如何定义一个带有 draw 方法的 trait Draw：文件名：src/lib.rs pub trait Draw { fn draw(&self);\n} 示例 17-3：Draw trait 的定义因为第十章已经讨论过如何定义 trait，其语法看起来应该比较眼熟。接下来就是新内容了：示例 17-4 定义了一个存放了名叫 components 的 vector 的结构体 Screen。这个 vector 的类型是 Box<dyn Draw>，此为一个 trait 对象：它是 Box 中任何实现了 Draw trait 的类型的替身。文件名：src/lib.rs # pub trait Draw {\n# fn draw(&self);\n# }\n# pub struct Screen { pub components: Vec<Box<dyn Draw>>,\n} 示例 17-4: 一个 Screen 结构体的定义，它带有一个字段 components，其包含实现了 Draw trait 的 trait 对象的 vector 在 Screen 结构体上，我们将定义一个 run 方法，该方法会对其 components 上的每一个组件调用 draw 方法，如示例 17-5 所示：文件名：src/lib.rs # pub trait Draw {\n# fn draw(&self);\n# }\n# # pub struct Screen {\n# pub components: Vec<Box<dyn Draw>>,\n# }\n# impl Screen { pub fn run(&self) { for component in self.components.iter() { component.draw(); } }\n} 示例 17-5：在 Screen 上实现一个 run 方法，该方法在每个 component 上调用 draw 方法这与定义使用了带有 trait bound 的泛型类型参数的结构体不同。泛型类型参数一次只能替代一个具体类型，而 trait 对象则允许在运行时替代多种具体类型。例如，可以定义 Screen 结构体来使用泛型和 trait bound，如示例 17-6 所示：文件名：src/lib.rs # pub trait Draw {\n# fn draw(&self);\n# }\n# pub struct Screen<T: Draw> { pub components: Vec<T>,\n} impl<T> Screen<T>\nwhere T: Draw,\n{ pub fn run(&self) { for component in self.components.iter() { component.draw(); } }\n} 示例 17-6: 一种 Screen 结构体的替代实现，其 run 方法使用泛型和 trait bound 这限制了 Screen 实例必须拥有一个全是 Button 类型或者全是 TextField 类型的组件列表。如果只需要同质（相同类型）集合，则倾向于使用泛型和 trait bound，因为其定义会在编译时采用具体类型进行单态化。另一方面，通过使用 trait 对象的方法，一个 Screen 实例可以存放一个既能包含 Box<Button>，也能包含 Box<TextField> 的 Vec<T>。让我们看看它是如何工作的，接着会讲到其运行时性能影响。","breadcrumbs":"Rust 的面向对象编程特性 » 顾及不同类型值的 trait 对象 » 定义通用行为的 trait","id":"329","title":"定义通用行为的 trait"},"33":{"body":"猜数字程序的第一部分请求和处理用户输入，并检查输入是否符合预期的格式。首先，我们会允许玩家输入一个猜测。在 src/main.rs 中输入示例 2-1 中的代码。文件名：src/main.rs use std::io; fn main() { println!(\"Guess the number!\"); println!(\"Please input your guess.\"); let mut guess = String::new(); io::stdin() .read_line(&mut guess) .expect(\"Failed to read line\"); println!(\"You guessed: {}\", guess);\n} 示例 2-1：获取用户猜测并打印的代码这些代码包含很多信息，我们一行一行地过一遍。为了获取用户输入并打印结果作为输出，我们需要将 io 输入/输出库引入当前作用域。io 库来自于标准库，也被称为 std： use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } 默认情况下，Rust 设定了若干个会自动导入到每个程序作用域中的标准库内容，这组内容被称为预导入（prelude）内容。你可以在标准库文档中查看预导入的所有内容。如果你需要的类型不在预导入内容中，就必须使用 use 语句显式地将其引入作用域。std::io 库提供很多有用的功能，包括接收用户输入的功能。如第一章所提及，main 函数是程序的入口点： # use std::io;\n# fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } fn 语法声明了一个新函数，小括号 () 表明没有参数，大括号 { 作为函数体的开始。第一章也提及了 println! 是一个在屏幕上打印字符串的宏： # use std::io;\n# # fn main() { println!(\"Guess the number!\"); println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } 这些代码仅仅打印提示，介绍游戏的内容然后请求用户输入。","breadcrumbs":"写个猜数字游戏 » 处理一次猜测","id":"33","title":"处理一次猜测"},"330":{"body":"现在来增加一些实现了 Draw trait 的类型。我们将提供 Button 类型。再一次重申，真正实现 GUI 库超出了本书的范畴，所以 draw 方法体中不会有任何有意义的实现。为了想象一下这个实现看起来像什么，一个 Button 结构体可能会拥有 width、height 和 label 字段，如示例 17-7 所示：文件名：src/lib.rs # pub trait Draw {\n# fn draw(&self);\n# }\n# # pub struct Screen {\n# pub components: Vec<Box<dyn Draw>>,\n# }\n# # impl Screen {\n# pub fn run(&self) {\n# for component in self.components.iter() {\n# component.draw();\n# }\n# }\n# }\n# pub struct Button { pub width: u32, pub height: u32, pub label: String,\n} impl Draw for Button { fn draw(&self) { // code to actually draw a button }\n} 示例 17-7: 一个实现了 Draw trait 的 Button 结构体在 Button 上的 width、height 和 label 字段会和其他组件不同，比如 TextField 可能有 width、height、label 以及 placeholder 字段。每一个我们希望能在屏幕上绘制的类型都会使用不同的代码来实现 Draw trait 的 draw 方法来定义如何绘制特定的类型，像这里的 Button 类型（如上提到的并不包含任何实际的 GUI 代码）。除了实现 Draw trait 之外，比如 Button 还可能有另一个包含按钮点击如何响应的方法的 impl 块。这类方法并不适用于像 TextField 这样的类型。如果一些库的使用者决定实现一个包含 width、height 和 options 字段的结构体 SelectBox，并且也为其实现了 Draw trait，如示例 17-8 所示：文件名：src/main.rs use gui::Draw; struct SelectBox { width: u32, height: u32, options: Vec<String>,\n} impl Draw for SelectBox { fn draw(&self) { // code to actually draw a select box }\n}\n# # fn main() {} 示例 17-8: 另一个使用 gui 的 crate 中，在 SelectBox 结构体上实现 Draw trait 库使用者现在可以在他们的 main 函数中创建一个 Screen 实例。至此可以通过将 SelectBox 和 Button 放入 Box<T> 转变为 trait 对象再放入 Screen 实例中。接着可以调用 Screen 的 run 方法，它会调用每个组件的 draw 方法。示例 17-9 展示了这个实现：文件名：src/main.rs # use gui::Draw;\n# # struct SelectBox {\n# width: u32,\n# height: u32,\n# options: Vec<String>,\n# }\n# # impl Draw for SelectBox {\n# fn draw(&self) {\n# // code to actually draw a select box\n# }\n# }\n# use gui::{Button, Screen}; fn main() { let screen = Screen { components: vec![ Box::new(SelectBox { width: 75, height: 10, options: vec![ String::from(\"Yes\"), String::from(\"Maybe\"), String::from(\"No\"), ], }), Box::new(Button { width: 50, height: 10, label: String::from(\"OK\"), }), ], }; screen.run();\n} 示例 17-9: 使用 trait 对象来存储实现了相同 trait 的不同类型的值当编写库的时候，我们不知道何人会在何时增加 SelectBox 类型，不过 Screen 的实现能够操作并绘制这个新类型，因为 SelectBox 实现了 Draw trait，这意味着它实现了 draw 方法。这个概念 —— 只关心值所反映的信息而不是其具体类型 —— 类似于动态类型语言中称为鸭子类型（ duck typing ）的概念：如果它走起来像一只鸭子，叫起来像一只鸭子，那么它就是一只鸭子！在示例 17-5 中 Screen 上的 run 实现中，run 并不需要知道各个组件的具体类型是什么。它并不检查组件是 Button 或者 SelectBox 的实例。通过指定 Box<dyn Draw> 作为 components vector 中值的类型，我们就定义了 Screen 为需要可以在其上调用 draw 方法的值。使用 trait 对象和 Rust 类型系统来进行类似鸭子类型操作的优势是无需在运行时检查一个值是否实现了特定方法或者担心在调用时因为值没有实现方法而产生错误。如果值没有实现 trait 对象所需的 trait 则 Rust 不会编译这些代码。例如，示例 17-10 展示了当创建一个使用 String 做为其组件的 Screen 时发生的情况：文件名：src/main.rs use gui::Screen; fn main() { let screen = Screen { components: vec![Box::new(String::from(\"Hi\"))], }; screen.run();\n} 示例 17-10: 尝试使用一种没有实现 trait 对象的 trait 的类型我们会遇到这个错误，因为 String 没有实现 rust_gui::Draw trait： $ cargo run Compiling gui v0.1.0 (file:///projects/gui)\nerror[E0277]: the trait bound `String: Draw` is not satisfied --> src/main.rs:5:26 |\n5 | components: vec![Box::new(String::from(\"Hi\"))], | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Draw` is not implemented for `String` | = help: the trait `Draw` is implemented for `Button` = note: required for the cast from `Box<String>` to `Box<dyn Draw>` For more information about this error, try `rustc --explain E0277`.\nerror: could not compile `gui` (bin \"gui\") due to 1 previous error 这告诉了我们，要么是我们传递了并不希望传递给 Screen 的类型并应该提供其他类型，要么应该在 String 上实现 Draw 以便 Screen 可以调用其上的 draw。","breadcrumbs":"Rust 的面向对象编程特性 » 顾及不同类型值的 trait 对象 » 实现 trait","id":"330","title":"实现 trait"},"331":{"body":"回忆一下第十章 “泛型代码的性能” 部分讨论过的，当对泛型使用 trait bound 时编译器所执行的单态化处理：编译器为每一个被泛型类型参数代替的具体类型生成了函数和方法的非泛型实现。单态化产生的代码在执行静态分发（ static dispatch ）。静态分发发生于编译器在编译时就知晓调用了什么方法的时候。这与动态分发（ dynamic dispatch ）相对，这时编译器在编译时无法知晓调用了什么方法。在动态分发的场景下，编译器会生成负责在运行时确定该调用什么方法的代码。当使用 trait 对象时，Rust 必须使用动态分发。编译器无法知晓所有可能用于 trait 对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust 在运行时使用 trait 对象中的指针来知晓需要调用哪个方法。动态分发也阻止编译器有选择的内联方法代码，这会相应的禁用一些优化。尽管在编写示例 17-5 和可以支持示例 17-9 中的代码的过程中确实获得了额外的灵活性，但仍然需要权衡取舍。","breadcrumbs":"Rust 的面向对象编程特性 » 顾及不同类型值的 trait 对象 » trait 对象执行动态分发","id":"331","title":"trait 对象执行动态分发"},"332":{"body":"ch18-03-oo-design-patterns.md commit 937784b8708c24314707378ad42faeb12a334bbd 状态模式（ state pattern ）是一个面向对象设计模式。该模式的关键在于定义一系列值的内含状态。这些状态体现为一系列的状态对象，同时值的行为随着其内部状态而改变。我们将编写一个博客发布结构体的例子，它拥有一个包含其状态的字段，这是一个有着 \"draft\"、\"review\" 或 \"published\" 的状态对象状态对象共享功能：当然，在 Rust 中使用结构体和 trait 而不是对象和继承。每一个状态对象负责其自身的行为，以及该状态何时应当转移至另一个状态。持有一个状态对象的值对于不同状态的行为以及何时状态转移毫不知情。使用状态模式的优点在于，程序的业务需求改变时，无需改变值持有状态或者使用值的代码。我们只需更新某个状态对象中的代码来改变其规则，或者是增加更多的状态对象。首先我们将以一种更加传统的面向对象的方式实现状态模式，接着使用一种更 Rust 一点的方式。让我们使用状态模式增量式地实现一个发布博文的工作流以探索这个概念。这个博客的最终功能看起来像这样：博文从空白的草案开始。一旦草案完成，请求审核博文。一旦博文过审，它将被发表。只有被发表的博文的内容会被打印，这样就不会意外打印出没有被审核的博文的文本。任何其他对博文的修改尝试都是没有作用的。例如，如果尝试在请求审核之前通过一个草案博文，博文应该保持未发布的状态。示例 17-11 展示这个工作流的代码形式：这是一个我们将要在一个叫做 blog 的库 crate 中实现的 API 的示例。这段代码还不能编译，因为还未实现 blog。文件名：src/main.rs use blog::Post; fn main() { let mut post = Post::new(); post.add_text(\"I ate a salad for lunch today\"); assert_eq!(\"\", post.content()); post.request_review(); assert_eq!(\"\", post.content()); post.approve(); assert_eq!(\"I ate a salad for lunch today\", post.content());\n} 示例 17-11: 展示了 blog crate 期望行为的代码我们希望允许用户使用 Post::new 创建一个新的博文草案。也希望能在草案阶段为博文编写一些文本。如果在审批之前尝试立刻获取博文的内容，不应该获取到任何文本因为博文仍然是草案。一个好的单元测试将是断言草案博文的 content 方法返回空字符串，不过我们并不准备为这个例子编写单元测试。接下来，我们希望能够请求审核博文，而在等待审核的阶段 content 应该仍然返回空字符串。最后当博文审核通过，它应该被发表，这意味着当调用 content 时博文的文本将被返回。注意我们与 crate 交互的唯一的类型是 Post。这个类型会使用状态模式并会存放处于三种博文所可能的状态之一的值 —— 草案，等待审核和发布。状态上的改变由 Post 类型内部进行管理。状态依库用户对 Post 实例调用的方法而改变，但是不能直接管理状态变化。这也意味着用户不会在状态上犯错，比如在过审前发布博文。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 面向对象设计模式的实现","id":"332","title":"面向对象设计模式的实现"},"333":{"body":"让我们开始实现这个库吧！我们知道需要一个公有 Post 结构体来存放一些文本，所以让我们从结构体的定义和一个创建 Post 实例的公有关联函数 new 开始，如示例 17-12 所示。还需定义一个私有 trait State。 Post 将在私有字段 state 中存放一个 Option<T> 类型的 trait 对象 Box<dyn State>。稍后将会看到为何 Option<T> 是必须的。文件名：src/lib.rs pub struct Post { state: Option<Box<dyn State>>, content: String,\n} impl Post { pub fn new() -> Post { Post { state: Some(Box::new(Draft {})), content: String::new(), } }\n} trait State {} struct Draft {} impl State for Draft {} 示例 17-12: Post 结构体的定义和新建 Post 实例的 new 函数，State trait 和结构体 Draft State trait 定义了所有不同状态的博文所共享的行为，这个状态对象是 Draft、PendingReview 和 Published，它们都会实现 State 状态。现在这个 trait 并没有任何方法，同时开始将只定义 Draft 状态因为这是我们希望博文的初始状态。当创建新的 Post 时，我们将其 state 字段设置为一个存放了 Box 的 Some 值。这个 Box 指向一个 Draft 结构体新实例。这确保了无论何时新建一个 Post 实例，它都会从草案开始。因为 Post 的 state 字段是私有的，也就无法创建任何其他状态的 Post 了！。Post::new 函数中将 content 设置为新建的空 String。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 定义 Post 并新建一个草案状态的实例","id":"333","title":"定义 Post 并新建一个草案状态的实例"},"334":{"body":"在示例 17-11 中，展示了我们希望能够调用一个叫做 add_text 的方法并向其传递一个 &str 来将文本增加到博文的内容中。选择实现为一个方法而不是将 content 字段暴露为 pub 。这意味着之后可以实现一个方法来控制 content 字段如何被读取。add_text 方法是非常直观的，让我们在示例 17-13 的 impl Post 块中增加一个实现：文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# impl Post { // --snip--\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# pub fn add_text(&mut self, text: &str) { self.content.push_str(text); }\n}\n# # trait State {}\n# # struct Draft {}\n# # impl State for Draft {} 示例 17-13: 实现方法 add_text 来向博文的 content 增加文本 add_text 获取一个 self 的可变引用，因为需要改变调用 add_text 的 Post 实例。接着调用 content 中的 String 的 push_str 并传递 text 参数来保存到 content 中。这不是状态模式的一部分，因为它的行为并不依赖博文所处的状态。add_text 方法完全不与 state 状态交互，不过这是我们希望支持的行为的一部分。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 存放博文内容的文本","id":"334","title":"存放博文内容的文本"},"335":{"body":"即使调用 add_text 并向博文增加一些内容之后，我们仍然希望 content 方法返回一个空字符串 slice，因为博文仍然处于草案状态，如示例 17-11 的第 8 行所示。现在让我们使用能满足要求的最简单的方式来实现 content 方法：总是返回一个空字符串 slice。当实现了将博文状态改为发布的能力之后将改变这一做法。但是目前博文只能是草案状态，这意味着其内容应该总是空的。示例 17-14 展示了这个占位符实现：文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# impl Post { // --snip--\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# # pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# pub fn content(&self) -> &str { \"\" }\n}\n# # trait State {}\n# # struct Draft {}\n# # impl State for Draft {} 列表 17-14: 增加一个 Post 的 content 方法的占位实现，它总是返回一个空字符串 slice 通过增加这个 content 方法，示例 17-11 中直到第 8 行的代码能如期运行。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 确保博文草案的内容是空的","id":"335","title":"确保博文草案的内容是空的"},"336":{"body":"接下来需要增加请求审核博文的功能，这应当将其状态由 Draft 改为 PendingReview。示例 17-15 展示了这个代码：文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# impl Post { // --snip--\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# # pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# # pub fn content(&self) -> &str {\n# \"\"\n# }\n# pub fn request_review(&mut self) { if let Some(s) = self.state.take() { self.state = Some(s.request_review()) } }\n} trait State { fn request_review(self: Box<Self>) -> Box<dyn State>;\n} struct Draft {} impl State for Draft { fn request_review(self: Box<Self>) -> Box<dyn State> { Box::new(PendingReview {}) }\n} struct PendingReview {} impl State for PendingReview { fn request_review(self: Box<Self>) -> Box<dyn State> { self }\n} 示例 17-15: 实现 Post 和 State trait 的 request_review 方法这里为 Post 增加一个获取 self 可变引用的公有方法 request_review。接着在 Post 的当前状态下调用内部的 request_review 方法，并且第二个 request_review 方法会消费当前的状态并返回一个新状态。这里给 State trait 增加了 request_review 方法；所有实现了这个 trait 的类型现在都需要实现 request_review 方法。注意不同于使用 self、 &self 或者 &mut self 作为方法的第一个参数，这里使用了 self: Box<Self>。这个语法意味着该方法只可在持有这个类型的 Box 上被调用。这个语法获取了 Box<Self> 的所有权使老状态无效化，以便 Post 的状态值可转换为一个新状态。为了消费老状态，request_review 方法需要获取状态值的所有权。这就是 Post 的 state 字段中 Option 的来历：调用 take 方法将 state 字段中的 Some 值取出并留下一个 None，因为 Rust 不允许结构体实例中存在值为空的字段。这使得我们将 state 的值移出 Post 而不是借用它。接着我们将博文的 state 值设置为这个操作的结果。我们需要将 state 临时设置为 None 来获取 state 值，即老状态的所有权，而不是使用 self.state = self.state.request_review(); 这样的代码直接更新状态值。这确保了当 Post 被转换为新状态后不能再使用老 state 值。 Draft 的 request_review 方法需要返回一个新的，装箱的 PendingReview 结构体的实例，其用来代表博文处于等待审核状态。结构体 PendingReview 同样也实现了 request_review 方法，不过它不进行任何状态转换。相反它返回自身，因为当我们请求审核一个已经处于 PendingReview 状态的博文，它应该继续保持 PendingReview 状态。现在我们能看出状态模式的优势了：无论 state 是何值，Post 的 request_review 方法都是一样的。每个状态只负责它自己的规则。我们将继续保持 Post 的 content 方法实现不变，返回一个空字符串 slice。现在我们可以拥有 PendingReview 状态和 Draft 状态的 Post 了，不过我们希望在 PendingReview 状态下 Post 也有相同的行为。现在示例 17-11 中直到 10 行的代码是可以执行的！","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 请求审核博文来改变其状态","id":"336","title":"请求审核博文来改变其状态"},"337":{"body":"approve 方法将与 request_review 方法类似：它会将 state 设置为审核通过时应处于的状态，如示例 17-16 所示。文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# impl Post { // --snip--\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# # pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# # pub fn content(&self) -> &str {\n# \"\"\n# }\n# # pub fn request_review(&mut self) {\n# if let Some(s) = self.state.take() {\n# self.state = Some(s.request_review())\n# }\n# }\n# pub fn approve(&mut self) { if let Some(s) = self.state.take() { self.state = Some(s.approve()) } }\n} trait State { fn request_review(self: Box<Self>) -> Box<dyn State>; fn approve(self: Box<Self>) -> Box<dyn State>;\n} struct Draft {} impl State for Draft { // --snip--\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# Box::new(PendingReview {})\n# }\n# fn approve(self: Box<Self>) -> Box<dyn State> { self }\n} struct PendingReview {} impl State for PendingReview { // --snip--\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# fn approve(self: Box<Self>) -> Box<dyn State> { Box::new(Published {}) }\n} struct Published {} impl State for Published { fn request_review(self: Box<Self>) -> Box<dyn State> { self } fn approve(self: Box<Self>) -> Box<dyn State> { self }\n} 示例 17-16: 为 Post 和 State trait 实现 approve 方法这里为 State trait 增加了 approve 方法，并新增了一个实现了 State 的结构体，Published 状态。类似于 PendingReview 中 request_review 的工作方式，如果对 Draft 调用 approve 方法，并没有任何效果，因为它会返回 self。当对 PendingReview 调用 approve 时，它返回一个新的、装箱的 Published 结构体的实例。Published 结构体实现了 State trait，同时对于 request_review 和 approve 两方法来说，它返回自身，因为在这两种情况博文应该保持 Published 状态。现在需要更新 Post 的 content 方法。我们希望 content 根据 Post 的当前状态返回值，所以需要 Post 代理一个定义于 state 上的 content 方法，如实例 17-17 所示：文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# impl Post { // --snip--\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# # pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# pub fn content(&self) -> &str { self.state.as_ref().unwrap().content(self) } // --snip--\n# # pub fn request_review(&mut self) {\n# if let Some(s) = self.state.take() {\n# self.state = Some(s.request_review())\n# }\n# }\n# # pub fn approve(&mut self) {\n# if let Some(s) = self.state.take() {\n# self.state = Some(s.approve())\n# }\n# }\n}\n# # trait State {\n# fn request_review(self: Box<Self>) -> Box<dyn State>;\n# fn approve(self: Box<Self>) -> Box<dyn State>;\n# }\n# # struct Draft {}\n# # impl State for Draft {\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# Box::new(PendingReview {})\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# }\n# # struct PendingReview {}\n# # impl State for PendingReview {\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# Box::new(Published {})\n# }\n# }\n# # struct Published {}\n# # impl State for Published {\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# } 示例 17-17: 更新 Post 的 content 方法来委托调用 State 的 content 方法因为目标是将所有像这样的规则保持在实现了 State 的结构体中，我们将调用 state 中的值的 content 方法并传递博文实例（也就是 self）作为参数。接着返回 state 值的 content 方法的返回值。这里调用 Option 的 as_ref 方法是因为需要 Option 中值的引用而不是获取其所有权。因为 state 是一个 Option<Box<dyn State>>，调用 as_ref 会返回一个 Option<&Box<dyn State>>。如果不调用 as_ref，将会得到一个错误，因为不能将 state 移动出借用的 &self 函数参数。接着调用 unwrap 方法，这里我们知道它永远也不会 panic，因为 Post 的所有方法都确保在它们返回时 state 会有一个 Some 值。这就是一个第十二章 “当我们比编译器知道更多的情况” 部分讨论过的我们知道 None 是不可能的而编译器却不能理解的情况。接着我们就有了一个 &Box<dyn State>，当调用其 content 时，Deref 强制转换会作用于 & 和 Box ，这样最终会调用实现了 State trait 的类型的 content 方法。这意味着需要为 State trait 定义增加 content，这也是放置根据所处状态返回什么内容的逻辑的地方，如示例 17-18 所示：文件名：src/lib.rs # pub struct Post {\n# state: Option<Box<dyn State>>,\n# content: String,\n# }\n# # impl Post {\n# pub fn new() -> Post {\n# Post {\n# state: Some(Box::new(Draft {})),\n# content: String::new(),\n# }\n# }\n# # pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# # pub fn content(&self) -> &str {\n# self.state.as_ref().unwrap().content(self)\n# }\n# # pub fn request_review(&mut self) {\n# if let Some(s) = self.state.take() {\n# self.state = Some(s.request_review())\n# }\n# }\n# # pub fn approve(&mut self) {\n# if let Some(s) = self.state.take() {\n# self.state = Some(s.approve())\n# }\n# }\n# }\n# trait State { // --snip--\n# fn request_review(self: Box<Self>) -> Box<dyn State>;\n# fn approve(self: Box<Self>) -> Box<dyn State>;\n# fn content<'a>(&self, post: &'a Post) -> &'a str { \"\" }\n} // --snip--\n# # struct Draft {}\n# # impl State for Draft {\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# Box::new(PendingReview {})\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# }\n# # struct PendingReview {}\n# # impl State for PendingReview {\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# Box::new(Published {})\n# }\n# }\n# struct Published {} impl State for Published { // --snip--\n# fn request_review(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# # fn approve(self: Box<Self>) -> Box<dyn State> {\n# self\n# }\n# fn content<'a>(&self, post: &'a Post) -> &'a str { &post.content }\n} 示例 17-18: 为 State trait 增加 content 方法这里增加了一个 content 方法的默认实现来返回一个空字符串 slice。这意味着无需为 Draft 和 PendingReview 结构体实现 content 了。Published 结构体会覆盖 content 方法并会返回 post.content 的值。注意这个方法需要生命周期注解，如第十章所讨论的。这里获取 post 的引用作为参数，并返回 post 一部分的引用，所以返回的引用的生命周期与 post 参数相关。现在示例完成了 —— 现在示例 17-11 中所有的代码都能工作！我们通过发布博文工作流的规则实现了状态模式。围绕这些规则的逻辑都存在于状态对象中而不是分散在 Post 之中。为什么不用枚举？你可能会好奇为什么不用包含不同可能的博文状态的 enum 作为变量。这确实是一个可能的方案，尝试实现并对比最终结果来看看哪一种更适合你！使用枚举的一个缺点是每一个检查枚举值的地方都需要一个 match 表达式或类似的代码来处理所有可能的成员。这相比 trait 对象模式可能显得更重复。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 增加改变 content 行为的 approve 方法","id":"337","title":"增加改变 content 行为的 approve 方法"},"338":{"body":"我们展示了 Rust 是能够实现面向对象的状态模式的，以便能根据博文所处的状态来封装不同类型的行为。Post 的方法并不知道这些不同类型的行为。通过这种组织代码的方式，要找到所有已发布博文的不同行为只需查看一处代码：Published 的 State trait 的实现。如果要创建一个不使用状态模式的替代实现，则可能会在 Post 的方法中，或者甚至于在 main 代码中用到 match 语句，来检查博文状态并在这里改变其行为。这意味着需要查看很多位置来理解处于发布状态的博文的所有逻辑！这在增加更多状态时会变得更糟：每一个 match 语句都会需要另一个分支。对于状态模式来说，Post 的方法和使用 Post 的位置无需 match 语句，同时增加新状态只涉及到增加一个新 struct 和为其实现 trait 的方法。这个实现易于扩展增加更多功能。为了体会使用此模式维护代码的简洁性，请尝试如下一些建议：增加 reject 方法将博文的状态从 PendingReview 变回 Draft 在将状态变为 Published 之前需要两次 approve 调用只允许博文处于 Draft 状态时增加文本内容。提示：让状态对象负责内容可能发生什么改变，但不负责修改 Post。状态模式的一个缺点是因为状态实现了状态之间的转换，一些状态会相互联系。如果在 PendingReview 和 Published 之间增加另一个状态，比如 Scheduled，则不得不修改 PendingReview 中的代码来转移到 Scheduled。如果 PendingReview 无需因为新增的状态而改变就更好了，不过这意味着切换到另一种设计模式。另一个缺点是我们会发现一些重复的逻辑。为了消除它们，可以尝试为 State trait 中返回 self 的 request_review 和 approve 方法增加默认实现，不过这会违反对象安全性，因为 trait 不知道 self 具体是什么。我们希望能够将 State 作为一个 trait 对象，所以需要其方法是对象安全的。另一个重复是 Post 中 request_review 和 approve 这两个类似的实现。它们都委托调用了 state 字段中 Option 值的同一方法，并在结果中为 state 字段设置了新值。如果 Post 中的很多方法都遵循这个模式，我们可能会考虑定义一个宏来消除重复（查看第二十章的 “宏” 部分）。完全按照面向对象语言的定义实现这个模式并没有尽可能地利用 Rust 的优势。让我们看看一些代码中可以做出的修改，来将无效的状态和状态转移变为编译时错误。将状态和行为编码为类型我们将展示如何稍微反思状态模式来进行一系列不同的权衡取舍。不同于完全封装状态和状态转移使得外部代码对其毫不知情，我们将状态编码进不同的类型。如此，Rust 的类型检查就会将任何在只能使用发布博文的地方使用草案博文的尝试变为编译时错误。让我们考虑一下示例 17-11 中 main 的第一部分：文件名：src/main.rs # use blog::Post;\n# fn main() { let mut post = Post::new(); post.add_text(\"I ate a salad for lunch today\"); assert_eq!(\"\", post.content());\n# # post.request_review();\n# assert_eq!(\"\", post.content());\n# # post.approve();\n# assert_eq!(\"I ate a salad for lunch today\", post.content());\n} 我们仍然希望能够使用 Post::new 创建一个新的草案博文，并能够增加博文的内容。不过不同于存在一个草案博文时返回空字符串的 content 方法，我们将使草案博文完全没有 content 方法。这样如果尝试获取草案博文的内容，将会得到一个方法不存在的编译错误。这使得我们不可能在生产环境意外显示出草案博文的内容，因为这样的代码甚至就不能编译。示例 17-19 展示了 Post 结构体、DraftPost 结构体以及各自的方法的定义：文件名：src/lib.rs pub struct Post { content: String,\n} pub struct DraftPost { content: String,\n} impl Post { pub fn new() -> DraftPost { DraftPost { content: String::new(), } } pub fn content(&self) -> &str { &self.content }\n} impl DraftPost { pub fn add_text(&mut self, text: &str) { self.content.push_str(text); }\n} 示例 17-19: 带有 content 方法的 Post 和没有 content 方法的 DraftPost Post 和 DraftPost 结构体都有一个私有的 content 字段来储存博文的文本。这些结构体不再有 state 字段因为我们将状态编码改为结构体类型。Post 将代表发布的博文，它有一个返回 content 的 content 方法。仍然有一个 Post::new 函数，不过不同于返回 Post 实例，它返回 DraftPost 的实例。现在不可能创建一个 Post 实例，因为 content 是私有的同时没有任何函数返回 Post。 DraftPost 上定义了一个 add_text 方法，这样就可以像之前那样向 content 增加文本，不过注意 DraftPost 并没有定义 content 方法！如此现在程序确保了所有博文都从草案开始，同时草案博文没有任何可供展示的内容。任何绕过这些限制的尝试都会产生编译错误。实现状态转移为不同类型的转换那么如何得到发布的博文呢？我们希望强制执行的规则是草案博文在可以发布之前必须被审核通过。等待审核状态的博文应该仍然不会显示任何内容。让我们通过增加另一个结构体 PendingReviewPost 来实现这个限制，在 DraftPost 上定义 request_review 方法来返回 PendingReviewPost，并在 PendingReviewPost 上定义 approve 方法来返回 Post，如示例 17-20 所示：文件名：src/lib.rs # pub struct Post {\n# content: String,\n# }\n# # pub struct DraftPost {\n# content: String,\n# }\n# # impl Post {\n# pub fn new() -> DraftPost {\n# DraftPost {\n# content: String::new(),\n# }\n# }\n# # pub fn content(&self) -> &str {\n# &self.content\n# }\n# }\n# impl DraftPost { // --snip--\n# pub fn add_text(&mut self, text: &str) {\n# self.content.push_str(text);\n# }\n# pub fn request_review(self) -> PendingReviewPost { PendingReviewPost { content: self.content, } }\n} pub struct PendingReviewPost { content: String,\n} impl PendingReviewPost { pub fn approve(self) -> Post { Post { content: self.content, } }\n} 列表 17-20: PendingReviewPost 通过调用 DraftPost 的 request_review 创建，approve 方法将 PendingReviewPost 变为发布的 Post request_review 和 approve 方法获取 self 的所有权，因此会消费 DraftPost 和 PendingReviewPost 实例，并分别转换为 PendingReviewPost 和发布的 Post。这样在调用 request_review 之后就不会遗留任何 DraftPost 实例，后者同理。PendingReviewPost 并没有定义 content 方法，所以尝试读取其内容会导致编译错误，DraftPost 同理。因为唯一得到定义了 content 方法的 Post 实例的途径是调用 PendingReviewPost 的 approve 方法，而得到 PendingReviewPost 的唯一办法是调用 DraftPost 的 request_review 方法，现在我们就将发博文的工作流编码进了类型系统。这也意味着不得不对 main 做出一些小的修改。因为 request_review 和 approve 返回新实例而不是修改被调用的结构体，所以我们需要增加更多的 let post = 覆盖赋值来保存返回的实例。也不再能断言草案和等待审核的博文的内容为空字符串了，我们也不再需要它们：不能编译尝试使用这些状态下博文内容的代码。更新后的 main 的代码如示例 17-21 所示：文件名：src/main.rs use blog::Post; fn main() { let mut post = Post::new(); post.add_text(\"I ate a salad for lunch today\"); let post = post.request_review(); let post = post.approve(); assert_eq!(\"I ate a salad for lunch today\", post.content());\n} 示例 17-21: main 中使用新的博文工作流实现的修改不得不修改 main 来重新赋值 post 使得这个实现不再完全遵守面向对象的状态模式：状态间的转换不再完全封装在 Post 实现中。然而，得益于类型系统和编译时类型检查，我们得到了的是无效状态是不可能的！这确保了某些特定的 bug，比如显示未发布博文的内容，将在部署到生产环境之前被发现。尝试为示例 17-21 之后的 blog crate 实现这一部分开始所建议的任务来体会使用这个版本的代码是何感觉。注意在这个设计中一些需求可能已经完成了。即便 Rust 能够实现面向对象设计模式，也有其他像将状态编码进类型这样的模式存在。这些模式有着不同的权衡取舍。虽然你可能非常熟悉面向对象模式，重新思考这些问题来利用 Rust 提供的像在编译时避免一些 bug 这样有益功能。在 Rust 中面向对象模式并不总是最好的解决方案，因为 Rust 拥有像所有权这样的面向对象语言所没有的功能。","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 状态模式的权衡取舍","id":"338","title":"状态模式的权衡取舍"},"339":{"body":"阅读本章后，不管你是否认为 Rust 是一个面向对象语言，现在你都见识了 trait 对象是一个 Rust 中获取部分面向对象功能的方法。动态分发可以通过牺牲少量运行时性能来为你的代码提供一些灵活性。这些灵活性可以用来实现有助于代码可维护性的面向对象模式。Rust 也有像所有权这样不同于面向对象语言的功能。面向对象模式并不总是利用 Rust 优势的最好方式，但也是可用的选项。接下来，让我们看看另一个提供了多样灵活性的 Rust 功能：模式。贯穿全书的模式，我们已经和它们打过照面了，但并没有见识过它们的全部本领。让我们开始探索吧！","breadcrumbs":"Rust 的面向对象编程特性 » 面向对象设计模式的实现 » 总结","id":"339","title":"总结"},"34":{"body":"接下来，创建一个变量（ variable ）来储存用户输入，像这样： # use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } 现在程序开始变得有意思了！这一小行代码发生了很多事。我们使用 let 语句来创建变量。这里是另外一个例子： let apples = 5; 这行代码新建了一个叫做 apples 的变量并把它绑定到值 5 上。在 Rust 中，变量默认是不可变的，这意味着一旦我们给变量赋值，这个值就不再可以修改了。我们将会在第三章的 “变量与可变性” 部分详细讨论这个概念。下面的例子展示了如何在变量名前使用 mut 来使一个变量可变： let apples = 5; // 不可变\nlet mut bananas = 5; // 可变注意：// 语法开始一个注释，持续到行尾。Rust 忽略注释中的所有内容，第三章将会详细介绍注释。回到猜数字程序中。现在我们知道了 let mut guess 会引入一个叫做 guess 的可变变量。等号（=）告诉 Rust 我们现在想将某个值绑定在变量上。等号的右边是 guess 所绑定的值，它是 String::new 的结果，这个函数会返回一个 String 的新实例。 String 是一个标准库提供的字符串类型，它是 UTF-8 编码的可增长文本块。 ::new 那一行的 :: 语法表明 new 是 String 类型的一个关联函数（ associated function ）。关联函数是针对某个类型实现的函数，在这个例子中是 String。这个 new 函数创建了一个新的空字符串。你会发现许多类型上都有一个 new 函数，因为这是为某种类型创建新值的常用函数名。总的来说，let mut guess = String::new(); 这一行创建了一个可变变量，当前它绑定到一个新的 String 空实例上。","breadcrumbs":"写个猜数字游戏 » 使用变量储存值","id":"34","title":"使用变量储存值"},"340":{"body":"ch19-00-patterns.md commit 6fce661a0938aa0da06526e7b8f98fd7e67a222f 模式（ Patterns ）是 Rust 中特殊的语法，它用来匹配类型中的结构，无论类型是简单还是复杂。结合使用模式和 match 表达式以及其他结构可以提供更多对程序控制流的支配权。模式由如下一些内容组合而成：字面值解构的数组、枚举、结构体或者元组变量通配符占位符一些模式的例子包括x, (a, 3) 和 Some(Color::Red)。在模式为有效的上下文中，这些部分描述了数据的形状。接着可以用其匹配值来决定程序是否拥有正确的数据来运行特定部分的代码。我们通过将一些值与模式相比较来使用它。如果模式匹配这些值，我们对值部分进行相应处理。回忆一下第六章讨论 match 表达式时像硬币分类器那样使用模式。如果数据符合这个形状，就可以使用这些命名的片段。如果不符合，与该模式相关的代码则不会运行。本章是所有模式相关内容的参考。我们将涉及到使用模式的有效位置， refutable 与 irrefutable 模式的区别，和你可能会见到的不同类型的模式语法。在最后，你将会看到如何使用模式创建强大而简洁的代码。","breadcrumbs":"模式与模式匹配 » 模式与模式匹配","id":"340","title":"模式与模式匹配"},"341":{"body":"ch19-01-all-the-places-for-patterns.md commit 0c2d41e2afce734825c3a12087d423e8c2f0ae53 模式出现在 Rust 的很多地方。你已经在不经意间使用了很多模式！本部分是一个所有有效模式位置的参考。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » 所有可能会用到模式的位置","id":"341","title":"所有可能会用到模式的位置"},"342":{"body":"如第六章所讨论的，一个模式常用的位置是 match 表达式的分支。在形式上 match 表达式由 match 关键字、用于匹配的值和一个或多个分支构成，这些分支包含一个模式和在值匹配分支的模式时运行的表达式： match VALUE { PATTERN => EXPRESSION, PATTERN => EXPRESSION, PATTERN => EXPRESSION,\n} 例如这是一个来自示例 6-5 中匹配变量 x 中 Option<i32> 值的 match 表达式： match x { None => None, Some(i) => Some(i + 1),\n} 这个 match 表达式中的模式为每个箭头左边的 None 和 Some(i)。 match 表达式必须是穷尽（ exhaustive ）的，意为 match 表达式所有可能的值都必须被考虑到。一个确保覆盖每个可能值的方法是在最后一个分支使用捕获所有的模式：比如，一个匹配任何值的名称永远也不会失败，因此可以覆盖所有匹配剩下的情况。有一个特定的模式 _ 可以匹配所有情况，不过它从不绑定任何变量。这在例如希望忽略任何未指定值的情况很有用。本章之后的 “忽略模式中的值” 部分会详细介绍 _ 模式的更多细节。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » match 分支","id":"342","title":"match 分支"},"343":{"body":"第六章讨论过了 if let 表达式，以及它是如何主要用于编写等同于只关心一个情况的 match 语句简写的。if let 可以对应一个可选的带有代码的 else 在 if let 中的模式不匹配时运行。示例 18-1 展示了也可以组合并匹配 if let、else if 和 else if let 表达式。这相比 match 表达式一次只能将一个值与模式比较提供了更多灵活性。并且 Rust 并不要求一系列 if let、else if、else if let 分支的条件相互关联。示例 18-1 中的代码展示了一系列针对不同条件的检查来决定背景颜色应该是什么。为了达到这个例子的目的，我们创建了硬编码值的变量，在真实程序中则可能由询问用户获得。文件名：src/main.rs fn main() { let favorite_color: Option<&str> = None; let is_tuesday = false; let age: Result<u8, _> = \"34\".parse(); if let Some(color) = favorite_color { println!(\"Using your favorite color, {color}, as the background\"); } else if is_tuesday { println!(\"Tuesday is green day!\"); } else if let Ok(age) = age { if age > 30 { println!(\"Using purple as the background color\"); } else { println!(\"Using orange as the background color\"); } } else { println!(\"Using blue as the background color\"); }\n} 示例 18-1: 结合 if let、else if、else if let 以及 else 如果用户指定了中意的颜色，将使用其作为背景颜色。如果没有指定中意的颜色且今天是星期二，背景颜色将是绿色。如果用户指定了他们的年龄字符串并能够成功将其解析为数字的话，我们将根据这个数字使用紫色或者橙色。最后，如果没有一个条件符合，背景颜色将是蓝色。这个条件结构允许我们支持复杂的需求。使用这里硬编码的值，例子会打印出 Using purple as the background color。注意 if let 也可以像 match 分支那样引入覆盖变量：if let Ok(age) = age 引入了一个新的覆盖变量 age，它包含 Ok 成员中的值。这意味着 if age > 30 条件需要位于这个代码块内部；不能将两个条件组合为 if let Ok(age) = age && age > 30，因为我们希望与 30 进行比较的被覆盖的 age 直到大括号开始的新作用域才是有效的。 if let 表达式的缺点在于其穷尽性没有为编译器所检查，而 match 表达式则检查了。如果去掉最后的 else 块而遗漏处理一些情况，编译器也不会警告这类可能的逻辑错误。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » if let 条件表达式","id":"343","title":"if let 条件表达式"},"344":{"body":"一个与 if let 结构类似的是 while let 条件循环，它允许只要模式匹配就一直进行 while 循环。示例 18-2 展示了一个使用 while let 的例子，它使用 vector 作为栈并以先进后出的方式打印出 vector 中的值： # fn main() { let (tx, rx) = std::sync::mpsc::channel(); std::thread::spawn(move || { for val in [1, 2, 3] { tx.send(val).unwrap(); } }); while let Ok(value) = rx.recv() { println!(\"{value}\"); }\n# } 列表 18-2: 使用 while let 循环只要 stack.pop() 返回 Some 就打印出其值这个例子会打印出 3、2 接着是 1。pop 方法取出 vector 的最后一个元素并返回 Some(value)。如果 vector 是空的，它返回 None。while 循环只要 pop 返回 Some 就会一直运行其块中的代码。一旦其返回 None，while 循环停止。我们可以使用 while let 来弹出栈中的每一个元素。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » while let 条件循环","id":"344","title":"while let 条件循环"},"345":{"body":"在 for 循环中，模式是 for 关键字直接跟随的值，正如 for x in y 中的 x。示例 18-3 中展示了如何使用 for 循环来解构，或拆开一个元组作为 for 循环的一部分： # fn main() { let v = vec!['a', 'b', 'c']; for (index, value) in v.iter().enumerate() { println!(\"{value} is at index {index}\"); }\n# } 列表 18-3: 在 for 循环中使用模式来解构元组示例 18-3 的代码会打印出： $ cargo run Compiling patterns v0.1.0 (file:///projects/patterns) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s Running `target/debug/patterns`\na is at index 0\nb is at index 1\nc is at index 2 这里使用 enumerate 方法适配一个迭代器来产生一个值和其在迭代器中的索引，它们位于一个元组中。第一个产生的值是元组 (0, 'a')。当这个值匹配模式 (index, value)，index 将会是 0 而 value 将会是 'a'，并打印出第一行输出。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » for 循环","id":"345","title":"for 循环"},"346":{"body":"在本章之前，我们只明确的讨论过通过 match 和 if let 使用模式，不过事实上也在别的地方使用过模式，包括 let 语句。例如，考虑一下这个直白的 let 变量赋值： let x = 5; 不过你可能没有发觉，每一次像这样使用 let 语句就是在使用模式！let 语句更为正式的样子如下： let PATTERN = EXPRESSION; 像 let x = 5; 这样的语句中变量名位于 PATTERN 位置，变量名不过是形式特别朴素的模式。我们将表达式与模式比较，并为任何找到的名称赋值。所以例如 let x = 5; 的情况，x 是一个代表 “将匹配到的值绑定到变量 x” 的模式。同时因为名称 x 是整个模式，这个模式实际上等于 “将任何值绑定到变量 x，不管值是什么”。为了更清楚的理解 let 的模式匹配方面的内容，考虑示例 18-4 中使用 let 和模式解构一个元组： # fn main() { let (x, y, z) = (1, 2, 3);\n# } 示例 18-4: 使用模式解构元组并一次创建三个变量这里将一个元组与模式匹配。Rust 会比较值 (1, 2, 3) 与模式 (x, y, z) 并发现此值匹配这个模式。在这个例子中，将会把 1 绑定到 x，2 绑定到 y 并将 3 绑定到 z。你可以将这个元组模式看作是将三个独立的变量模式结合在一起。如果模式中元素的数量不匹配元组中元素的数量，则整个类型不匹配，并会得到一个编译时错误。例如，示例 18-5 展示了尝试用两个变量解构三个元素的元组，这是不行的： # fn main() { let (x, y) = (1, 2, 3);\n# } 示例 18-5: 一个错误的模式结构，其中变量的数量不符合元组中元素的数量尝试编译这段代码会给出如下类型错误： $ cargo run Compiling patterns v0.1.0 (file:///projects/patterns)\nerror[E0308]: mismatched types --> src/main.rs:2:9 |\n2 | let (x, y) = (1, 2, 3); | ^^^^^^ --------- this expression has type `({integer}, {integer}, {integer})` | | | expected a tuple with 3 elements, found one with 2 elements | = note: expected tuple `({integer}, {integer}, {integer})` found tuple `(_, _)` For more information about this error, try `rustc --explain E0308`.\nerror: could not compile `patterns` (bin \"patterns\") due to 1 previous error 为了修复这个错误，可以使用 _ 或 .. 来忽略元组中一个或多个值，如 “忽略模式中的值” 部分所示。如果问题是模式中有太多的变量，则解决方法是通过去掉变量使得变量数与元组中元素数相等。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » let 语句","id":"346","title":"let 语句"},"347":{"body":"函数参数也可以是模式。列表 18-6 中的代码声明了一个叫做 foo 的函数，它获取一个 i32 类型的参数 x，现在这看起来应该很熟悉： fn foo(x: i32) { // code goes here\n}\n# # fn main() {} 列表 18-6: 在参数中使用模式的函数签名 x 部分就是一个模式！类似于之前对 let 所做的，可以在函数参数中匹配元组。列表 18-7 将传递给函数的元组拆分为值：文件名：src/main.rs fn print_coordinates(&(x, y): &(i32, i32)) { println!(\"Current location: ({x}, {y})\");\n} fn main() { let point = (3, 5); print_coordinates(&point);\n} 列表 18-7: 一个在参数中解构元组的函数这会打印出 Current location: (3, 5)。值 &(3, 5) 会匹配模式 &(x, y)，如此 x 得到了值 3，而 y得到了值 5。因为如第十三章所讲闭包类似于函数，也可以在闭包参数列表中使用模式。现在我们见过了很多使用模式的方式了，不过模式在每个使用它的地方并不以相同的方式工作；在一些地方，模式必须是 irrefutable 的，意味着它们必须匹配所提供的任何值。在另一些情况，它们则可以是 refutable 的。接下来让我们讨论这两个概念。","breadcrumbs":"模式与模式匹配 » 所有可能会用到模式的位置 » 函数参数","id":"347","title":"函数参数"},"348":{"body":"ch19-02-refutability.md commit 0c2d41e2afce734825c3a12087d423e8c2f0ae53 模式有两种形式：refutable（可反驳的）和 irrefutable（不可反驳的）。能匹配任何传递的可能值的模式被称为是不可反驳的（ irrefutable ）。一个例子就是 let x = 5; 语句中的 x，因为 x 可以匹配任何值所以不可能会失败。对某些可能的值进行匹配会失败的模式被称为是可反驳的（ refutable ）。一个这样的例子便是 if let Some(x) = a_value 表达式中的 Some(x)；如果变量 a_value 中的值是 None 而不是 Some，那么 Some(x) 模式不能匹配。函数参数、let 语句和 for 循环只能接受不可反驳的模式，因为当值不匹配时，程序无法进行有意义的操作。if let 和 while let 表达式可以接受可反驳和不可反驳的模式，但编译器会对不可反驳的模式发出警告，因为根据定义它们旨在处理可能的失败：条件表达式的功能在于它能够根据成功或失败来执行不同的操作。通常我们无需担心可反驳和不可反驳模式的区别，不过确实需要熟悉可反驳性的概念，这样当在错误信息中看到时就知道如何应对。遇到这些情况，根据代码行为的意图，需要修改模式或者使用模式的结构。让我们看看一个尝试在 Rust 要求不可反驳模式的地方使用可反驳模式以及相反情况的例子。在示例 18-8 中，有一个 let 语句，不过模式被指定为可反驳模式 Some(x)。如你所见，这不能编译： # fn main() {\n# let some_option_value: Option<i32> = None; let Some(x) = some_option_value;\n# } 示例 18-8: 尝试在 let 中使用可反驳模式如果 some_option_value 的值是 None，其不会成功匹配模式 Some(x)，表明这个模式是可反驳的。然而，因为 let 对于 None 匹配不能产生任何合法的代码，所以 let 语句只能接受不可反驳模式。Rust 会在编译时抱怨我们尝试在要求不可反驳模式的地方使用可反驳模式： $ cargo run Compiling patterns v0.1.0 (file:///projects/patterns)\nerror[E0005]: refutable pattern in local binding --> src/main.rs:3:9 |\n3 | let Some(x) = some_option_value; | ^^^^^^^ pattern `None` not covered | = note: `let` bindings require an \"irrefutable pattern\", like a `struct` or an `enum` with only one variant = note: for more information, visit https://doc.rust-lang.org/book/ch19-02-refutability.html = note: the matched value is of type `Option<i32>`\nhelp: you might want to use `let else` to handle the variant that isn't matched |\n3 | let Some(x) = some_option_value else { todo!() }; | ++++++++++++++++ For more information about this error, try `rustc --explain E0005`.\nerror: could not compile `patterns` (bin \"patterns\") due to 1 previous error 因为我们没有覆盖（也不可能覆盖！）到模式 Some(x) 的每一个可能的值，所以 Rust 会合理地抗议。为了修复在需要不可反驳模式的地方使用可反驳模式的情况，可以修改使用模式的代码：不同于使用 let，可以使用 if let。如此，如果模式不匹配，大括号中的代码将被忽略，其余代码保持有效。示例 18-9 展示了如何修复示例 18-8 中的代码。 # fn main() {\n# let some_option_value: Option<i32> = None; if let Some(x) = some_option_value { println!(\"{x}\"); }\n# } 示例 18-9: 使用 if let 和一个带有可反驳模式的代码块来代替 let 我们给了代码一个得以继续的出路！虽然我们没办法在避免产生错误的情况下使用不可反驳模式，但这段使用可反驳模式的代码是完全有效的。如果为 if let 提供了一个总是会匹配的模式，比如示例 18-10 中的 x，编译器会给出一个警告： # fn main() { if let x = 5 { println!(\"{x}\"); };\n# } 示例 18-10: 尝试把不可反驳模式用到 if let 上 Rust 会抱怨将不可反驳模式用于 if let 是没有意义的： $ cargo run Compiling patterns v0.1.0 (file:///projects/patterns)\nwarning: irrefutable `if let` pattern --> src/main.rs:2:8 |\n2 | if let x = 5 { | ^^^^^^^^^ | = note: this pattern will always match, so the `if let` is useless = help: consider replacing the `if let` with a `let` = note: `#[warn(irrefutable_let_patterns)]` on by default warning: `patterns` (bin \"patterns\") generated 1 warning Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.39s Running `target/debug/patterns`\n5 基于此，match匹配分支必须使用可反驳模式，除了最后一个分支需要使用能匹配任何剩余值的不可反驳模式。Rust 允许我们在只有一个匹配分支的match中使用不可反驳模式，不过这么做不是特别有用，并可以被更简单的 let 语句替代。目前我们已经讨论了所有可以使用模式的地方，以及可反驳模式与不可反驳模式的区别，下面让我们一起去把可以用来创建模式的语法过目一遍吧。","breadcrumbs":"模式与模式匹配 » Refutability（可反驳性）: 模式是否会匹配失效 » Refutability（可反驳性）: 模式是否会匹配失效","id":"348","title":"Refutability（可反驳性）: 模式是否会匹配失效"},"349":{"body":"ch19-03-pattern-syntax.md commit 6fce661a0938aa0da06526e7b8f98fd7e67a222f 在本节中，我们收集了模式中所有有效的语法，并讨论为什么以及何时你可能要使用这些语法。","breadcrumbs":"模式与模式匹配 » 模式语法 » 所有的模式语法","id":"349","title":"所有的模式语法"},"35":{"body":"回忆一下，我们在程序的第一行使用 use std::io; 从标准库中引入了输入/输出功能。现在调用 io 库中的函数 stdin，这允许我们处理用户输入： # use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# io::stdin() .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } 如果程序的开头没有使用 use std::io; 引入 io 库，我们仍可以通过把函数调用写成 std::io::stdin 来使用该函数。stdin 函数返回一个 std::io::Stdin 的实例，这是一种代表终端标准输入句柄的类型。接下来，代码中的 .read_line(&mut guess) 调用了标准输入句柄上的 read_line 方法，以获取用户输入。我们还将 &mut guess 作为参数传递给 read_line 函数，让其将用户输入储存到这个字符串中。read_line 的工作是，无论用户在标准输入中键入什么内容，都将其追加（不会覆盖其原有内容）到一个字符串中，因此它需要字符串作为参数。这个字符串参数应该是可变的，以便 read_line 将用户输入附加上去。 & 表示这个参数是一个引用（ reference ），它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂的特性，Rust 的一个主要优势就是安全而简单的操纵引用。完成当前程序并不需要了解如此多细节。现在，我们只需知道它像变量一样，默认是不可变的。因此，需要写成 &mut guess 来使其可变，而不是 &guess。（第四章会更全面的解释引用。）","breadcrumbs":"写个猜数字游戏 » 接收用户输入","id":"35","title":"接收用户输入"},"350":{"body":"如第六章所示，可以直接匹配字面值模式。如下代码给出了一些例子： # fn main() { let x = 1; match x { 1 => println!(\"one\"), 2 => println!(\"two\"), 3 => println!(\"three\"), _ => println!(\"anything\"), }\n# } 这段代码会打印 one 因为 x 的值是 1。如果希望代码获得特定的具体值，则该语法很有用。","breadcrumbs":"模式与模式匹配 » 模式语法 » 匹配字面值","id":"350","title":"匹配字面值"},"351":{"body":"命名变量是匹配任何值的不可反驳模式，这在之前已经使用过数次。然而当其用于 match 表达式时情况会有些复杂。因为 match 会开始一个新作用域，match 表达式中作为模式的一部分声明的变量会覆盖 match 结构之外的同名变量，与所有变量一样。在示例 18-11 中，声明了一个值为 Some(5) 的变量 x 和一个值为 10 的变量 y。接着在值 x 上创建了一个 match 表达式。观察匹配分支中的模式和结尾的 println!，并在运行此代码或进一步阅读之前推断这段代码会打印什么。文件名：src/main.rs # fn main() { let x = Some(5); let y = 10; match x { Some(50) => println!(\"Got 50\"), Some(y) => println!(\"Matched, y = {y}\"), _ => println!(\"Default case, x = {x:?}\"), } println!(\"at the end: x = {x:?}, y = {y}\");\n# } 示例 18-11: 一个 match 语句其中一个分支引入了覆盖变量 y 让我们看看当 match 语句运行的时候发生了什么。第一个匹配分支的模式并不匹配 x 中定义的值，所以代码继续执行。第二个匹配分支中的模式引入了一个新变量 y，它会匹配任何 Some 中的值。因为我们在 match 表达式的新作用域中，这是一个新变量，而不是开头声明为值 10 的那个 y。这个新的 y 绑定会匹配任何 Some 中的值，在这里是 x 中的值。因此这个 y 绑定了 x 中 Some 内部的值。这个值是 5，所以这个分支的表达式将会执行并打印出 Matched, y = 5。如果 x 的值是 None 而不是 Some(5)，头两个分支的模式不会匹配，所以会匹配下划线。这个分支的模式中没有引入变量 x，所以此时表达式中的 x 会是外部没有被覆盖的 x。在这个假想的例子中，match 将会打印 Default case, x = None。一旦 match 表达式执行完毕，其作用域也就结束了，同理内部 y 的作用域也结束了。最后的 println! 会打印 at the end: x = Some(5), y = 10。为了创建能够比较外部 x 和 y 的值，而不引入覆盖变量的 match 表达式，我们需要相应地使用带有条件的匹配守卫（match guard）。我们稍后将在 “匹配守卫提供的额外条件” 这一小节讨论匹配守卫。","breadcrumbs":"模式与模式匹配 » 模式语法 » 匹配命名变量","id":"351","title":"匹配命名变量"},"352":{"body":"在 match 表达式中，可以使用 | 语法匹配多个模式，它代表或（ or ）运算符模式。例如，如下代码将 x 的值与匹配分支相比较，第一个分支有或选项，意味着如果 x 的值匹配此分支的任一个值，它就会运行： # fn main() { let x = 1; match x { 1 | 2 => println!(\"one or two\"), 3 => println!(\"three\"), _ => println!(\"anything\"), }\n# } 上面的代码会打印 one or two。","breadcrumbs":"模式与模式匹配 » 模式语法 » 多个模式","id":"352","title":"多个模式"},"353":{"body":"..= 语法允许你匹配一个闭区间范围内的值。在如下代码中，当模式匹配任何在给定范围内的值时，该分支会执行： # fn main() { let x = 5; match x { 1..=5 => println!(\"one through five\"), _ => println!(\"something else\"), }\n# } 如果 x 是 1、2、3、4 或 5，第一个分支就会匹配。这个语法在匹配多个值时相比使用 | 运算符来表达相同的意思更为方便；如果使用 | 则不得不指定 1 | 2 | 3 | 4 | 5。相反指定范围就简短的多，特别是在希望匹配比如从 1 到 1000 的数字的时候！编译器会在编译时检查范围不为空，而 char 和数字值是 Rust 仅有的可以判断范围是否为空的类型，所以范围只允许用于数字或 char 值。如下是一个使用 char 类型值范围的例子： # fn main() { let x = 'c'; match x { 'a'..='j' => println!(\"early ASCII letter\"), 'k'..='z' => println!(\"late ASCII letter\"), _ => println!(\"something else\"), }\n# } Rust 知道 'c' 位于第一个模式的范围内，并会打印出 early ASCII letter。","breadcrumbs":"模式与模式匹配 » 模式语法 » 通过 ..= 匹配值的范围","id":"353","title":"通过 ..= 匹配值的范围"},"354":{"body":"也可以使用模式来解构结构体、枚举和元组，以便使用这些值的不同部分。让我们来分别看一看。解构结构体示例 18-12 展示带有两个字段 x 和 y 的结构体 Point，可以通过带有模式的 let 语句将其分解：文件名：src/main.rs struct Point { x: i32, y: i32,\n} fn main() { let p = Point { x: 0, y: 7 }; let Point { x: a, y: b } = p; assert_eq!(0, a); assert_eq!(7, b);\n} 示例 18-12: 解构一个结构体的字段为单独的变量这段代码创建了变量 a 和 b 来匹配结构体 p 中的 x 和 y 字段。这个例子展示了模式中的变量名不必与结构体中的字段名一致。不过通常希望变量名与字段名一致以便于理解变量来自于哪些字段。因为变量名匹配字段名是常见的，同时因为 let Point { x: x, y: y } = p; 包含了很多重复，所以对于匹配结构体字段的模式存在简写：只需列出结构体字段的名称，则模式创建的变量会有相同的名称。示例 18-13 展示了与示例 18-12 有着相同行为的代码，不过 let 模式创建的变量为 x 和 y 而不是 a 和 b：文件名：src/main.rs struct Point { x: i32, y: i32,\n} fn main() { let p = Point { x: 0, y: 7 }; let Point { x, y } = p; assert_eq!(0, x); assert_eq!(7, y);\n} 示例 18-13: 使用结构体字段简写来解构结构体字段这段代码创建了变量 x 和 y，与变量 p 中的 x 和 y 相匹配。其结果是变量 x 和 y 包含结构体 p 中的值。也可以使用字面值作为结构体模式的一部分进行解构，而不是为所有的字段创建变量。这允许我们测试一些字段为特定值的同时创建其他字段的变量。示例 18-14 展示了一个 match 语句将 Point 值分成了三种情况：直接位于 x 轴上（此时 y = 0 为真）、位于 y 轴上（x = 0）或不在任何轴上的点。文件名：src/main.rs # struct Point {\n# x: i32,\n# y: i32,\n# }\n# fn main() { let p = Point { x: 0, y: 7 }; match p { Point { x, y: 0 } => println!(\"On the x axis at {x}\"), Point { x: 0, y } => println!(\"On the y axis at {y}\"), Point { x, y } => { println!(\"On neither axis: ({x}, {y})\"); } }\n} 示例 18-14: 解构和匹配模式中的字面值第一个分支通过指定字段 y 匹配字面值 0 来匹配任何位于 x 轴上的点。此模式仍然创建了变量 x 以便在分支的代码中使用。类似的，第二个分支通过指定字段 x 匹配字面值 0 来匹配任何位于 y 轴上的点，并为字段 y 创建了变量 y。第三个分支没有指定任何字面值，所以其会匹配任何其他的 Point 并为 x 和 y 两个字段创建变量。在这个例子中，值 p 因为其 x 包含 0 而匹配第二个分支，因此会打印出 On the y axis at 7。记住 match 表达式一旦找到一个匹配的模式就会停止检查其它分支，所以即使 Point { x: 0, y: 0} 在 x 轴上也在 y 轴上，这些代码也只会打印 On the x axis at 0。解构枚举本书之前曾经解构过枚举（例如第六章示例 6-5），不过当时没有明确提到解构枚举的模式需要对应枚举所定义的储存数据的方式。让我们以示例 6-2 中的 Message 枚举为例，编写一个 match 使用模式解构每一个内部值，如示例 18-15 所示：文件名：src/main.rs enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(i32, i32, i32),\n} fn main() { let msg = Message::ChangeColor(0, 160, 255); match msg { Message::Quit => { println!(\"The Quit variant has no data to destructure.\"); } Message::Move { x, y } => { println!(\"Move in the x direction {x} and in the y direction {y}\"); } Message::Write(text) => { println!(\"Text message: {text}\"); } Message::ChangeColor(r, g, b) => { println!(\"Change the color to red {r}, green {g}, and blue {b}\") } }\n} 示例 18-15: 解构包含不同类型值成员的枚举这段代码会打印出 Change the color to red 0, green 160, and blue 255。尝试改变 msg 的值来观察其他分支代码的运行。对于像 Message::Quit 这样没有任何数据的枚举成员，不能进一步解构其值。只能匹配其字面值 Message::Quit，因此模式中没有任何变量。对于像 Message::Move 这样的类结构体枚举成员，可以采用类似于匹配结构体的模式。在成员名称后，使用大括号并列出字段变量以便将其分解以供此分支的代码使用。这里使用了示例 18-13 所展示的简写。对于像 Message::Write 这样的包含一个元素，以及像 Message::ChangeColor 这样包含三个元素的类元组枚举成员，其模式则类似于用于解构元组的模式。模式中变量的数量必须与成员中元素的数量一致。解构嵌套的结构体和枚举目前为止，所有的例子都只匹配了深度为一级的结构体或枚举，不过当然也可以匹配嵌套的项！例如，我们可以重构列表 18-15 的代码在 ChangeColor 消息中同时支持 RGB 和 HSV 色彩模式，如示例 18-16 所示： enum Color { Rgb(i32, i32, i32), Hsv(i32, i32, i32),\n} enum Message { Quit, Move { x: i32, y: i32 }, Write(String), ChangeColor(Color),\n} fn main() { let msg = Message::ChangeColor(Color::Hsv(0, 160, 255)); match msg { Message::ChangeColor(Color::Rgb(r, g, b)) => { println!(\"Change color to red {r}, green {g}, and blue {b}\"); } Message::ChangeColor(Color::Hsv(h, s, v)) => { println!(\"Change color to hue {h}, saturation {s}, value {v}\") } _ => (), }\n} 示例 18-16: 匹配嵌套的枚举 match 表达式第一个分支的模式匹配一个包含 Color::Rgb 枚举成员的 Message::ChangeColor 枚举成员，然后模式绑定了 3 个内部的 i32 值。第二个分支的模式也匹配一个 Message::ChangeColor 枚举成员，但是其内部的枚举会匹配 Color::Hsv 枚举成员。我们可以在一个 match 表达式中指定这些复杂条件，即使会涉及到两个枚举。解构结构体和元组甚至可以用复杂的方式来混合、匹配和嵌套解构模式。如下是一个复杂结构体的例子，其中结构体和元组嵌套在元组中，并将所有的原始类型解构出来： # fn main() {\n# struct Point {\n# x: i32,\n# y: i32,\n# }\n# let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });\n# } 这将复杂的类型分解成部分组件以便可以单独使用我们感兴趣的值。通过模式解构是一个方便利用部分值片段的手段，比如结构体中每个单独字段的值。","breadcrumbs":"模式与模式匹配 » 模式语法 » 解构并分解值","id":"354","title":"解构并分解值"},"355":{"body":"有时忽略模式中的一些值是有用的，比如 match 中最后捕获全部情况的分支实际上没有做任何事，但是它确实对所有剩余情况负责。有一些简单的方法可以忽略模式中全部或部分值：使用 _ 模式（我们已经见过了），在另一个模式中使用 _ 模式，使用一个以下划线开始的名称，或者使用 .. 忽略所剩部分的值。让我们来分别探索如何以及为什么要这么做。使用 _ 忽略整个值我们已经使用过下划线作为匹配但不绑定任何值的通配符模式了。虽然这作为 match 表达式最后的分支特别有用，也可以将其用于任意模式，包括函数参数中，如示例 18-17 所示：文件名：src/main.rs fn foo(_: i32, y: i32) { println!(\"This code only uses the y parameter: {y}\");\n} fn main() { foo(3, 4);\n} 示例 18-17: 在函数签名中使用 _ 这段代码会完全忽略作为第一个参数传递的值 3，并会打印出 This code only uses the y parameter: 4。大部分情况当你不再需要特定函数参数时，最好修改签名不再包含无用的参数。在一些情况下忽略函数参数会变得特别有用，比如实现 trait 时，当你需要特定类型签名但是函数实现并不需要某个参数时。这样可以避免一个存在未使用的函数参数的编译警告，就跟使用命名参数一样。使用嵌套的 _ 忽略部分值也可以在一个模式内部使用_ 忽略部分值，例如，当只需要测试部分值但在期望运行的代码中没有用到其他部分时。示例 18-18 展示了负责管理设置值的代码。业务需求是用户不允许覆盖现有的自定义设置，但是可以取消设置，也可以在当前未设置时为其提供设置。 # fn main() { let mut setting_value = Some(5); let new_setting_value = Some(10); match (setting_value, new_setting_value) { (Some(_), Some(_)) => { println!(\"Can't overwrite an existing customized value\"); } _ => { setting_value = new_setting_value; } } println!(\"setting is {setting_value:?}\");\n# } 示例 18-18: 当不需要 Some 中的值时在模式内使用下划线来匹配 Some 成员这段代码会打印出 Can't overwrite an existing customized value 接着是 setting is Some(5)。在第一个匹配分支，我们不需要匹配或使用任一个 Some 成员中的值；重要的部分是需要测试 setting_value 和 new_setting_value 都为 Some 成员的情况。在这种情况，我们打印出为何不改变 setting_value，并且不会改变它。对于所有其他情况（setting_value 或 new_setting_value 任一为 None），这由第二个分支的 _ 模式体现，这时确实希望允许 new_setting_value 变为 setting_value。也可以在一个模式中的多处使用下划线来忽略特定值，如示例 18-19 所示，这里忽略了一个五元元组中的第二和第四个值： # fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { (first, _, third, _, fifth) => { println!(\"Some numbers: {first}, {third}, {fifth}\") } }\n# } 示例 18-19: 忽略元组的多个部分这会打印出 Some numbers: 2, 8, 32，值 4 和 16 会被忽略。通过在名字前以一个 _ 开头来忽略未使用的变量如果你创建了一个变量却不在任何地方使用它，Rust 通常会给你一个警告，因为未使用的变量可能会是个 bug。但是有时创建一个还未使用的变量是有用的，比如你正在设计原型或刚刚开始一个项目。这时你希望告诉 Rust 不要警告未使用的变量，为此可以用下划线作为变量名的开头。示例 18-20 中创建了两个未使用变量，不过当编译代码时只会得到其中一个的警告：文件名：src/main.rs fn main() { let _x = 5; let y = 10;\n} 示例 18-20: 以下划线开始变量名以便去掉未使用变量警告这里得到了警告说未使用变量 y，不过没有警告说使用 _x。注意，只使用 _ 和使用以下划线开头的名称有些微妙的不同：比如 _x 仍会将值绑定到变量，而 _ 则完全不会绑定。为了展示这个区别的意义，示例 18-21 会产生一个错误。 # fn main() { let s = Some(String::from(\"Hello!\")); if let Some(_s) = s { println!(\"found a string\"); } println!(\"{s:?}\");\n# } 示例 18-21: 以下划线开头的未使用变量仍然会绑定值，它可能会获取值的所有权我们会得到一个错误，因为 s 的值仍然会移动进 _s，并阻止我们再次使用 s。然而只使用下划线本身，并不会绑定值。示例 18-22 能够无错编译，因为 s 没有被移动进 _： # fn main() { let s = Some(String::from(\"Hello!\")); if let Some(_) = s { println!(\"found a string\"); } println!(\"{s:?}\");\n# } 示例 18-22: 单独使用下划线不会绑定值上面的代码能很好的运行；因为没有把 s 绑定到任何变量；它没有被移动。用 .. 忽略剩余值对于有多个部分的值，可以使用 .. 语法来只使用特定部分并忽略其它值，同时避免不得不每一个忽略值列出下划线。.. 模式会忽略模式中剩余的任何没有显式匹配的值部分。在示例 18-23 中，有一个 Point 结构体存放了三维空间中的坐标。在 match 表达式中，我们希望只操作 x 坐标并忽略 y 和 z 字段的值： # fn main() { struct Point { x: i32, y: i32, z: i32, } let origin = Point { x: 0, y: 0, z: 0 }; match origin { Point { x, .. } => println!(\"x is {x}\"), }\n# } 示例 18-23: 通过使用 .. 来忽略 Point 中除 x 以外的字段这里列出了 x 值，接着仅仅包含了 .. 模式。这比不得不列出 y: _ 和 z: _ 要来得简单，特别是在处理有很多字段的结构体，但只涉及一到两个字段时的情形。 .. 会扩展为所需要的值的数量。示例 18-24 展示了元组中 .. 的应用：文件名：src/main.rs fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { (first, .., last) => { println!(\"Some numbers: {first}, {last}\"); } }\n} 示例 18-24: 只匹配元组中的第一个和最后一个值并忽略掉所有其它值这里用 first 和 last 来匹配第一个和最后一个值。.. 将匹配并忽略中间的所有值。然而使用 .. 必须是无歧义的。如果期望匹配和忽略的值是不明确的，Rust 会报错。示例 18-25 展示了一个带有歧义的 .. 例子，因此其不能编译：文件名：src/main.rs fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { (.., second, ..) => { println!(\"Some numbers: {second}\") }, }\n} 示例 18-25: 尝试以有歧义的方式运用 .. 如果编译上面的例子，会得到下面的错误： $ cargo run Compiling patterns v0.1.0 (file:///projects/patterns)\nerror: `..` can only be used once per tuple pattern --> src/main.rs:5:22 |\n5 | (.., second, ..) => { | -- ^^ can only be used once per tuple pattern | | | previously used here error: could not compile `patterns` (bin \"patterns\") due to 1 previous error Rust 不可能决定在元组中匹配 second 值之前应该忽略多少个值，以及在之后忽略多少个值。这段代码可能表明我们意在忽略 2，绑定 second 为 4，接着忽略 8、16 和 32；抑或是意在忽略 2 和 4，绑定 second 为 8，接着忽略 16 和 32，以此类推。变量名 second 对于 Rust 来说并没有任何特殊意义，所以会得到编译错误，因为在这两个地方使用 .. 是有歧义的。","breadcrumbs":"模式与模式匹配 » 模式语法 » 忽略模式中的值","id":"355","title":"忽略模式中的值"},"356":{"body":"匹配守卫（ match guard ）是一个指定于 match 分支模式之后的额外 if 条件，它也必须被满足才能选择此分支。匹配守卫用于表达比单独的模式所能允许的更为复杂的情况。这个条件可以使用模式中创建的变量。示例 18-26 展示了一个 match，其中第一个分支有模式 Some(x) 还有匹配守卫 if x % 2 == 0 (当 x 是偶数的时候为真)： # fn main() { let num = Some(4); match num { Some(x) if x % 2 == 0 => println!(\"The number {x} is even\"), Some(x) => println!(\"The number {x} is odd\"), None => (), }\n# } 示例 18-26: 在模式中加入匹配守卫上例会打印出 The number 4 is even。当 num 与模式中第一个分支比较时，因为 Some(4) 匹配 Some(x) 所以可以匹配。接着匹配守卫检查 x 除以 2 的余数是否等于 0，因为它等于 0，所以第一个分支被选择。相反如果 num 为 Some(5)，因为 5 除以 2 的余数是 1 不等于 0 所以第一个分支的匹配守卫为假。接着 Rust 会前往第二个分支，这次匹配因为它没有匹配守卫所以会匹配任何 Some 成员。无法在模式中表达类似 if x % 2 == 0 的条件，所以通过匹配守卫提供了表达类似逻辑的能力。这种替代表达方式的缺点是，编译器不会尝试为包含匹配守卫的模式检查穷尽性。在示例 18-11 中，我们提到可以使用匹配守卫来解决模式中变量覆盖的问题，那里 match 表达式的模式中新建了一个变量而不是使用 match 之外的同名变量。新变量意味着不能够测试外部变量的值。示例 18-27 展示了如何使用匹配守卫修复这个问题。文件名：src/main.rs fn main() { let x = Some(5); let y = 10; match x { Some(50) => println!(\"Got 50\"), Some(n) if n == y => println!(\"Matched, n = {n}\"), _ => println!(\"Default case, x = {x:?}\"), } println!(\"at the end: x = {x:?}, y = {y}\");\n} 示例 18-27: 使用匹配守卫来测试与外部变量的相等性现在这会打印出 Default case, x = Some(5)。现在第二个匹配分支中的模式不会引入一个覆盖外部 y 的新变量 y，这意味着可以在匹配守卫中使用外部的 y。相比指定会覆盖外部 y 的模式 Some(y)，这里指定为 Some(n)。此新建的变量 n 并没有覆盖任何值，因为 match 外部没有变量 n。匹配守卫 if n == y 并不是一个模式所以没有引入新变量。这个 y 正是外部的 y 而不是新的覆盖变量 y，这样就可以通过比较 n 和 y 来表达寻找一个与外部 y 相同的值的概念了。也可以在匹配守卫中使用或运算符 | 来指定多个模式，同时匹配守卫的条件会作用于所有的模式。示例 18-28 展示了结合匹配守卫与使用了 | 的模式的优先级。这个例子中重要的部分是匹配守卫 if y 作用于 4、5 和 6，即使这看起来好像 if y 只作用于 6： # fn main() { let x = 4; let y = false; match x { 4 | 5 | 6 if y => println!(\"yes\"), _ => println!(\"no\"), }\n# } 示例 18-28: 结合多个模式与匹配守卫这个匹配条件表明此分支值匹配 x 值为 4、5 或 6 同时 y 为 true 的情况。运行这段代码时会发生的是第一个分支的模式因 x 为 4 而匹配，不过匹配守卫 if y 为假，所以第一个分支不会被选择。代码移动到第二个分支，这会匹配，此程序会打印出 no。这是因为 if 条件作用于整个 4 | 5 | 6 模式，而不仅是最后的值 6。换句话说，匹配守卫与模式的优先级关系看起来像这样： (4 | 5 | 6) if y => ... 而不是： 4 | 5 | (6 if y) => ... 可以通过运行代码时的情况看出这一点：如果匹配守卫只作用于由 | 运算符指定的值列表的最后一个值，这个分支就会匹配且程序会打印出 yes。","breadcrumbs":"模式与模式匹配 » 模式语法 » 匹配守卫提供的额外条件","id":"356","title":"匹配守卫提供的额外条件"},"357":{"body":"at 运算符（@）允许我们在创建一个存放值的变量的同时测试其值是否匹配模式。示例 18-29 展示了一个例子，这里我们希望测试 Message::Hello 的 id 字段是否位于 3..=7 范围内，同时也希望能将其值绑定到 id_variable 变量中以便此分支相关联的代码可以使用它。可以将 id_variable 命名为 id，与字段同名，不过出于示例的目的这里选择了不同的名称。 # fn main() { enum Message { Hello { id: i32 }, } let msg = Message::Hello { id: 5 }; match msg { Message::Hello { id: id_variable @ 3..=7, } => println!(\"Found an id in range: {id_variable}\"), Message::Hello { id: 10..=12 } => { println!(\"Found an id in another range\") } Message::Hello { id } => println!(\"Found some other id: {id}\"), }\n# } 示例 18-29: 使用 @ 在模式中绑定值的同时测试它上例会打印出 Found an id in range: 5。通过在 3..=7 之前指定 id_variable @，我们捕获了任何匹配此范围的值并同时测试其值匹配这个范围模式。第二个分支只在模式中指定了一个范围，分支相关代码没有一个包含 id 字段实际值的变量。id 字段的值可以是 10、11 或 12，不过这个模式的代码并不知情也不能使用 id 字段中的值，因为没有将 id 值保存进一个变量。最后一个分支指定了一个没有范围的变量，此时确实拥有可以用于分支代码的变量 id，因为这里使用了结构体字段简写语法。不过此分支中没有像头两个分支那样对 id 字段的值进行测试：任何值都会匹配此分支。使用 @ 可以在一个模式中同时测试和保存变量值。","breadcrumbs":"模式与模式匹配 » 模式语法 » @ 绑定","id":"357","title":"@ 绑定"},"358":{"body":"模式是 Rust 中一个很有用的功能，它有助于我们区分不同类型的数据。当用于 match 语句时，Rust 确保模式会包含每一个可能的值，否则程序将不能编译。let 语句和函数参数的模式使得这些结构更强大，可以在将值解构为更小部分的同时为变量赋值。可以创建简单或复杂的模式来满足我们的要求。接下来，在本书倒数第二章中，我们将介绍一些 Rust 众多功能中较为高级的部分。","breadcrumbs":"模式与模式匹配 » 模式语法 » 总结","id":"358","title":"总结"},"359":{"body":"ch20-00-advanced-features.md commit a8536189d5f1ba2f0b1187bfae787c0d89e2871c 现在我们已经学习了 Rust 编程语言中最常用的部分。在第二十一章开始另一个新项目之前，让我们聊聊一些总有一天你会遇上的部分内容。你可以将本章作为不经意间遇到未知的内容时的参考。本章将要学习的功能在一些非常特定的场景下很有用处。虽然很少会碰到它们，我们希望确保你了解 Rust 提供的所有功能。本章将涉及如下内容：不安全 Rust：用于当需要舍弃 Rust 的某些保证并负责手动维持这些保证高级 trait：与 trait 相关的关联类型，默认类型参数，完全限定语法（fully qualified syntax），超（父）trait（supertraits）和 newtype 模式高级类型：关于 newtype 模式的更多内容，类型别名，never 类型和动态大小类型高级函数和闭包：函数指针和返回闭包宏：定义在编译时定义更多代码的方式对所有人而言，这都是一个介绍 Rust 迷人特性的宝典！让我们翻开它吧！","breadcrumbs":"高级特征 » 高级特征","id":"359","title":"高级特征"},"36":{"body":"我们还没有完全分析完这行代码。虽然我们已经讲到了第三行代码，但要注意：它仍是逻辑行（虽然换行了但仍是语句）的一部分。后一部分是这个方法（method）： # use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess) .expect(\"Failed to read line\");\n# # println!(\"You guessed: {}\", guess);\n# } 我们也可以将代码这样写： io::stdin().read_line(&mut guess).expect(\"Failed to read line\"); 不过，过长的代码行难以阅读，所以最好拆开来写。通常来说，当使用 .method_name() 语法调用方法时引入换行符和空格将长的代码行拆开是明智的。现在来看看这行代码干了什么。之前提到了 read_line 会将用户输入附加到传递给它的字符串中，不过它也会返回一个类型为 Result 的值。 Result 是一种枚举类型，通常也写作 enum 。枚举类型变量的值可以是多种可能状态中的一个。我们把每种可能的状态称为一种枚举成员（variant）。第六章将介绍枚举的更多细节。这里的 Result 类型将用来编码错误处理的信息。 Result 的成员是 Ok 和 Err，Ok 成员表示操作成功，内部包含成功时产生的值。Err 成员则意味着操作失败，并且 Err 中包含有关操作失败的原因或方式的信息。这些 Result 类型的作用是编码错误处理信息。Result 类型的值，像其他类型一样，拥有定义于其上的方法。Result 的实例拥有 expect 方法。如果 io::Result 实例的值是 Err，expect 会导致程序崩溃，并显示当做参数传递给 expect 的信息。如果 read_line 方法返回 Err，则可能是来源于底层操作系统错误的结果。如果 Result 实例的值是 Ok，expect 会获取 Ok 中的值并原样返回。在本例中，这个值是用户输入到标准输入中的字节数。如果不调用 expect，程序也能编译，不过会出现一个警告： $ cargo build Compiling guessing_game v0.1.0 (file:///projects/guessing_game)\nwarning: unused `Result` that must be used --> src/main.rs:10:5 |\n10 | io::stdin().read_line(&mut guess); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` on by default\nhelp: use `let _ = ...` to ignore the resulting value |\n10 | let _ = io::stdin().read_line(&mut guess); | +++++++ warning: `guessing_game` (bin \"guessing_game\") generated 1 warning Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.59s Rust 警告我们没有使用 read_line 的返回值 Result，说明有一个可能的错误没有处理。消除警告的正确做法是实际去编写错误处理代码，不过由于我们就是希望程序在出现问题时立即崩溃，所以直接使用 expect。第九章会学习如何从错误中恢复。","breadcrumbs":"写个猜数字游戏 » 使用 Result 类型来处理潜在的错误","id":"36","title":"使用 Result 类型来处理潜在的错误"},"360":{"body":"ch20-01-unsafe-rust.md commit 057b0d338229b87d06be772346ea0b643bdecdc5 目前为止讨论过的代码都有 Rust 在编译时会强制执行的内存安全保证。然而，Rust 还隐藏有第二种语言，它不会强制执行这类内存安全保证：这被称为不安全 Rust （ unsafe Rust ）。它与常规 Rust 代码无异，但是会提供额外的超能力。尽管代码可能没问题，但如果 Rust 编译器没有足够的信息可以确定，它将拒绝代码。不安全 Rust 之所以存在，是因为静态分析本质上是保守的。当编译器尝试确定一段代码是否支持某个保证时，拒绝一些合法的程序比接受无效的程序要好一些。这必然意味着有时代码可能是合法的，但如果 Rust 编译器没有足够的信息来确定，它将拒绝该代码。在这种情况下，可以使用不安全代码告诉编译器，“相信我，我知道我在干什么。” 不过千万注意，使用不安全 Rust 风险自担：如果不安全代码出错了，比如解引用空指针，可能会导致不安全的内存使用。另一个 Rust 存在不安全一面的原因是：底层计算机硬件固有的不安全性。如果 Rust 不允许进行不安全操作，那么有些任务则根本完成不了。Rust 需要能够进行像直接与操作系统交互，甚至于编写你自己的操作系统这样的底层系统编程！这也是 Rust 语言的目标之一。让我们看看不安全 Rust 能做什么，和怎么做。","breadcrumbs":"高级特征 » 不安全的 Rust » 不安全 Rust","id":"360","title":"不安全 Rust"},"361":{"body":"可以通过 unsafe 关键字来切换到不安全 Rust，接着可以开启一个新的存放不安全代码的块。这里有五类可以在不安全 Rust 中进行而不能用于安全 Rust 的操作，它们称之为 “不安全的超能力。（ unsafe superpowers ）” 这些超能力是：解引用裸指针调用不安全的函数或方法访问或修改可变静态变量实现不安全 trait 访问 union 的字段有一点很重要，unsafe 并不会关闭借用检查器或禁用任何其他 Rust 安全检查：如果在不安全代码中使用引用，它仍会被检查。unsafe 关键字只是提供了那五个不会被编译器检查内存安全的功能。你仍然能在不安全块中获得某种程度的安全。再者，unsafe 不意味着块中的代码就一定是危险的或者必然导致内存安全问题：其意图在于作为程序员你将会确保 unsafe 块中的代码以有效的方式访问内存。人是会犯错误的，错误总会发生，不过通过要求这五类操作必须位于标记为 unsafe 的块中，就能够知道任何与内存安全相关的错误必定位于 unsafe 块内。保持 unsafe 块尽可能小，如此当之后调查内存 bug 时就会感谢你自己了。为了尽可能隔离不安全代码，将不安全代码封装进一个安全的抽象并提供安全 API 是一个好主意，当我们学习不安全函数和方法时会讨论到。标准库的一部分被实现为在被评审过的不安全代码之上的安全抽象。这个技术防止了 unsafe 泄露到所有你或者用户希望使用由 unsafe 代码实现的功能的地方，因为使用其安全抽象是安全的。让我们按顺序依次介绍上述五个超能力，同时我们会看到一些提供不安全代码的安全接口的抽象。","breadcrumbs":"高级特征 » 不安全的 Rust » 不安全的超能力","id":"361","title":"不安全的超能力"},"362":{"body":"回到第四章的 “悬垂引用” 部分，那里提到了编译器会确保引用总是有效的。不安全 Rust 有两个被称为裸指针（ raw pointers ）的类似于引用的新类型。和引用一样，裸指针是不可变或可变的，分别写作 *const T 和 *mut T。这里的星号不是解引用运算符；它是类型名称的一部分。在裸指针的上下文中，不可变意味着指针解引用之后不能直接赋值。裸指针与引用和智能指针的区别在于允许忽略借用规则，可以同时拥有不可变和可变的指针，或多个指向相同位置的可变指针不保证指向有效的内存允许为空不能实现任何自动清理功能通过去掉 Rust 强加的保证，你可以放弃安全保证以换取性能或使用另一个语言或硬件接口的能力，此时 Rust 的保证并不适用。示例 19-1 展示了如何从引用同时创建不可变和可变裸指针。 # fn main() { let mut num = 5; let r1 = &num as *const i32; let r2 = &mut num as *mut i32;\n# } 示例 19-1: 通过引用创建裸指针注意这里没有引入 unsafe 关键字。可以在安全代码中创建裸指针，只是不能在不安全块之外解引用裸指针，稍后便会看到。这里使用 as 将不可变和可变引用强转为对应的裸指针类型。因为直接从保证安全的引用来创建它们，可以知道这些特定的裸指针是有效，但是不能对任何裸指针做出如此假设。作为展示接下来会创建一个不能确定其有效性的裸指针，示例 19-2 展示了如何创建一个指向任意内存地址的裸指针。尝试使用任意内存是未定义行为：此地址可能有数据也可能没有，编译器可能会优化掉这个内存访问，或者程序可能会出现段错误（segmentation fault）。通常没有好的理由编写这样的代码，不过却是可行的： # fn main() { let address = 0x012345usize; let r = address as *const i32;\n# } 示例 19-2: 创建指向任意内存地址的裸指针记得我们说过可以在安全代码中创建裸指针，不过不能解引用裸指针和读取其指向的数据。现在我们要做的就是对裸指针使用解引用运算符 *，这需要一个 unsafe 块，如示例 19-3 所示： # fn main() { let mut num = 5; let r1 = &num as *const i32; let r2 = &mut num as *mut i32; unsafe { println!(\"r1 is: {}\", *r1); println!(\"r2 is: {}\", *r2); }\n# } 示例 19-3: 在 unsafe 块中解引用裸指针创建一个指针不会造成任何危险；只有当访问其指向的值时才有可能遇到无效的值。还需注意示例 19-1 和 19-3 中创建了同时指向相同内存位置 num 的裸指针 *const i32 和 *mut i32。相反如果尝试同时创建 num 的不可变和可变引用，将无法通过编译，因为 Rust 的所有权规则不允许在拥有任何不可变引用的同时再创建一个可变引用。通过裸指针，就能够同时创建同一地址的可变指针和不可变指针，若通过可变指针修改数据，则可能潜在造成数据竞争。请多加小心！既然存在这么多的危险，为何还要使用裸指针呢？一个主要的应用场景便是调用 C 代码接口，这在下一部分 “调用不安全函数或方法” 中会讲到。另一个场景是构建借用检查器无法理解的安全抽象。让我们先介绍不安全函数，接着看一看使用不安全代码的安全抽象的例子。","breadcrumbs":"高级特征 » 不安全的 Rust » 解引用裸指针","id":"362","title":"解引用裸指针"},"363":{"body":"第二类可以在不安全块中进行的操作是调用不安全函数。不安全函数和方法与常规函数方法十分类似，除了其开头有一个额外的 unsafe。在此上下文中，关键字unsafe表示该函数具有调用时需要满足的要求，而 Rust 不会保证满足这些要求。通过在 unsafe 块中调用不安全函数，表明我们已经阅读过此函数的文档并对其是否满足函数自身的契约负责。如下是一个没有做任何操作的不安全函数 dangerous 的例子： # fn main() { unsafe fn dangerous() {} unsafe { dangerous(); }\n# } 必须在一个单独的 unsafe 块中调用 dangerous 函数。如果尝试不使用 unsafe 块调用 dangerous，则会得到一个错误： $ cargo run Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)\nerror[E0133]: call to unsafe function `dangerous` is unsafe and requires unsafe function or block --> src/main.rs:4:5 |\n4 | dangerous(); | ^^^^^^^^^^^ call to unsafe function | = note: consult the function's documentation for information on how to avoid undefined behavior For more information about this error, try `rustc --explain E0133`.\nerror: could not compile `unsafe-example` (bin \"unsafe-example\") due to 1 previous error 通过 unsafe 块，我们向 Rust 保证了我们已经阅读过函数的文档，理解如何正确使用，并验证过其满足函数的契约。不安全函数体也是有效的 unsafe 块，所以在不安全函数中进行另一个不安全操作时无需新增额外的 unsafe 块。创建不安全代码的安全抽象仅仅因为函数包含不安全代码并不意味着整个函数都需要标记为不安全的。事实上，将不安全代码封装进安全函数是一个常见的抽象。作为一个例子，了解一下标准库中的函数 split_at_mut，它需要一些不安全代码，让我们探索如何可以实现它。这个安全函数定义于可变 slice 之上：它获取一个 slice 并从给定的索引参数开始将其分为两个 slice。split_at_mut 的用法如示例 19-4 所示： # fn main() { let mut v = vec![1, 2, 3, 4, 5, 6]; let r = &mut v[..]; let (a, b) = r.split_at_mut(3); assert_eq!(a, &mut [1, 2, 3]); assert_eq!(b, &mut [4, 5, 6]);\n# } 示例 19-4: 使用安全的 split_at_mut 函数这个函数无法只通过安全 Rust 实现。一个尝试可能看起来像示例 19-5，它不能编译。出于简单考虑，我们将 split_at_mut 实现为函数而不是方法，并只处理 i32 值而非泛型 T 的 slice。 fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) { let len = values.len(); assert!(mid <= len); (&mut values[..mid], &mut values[mid..])\n}\n# # fn main() {\n# let mut vector = vec![1, 2, 3, 4, 5, 6];\n# let (left, right) = split_at_mut(&mut vector, 3);\n# } 示例 19-5: 尝试只使用安全 Rust 来实现 split_at_mut 此函数首先获取 slice 的长度，然后通过检查参数是否小于或等于这个长度来断言参数所给定的索引位于 slice 当中。该断言意味着如果传入的索引比要分割的 slice 的索引更大，此函数在尝试使用这个索引前 panic。之后我们在一个元组中返回两个可变的 slice：一个从原始 slice 的开头直到 mid 索引，另一个从 mid 直到原 slice 的结尾。如果尝试编译示例 19-5 的代码，会得到一个错误： $ cargo run Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)\nerror[E0499]: cannot borrow `*values` as mutable more than once at a time --> src/main.rs:6:31 |\n1 | fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) { | - let's call the lifetime of this reference `'1`\n...\n6 | (&mut values[..mid], &mut values[mid..]) | --------------------------^^^^^^-------- | | | | | | | second mutable borrow occurs here | | first mutable borrow occurs here | returning this value requires that `*values` is borrowed for `'1` | = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices For more information about this error, try `rustc --explain E0499`.\nerror: could not compile `unsafe-example` (bin \"unsafe-example\") due to 1 previous error Rust 的借用检查器不能理解我们要借用这个 slice 的两个不同部分：它只知道我们借用了同一个 slice 两次。本质上借用 slice 的不同部分是可以的，因为结果两个 slice 不会重叠，不过 Rust 还没有智能到能够理解这些。当我们知道某些事是可以的而 Rust 不知道的时候，就是触及不安全代码的时候了示例 19-6 展示了如何使用 unsafe 块，裸指针和一些不安全函数调用来实现 split_at_mut： use std::slice; fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) { let len = values.len(); let ptr = values.as_mut_ptr(); assert!(mid <= len); unsafe { ( slice::from_raw_parts_mut(ptr, mid), slice::from_raw_parts_mut(ptr.add(mid), len - mid), ) }\n}\n# # fn main() {\n# let mut vector = vec![1, 2, 3, 4, 5, 6];\n# let (left, right) = split_at_mut(&mut vector, 3);\n# } 示例 19-6: 在 split_at_mut 函数的实现中使用不安全代码回忆第四章的 “Slice 类型” 部分，slice 是一个指向一些数据的指针，并带有该 slice 的长度。可以使用 len 方法获取 slice 的长度，使用 as_mut_ptr 方法访问 slice 的裸指针。在这个例子中，因为有一个 i32 值的可变 slice，as_mut_ptr 返回一个 *mut i32 类型的裸指针，储存在 ptr 变量中。我们保持索引 mid 位于 slice 中的断言。接着是不安全代码：slice::from_raw_parts_mut 函数获取一个裸指针和一个长度来创建一个 slice。这里使用此函数从 ptr 中创建了一个有 mid 个项的 slice。之后在 ptr 上调用 add 方法并使用 mid 作为参数来获取一个从 mid 开始的裸指针，使用这个裸指针并以 mid 之后项的数量为长度创建一个 slice。 slice::from_raw_parts_mut 函数是不安全的因为它获取一个裸指针，并必须确信这个指针是有效的。裸指针上的 add 方法也是不安全的，因为其必须确信此地址偏移量也是有效的指针。因此必须将 slice::from_raw_parts_mut 和 add 放入 unsafe 块中以便能调用它们。通过观察代码，和增加 mid 必然小于等于 len 的断言，我们可以说 unsafe 块中所有的裸指针将是有效的 slice 中数据的指针。这是一个可以接受的 unsafe 的恰当用法。注意无需将 split_at_mut 函数的结果标记为 unsafe，并可以在安全 Rust 中调用此函数。我们创建了一个不安全代码的安全抽象，其代码以一种安全的方式使用了 unsafe 代码，因为其只从这个函数访问的数据中创建了有效的指针。与此相对，示例 19-7 中的 slice::from_raw_parts_mut 在使用 slice 时很有可能会崩溃。这段代码获取任意内存地址并创建了一个长为一万的 slice： # fn main() { use std::slice; let address = 0x01234usize; let r = address as *mut i32; let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) };\n# } 示例 19-7: 通过任意内存地址创建 slice 我们并不拥有这个任意地址的内存，也不能保证这段代码创建的 slice 包含有效的 i32 值。试图使用臆测为有效的 values 会导致未定义的行为。使用 extern 函数调用外部代码有时你的 Rust 代码可能需要与其他语言编写的代码交互。为此 Rust 有一个关键字，extern，有助于创建和使用外部函数接口（ Foreign Function Interface ，FFI）。外部函数接口是一个编程语言用以定义函数的方式，其允许不同（外部）编程语言调用这些函数。示例 19-8 展示了如何集成 C 标准库中的 abs 函数。extern 块中声明的函数在 Rust 代码中总是不安全的。因为其他语言不会强制执行 Rust 的规则且 Rust 无法检查它们，所以确保其安全是程序员的责任：文件名：src/main.rs extern \"C\" { fn abs(input: i32) -> i32;\n} fn main() { unsafe { println!(\"Absolute value of -3 according to C: {}\", abs(-3)); }\n} 示例 19-8: 声明并调用另一个语言中定义的 extern 函数在 extern \"C\" 块中，列出了我们希望能够调用的另一个语言中的外部函数的签名和名称。\"C\" 部分定义了外部函数所使用的应用二进制接口（ application binary interface ，ABI） —— ABI 定义了如何在汇编语言层面调用此函数。\"C\" ABI 是最常见的，并遵循 C 编程语言的 ABI。从其它语言调用 Rust 函数也可以使用 extern 来创建一个允许其他语言调用 Rust 函数的接口。不同于创建整个 extern 块，就在 fn 关键字之前增加 extern 关键字并为相关函数指定所用到的 ABI。还需增加 #[no_mangle] 注解来告诉 Rust 编译器不要 mangle 此函数的名称。 Mangling 发生于当编译器将我们指定的函数名修改为不同的名称时，这会增加用于其他编译过程的额外信息，不过会使其名称更难以阅读。每一个编程语言的编译器都会以稍微不同的方式 mangle 函数名，所以为了使 Rust 函数能在其他语言中指定，必须禁用 Rust 编译器的 name mangling。在如下的例子中，一旦其编译为动态库并从 C 语言中链接，call_from_c 函数就能够在 C 代码中访问： #[no_mangle]\npub extern \"C\" fn call_from_c() { println!(\"Just called a Rust function from C!\");\n} extern 的使用无需 unsafe。","breadcrumbs":"高级特征 » 不安全的 Rust » 调用不安全函数或方法","id":"363","title":"调用不安全函数或方法"},"364":{"body":"目前为止全书都尽量避免讨论全局变量（ global variables ），Rust 确实支持它们，不过这对于 Rust 的所有权规则来说是有问题的。如果有两个线程访问相同的可变全局变量，则可能会造成数据竞争。全局变量在 Rust 中被称为静态（ static ）变量。示例 19-9 展示了一个拥有字符串 slice 值的静态变量的声明和应用：文件名：src/main.rs static HELLO_WORLD: &str = \"Hello, world!\"; fn main() { println!(\"name is: {HELLO_WORLD}\");\n} 示例 19-9: 定义和使用一个不可变静态变量静态（static）变量类似于第三章 “变量和常量的区别” 部分讨论的常量。通常静态变量的名称采用 SCREAMING_SNAKE_CASE 写法。静态变量只能储存拥有 'static 生命周期的引用，这意味着 Rust 编译器可以自己计算出其生命周期而无需显式标注。访问不可变静态变量是安全的。常量与不可变静态变量的一个微妙的区别是静态变量中的值有一个固定的内存地址。使用这个值总是会访问相同的地址。另一方面，常量则允许在任何被用到的时候复制其数据。另一个区别在于静态变量可以是可变的。访问和修改可变静态变量都是不安全的。示例 19-10 展示了如何声明、访问和修改名为 COUNTER 的可变静态变量：文件名：src/main.rs static mut COUNTER: u32 = 0; fn add_to_count(inc: u32) { unsafe { COUNTER += inc; }\n} fn main() { add_to_count(3); unsafe { println!(\"COUNTER: {COUNTER}\"); }\n} 示例 19-10: 读取或修改一个可变静态变量是不安全的就像常规变量一样，我们使用 mut 关键来指定可变性。任何读写 COUNTER 的代码都必须位于 unsafe 块中。这段代码可以编译并如期打印出 COUNTER: 3，因为这是单线程的。拥有多个线程访问 COUNTER 则可能导致数据竞争。拥有可以全局访问的可变数据，难以保证不存在数据竞争，这就是为何 Rust 认为可变静态变量是不安全的。任何可能的情况，请优先使用第十六章讨论的并发技术和线程安全智能指针，这样编译器就能检测不同线程间的数据访问是否是安全的。","breadcrumbs":"高级特征 » 不安全的 Rust » 访问或修改可变静态变量","id":"364","title":"访问或修改可变静态变量"},"365":{"body":"unsafe 的另一个操作用例是实现不安全 trait。当 trait 中至少有一个方法中包含编译器无法验证的不变式（invariant）时 trait 是不安全的。可以在 trait 之前增加 unsafe 关键字将 trait 声明为 unsafe，同时 trait 的实现也必须标记为 unsafe，如示例 19-11 所示： unsafe trait Foo { // methods go here\n} unsafe impl Foo for i32 { // method implementations go here\n} fn main() {} 示例 19-11: 定义并实现不安全 trait 通过 unsafe impl，我们承诺将保证编译器所不能验证的不变量。作为一个例子，回忆第十六章 “使用 Sync 和 Send trait 的可扩展并发” 部分中的 Sync 和 Send 标记 trait，编译器会自动为完全由 Send 和 Sync 类型组成的类型自动实现它们。如果实现了一个包含一些不是 Send 或 Sync 的类型，比如裸指针，并希望将此类型标记为 Send 或 Sync，则必须使用 unsafe。Rust 不能验证我们的类型保证可以安全的跨线程发送或在多线程间访问，所以需要我们自己进行检查并通过 unsafe 表明。","breadcrumbs":"高级特征 » 不安全的 Rust » 实现不安全 trait","id":"365","title":"实现不安全 trait"},"366":{"body":"仅适用于 unsafe 的最后一个操作是访问联合体中的字段，union 和 struct 类似，但是在一个实例中同时只能使用一个声明的字段。联合体主要用于和 C 代码中的联合体交互。访问联合体的字段是不安全的，因为 Rust 无法保证当前存储在联合体实例中数据的类型。可以查看参考 Rust 文档了解有关联合体的更多信息。","breadcrumbs":"高级特征 » 不安全的 Rust » 访问联合体中的字段","id":"366","title":"访问联合体中的字段"},"367":{"body":"使用 unsafe 来进行这五个操作（超能力）之一是没有问题的，甚至是不需要深思熟虑的，不过使得 unsafe 代码正确也实属不易，因为编译器不能帮助保证内存安全。当有理由使用 unsafe 代码时，是可以这么做的，通过使用显式的 unsafe 标注可以更容易地在错误发生时追踪问题的源头。","breadcrumbs":"高级特征 » 不安全的 Rust » 何时使用不安全代码","id":"367","title":"何时使用不安全代码"},"368":{"body":"ch20-03-advanced-traits.md commit 95e931170404cb98d476b19017cbbdbc00d0834d 第十章 “trait：定义共同行为” 部分，我们第一次涉及到了 trait，不过我们并没有覆盖一些较为高级的细节。现在我们更加了解 Rust 了，可以深入理解其本质了。","breadcrumbs":"高级特征 » 高级 trait » 高级 trait","id":"368","title":"高级 trait"},"369":{"body":"关联类型（ associated types ）让我们可以在 trait 里面增加一个待定义的类型（类型占位符），将类型占位符与 trait 相关联，这样 trait 的方法签名中就可以使用这些占位符类型。trait 的实现者在实现这个 trait 的时候，会指定一个具体类型，来替换掉这个占位符。这样，我们可以在一个 trait 中通过占位符使用不同类型，在实现此 trait 时才需要指定这些类型具体是什么。我们之前提到，本章所描述的大部分内容都较少使用。关联类型则比较适中；它们比本书其他的内容要少见，不过比本章中的很多内容要更常见。一个带有关联类型的 trait 的例子是标准库提供的 Iterator trait。它有一个叫做 Item 的关联类型来替代遍历的值的类型。Iterator trait 的定义如示例 19-12 所示： pub trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>;\n} 示例 19-12: Iterator trait 的定义中带有关联类型 Item Item 是一个占位符类型，同时 next 方法的定义表明它返回 Option<Self::Item> 类型的值。这个 trait 的实现者会指定 Item 的具体类型，无论实现者指定何种类型，next 方法都会返回一个包含了此具体类型值的 Option。关联类型看起来有点像泛型：后者允许定义一个函数时，暂不指定其可以处理的类型。为了体现这两者的区别，请看下面的例子。这个例子为 Counter 结构体实现了 Iterator trait，其中指定 Item 的类型为 u32：文件名：src/lib.rs # struct Counter {\n# count: u32,\n# }\n# # impl Counter {\n# fn new() -> Counter {\n# Counter { count: 0 }\n# }\n# }\n# impl Iterator for Counter { type Item = u32; fn next(&mut self) -> Option<Self::Item> { // --snip--\n# if self.count < 5 {\n# self.count += 1;\n# Some(self.count)\n# } else {\n# None\n# }\n# }\n# } 这个语法类似于泛型。那么为什么 Iterator trait 不像下面示例 19-13 那样，使用泛型来定义呢？ pub trait Iterator<T> { fn next(&mut self) -> Option<T>;\n} 示例 19-13: 一个使用泛型的 Iterator trait 假想定义区别在于当如示例 19-13 那样使用泛型时，则不得不在每一个实现中标注类型。这是因为我们也可以实现为 Iterator<String> for Counter，或任何其他类型，这样就可以有多个 Counter 的 Iterator 的实现。换句话说，当 trait 有泛型参数时，可以多次实现这个 trait，每次需改变泛型参数的具体类型。接着当使用 Counter 的 next 方法时，必须提供类型注解来表明希望使用 Iterator 的哪一个实现。有了关联类型，在实现时就无需标注类型，因为不能多次实现这个 trait。对于示例 19-12 使用关联类型的定义，我们只能选择一次 Item 会是什么类型，因为只能有一个 impl Iterator for Counter。当调用 Counter 的 next 时不必每次指定我们需要 u32 值的迭代器。关联类型也会成为 trait 契约的一部分：trait 的实现必须提供一个类型来替代关联类型占位符。关联类型通常以它的用途来命名，并且我们最好在 API 文档中为关联类型编写文档。","breadcrumbs":"高级特征 » 高级 trait » 关联类型在 trait 定义中指定占位符类型","id":"369","title":"关联类型在 trait 定义中指定占位符类型"},"37":{"body":"除了位于结尾的右花括号，目前为止就只有这一行代码值得讨论一下了，就是这一行： # use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# println!(\"You guessed: {}\", guess);\n# } 这行代码现在打印了存储用户输入的字符串。{} 这对大括号是一个占位符：把 {} 想象成小蟹钳，可以夹住合适的值。当打印变量的值时，变量名可以写进大括号中。当打印表达式的执行结果时，格式化字符串（format string）中大括号中留空，格式化字符串后跟逗号分隔的需要打印的表达式列表，其顺序与每一个空大括号占位符的顺序一致。在一个 println! 调用中打印变量和表达式的值看起来像这样： let x = 5;\nlet y = 10; println!(\"x = {x} and y + 2 = {}\", y + 2); 这行代码会打印出 x = 5 and y + 2 = 12。","breadcrumbs":"写个猜数字游戏 » 使用 println! 占位符打印值","id":"37","title":"使用 println! 占位符打印值"},"370":{"body":"当使用泛型类型参数时，可以为泛型指定一个默认的具体类型。如果默认类型就足够的话，这消除了为具体类型实现 trait 的需要。为泛型类型指定默认类型的语法是在声明泛型类型时使用 <PlaceholderType=ConcreteType>。这种情况的一个非常好的例子是使用运算符重载（ Operator overloading ），这是指在特定情况下自定义运算符（比如 +）行为的操作。 Rust 并不允许创建自定义运算符或重载任意运算符，不过 std::ops 中所列出的运算符和相应的 trait 可以通过实现运算符相关 trait 来重载。例如，示例 19-14 中展示了如何在 Point 结构体上实现 Add trait 来重载 + 运算符，这样就可以将两个 Point 实例相加了：文件名：src/main.rs use std::ops::Add; #[derive(Debug, Copy, Clone, PartialEq)]\nstruct Point { x: i32, y: i32,\n} impl Add for Point { type Output = Point; fn add(self, other: Point) -> Point { Point { x: self.x + other.x, y: self.y + other.y, } }\n} fn main() { assert_eq!( Point { x: 1, y: 0 } + Point { x: 2, y: 3 }, Point { x: 3, y: 3 } );\n} 示例 19-14: 实现 Add trait 重载 Point 实例的 + 运算符 add 方法将两个 Point 实例的 x 值和 y 值分别相加来创建一个新的 Point。Add trait 有一个叫做 Output 的关联类型，它用来决定 add 方法的返回值类型。这里默认泛型类型位于 Add trait 中。这里是其定义： trait Add<Rhs=Self> { type Output; fn add(self, rhs: Rhs) -> Self::Output;\n} 这些代码看来应该很熟悉，这是一个带有一个方法和一个关联类型的 trait。比较陌生的部分是尖括号中的 Rhs=Self：这个语法叫做默认类型参数（ default type parameters ）。Rhs 是一个泛型类型参数（“right hand side” 的缩写），它用于定义 add 方法中的 rhs 参数。如果实现 Add trait 时不指定 Rhs 的具体类型，Rhs 的类型将是默认的 Self 类型，也就是在其上实现 Add 的类型。当为 Point 实现 Add 时，使用了默认的 Rhs，因为我们希望将两个 Point 实例相加。让我们看看一个实现 Add trait 时希望自定义 Rhs 类型而不是使用默认类型的例子。这里有两个存放不同单元值的结构体，Millimeters 和 Meters。（这种将现有类型简单封装进另一个结构体的方式被称为 newtype 模式（ newtype pattern ，之后的 “为了类型安全和抽象而使用 newtype 模式” 部分会详细介绍。）我们希望能够将毫米值与米值相加，并让 Add 的实现正确处理转换。可以为 Millimeters 实现 Add 并以 Meters 作为 Rhs，如示例 19-15 所示。文件名：src/lib.rs use std::ops::Add; struct Millimeters(u32);\nstruct Meters(u32); impl Add<Meters> for Millimeters { type Output = Millimeters; fn add(self, other: Meters) -> Millimeters { Millimeters(self.0 + (other.0 * 1000)) }\n} 示例 19-15: 在 Millimeters 上实现 Add，以便能够将 Millimeters 与 Meters 相加为了使 Millimeters 和 Meters 能够相加，我们指定 impl Add<Meters> 来设定 Rhs 类型参数的值而不是使用默认的 Self。默认参数类型主要用于如下两个方面：扩展类型而不破坏现有代码。在大部分用户都不需要的特定情况进行自定义。标准库的 Add trait 就是一个第二个目的例子：大部分时候你会将两个相似的类型相加，不过它提供了自定义额外行为的能力。在 Add trait 定义中使用默认类型参数意味着大部分时候无需指定额外的参数。换句话说，一小部分实现的样板代码是不必要的，这样使用 trait 就更容易了。第一个目的是相似的，但过程是反过来的：如果需要为现有 trait 增加类型参数，为其提供一个默认类型将允许我们在不破坏现有实现代码的基础上扩展 trait 的功能。","breadcrumbs":"高级特征 » 高级 trait » 默认泛型类型参数和运算符重载","id":"370","title":"默认泛型类型参数和运算符重载"},"371":{"body":"Rust 既不能避免一个 trait 与另一个 trait 拥有相同名称的方法，也不能阻止为同一类型同时实现这两个 trait。甚至直接在类型上实现开始已经有的同名方法也是可能的！不过，当调用这些同名方法时，需要告诉 Rust 我们希望使用哪一个。考虑一下示例 19-16 中的代码，这里定义了 trait Pilot 和 Wizard 都拥有方法 fly。接着在一个本身已经实现了名为 fly 方法的类型 Human 上实现这两个 trait。每一个 fly 方法都进行了不同的操作：文件名：src/main.rs trait Pilot { fn fly(&self);\n} trait Wizard { fn fly(&self);\n} struct Human; impl Pilot for Human { fn fly(&self) { println!(\"This is your captain speaking.\"); }\n} impl Wizard for Human { fn fly(&self) { println!(\"Up!\"); }\n} impl Human { fn fly(&self) { println!(\"*waving arms furiously*\"); }\n}\n# # fn main() {} 示例 19-16: 两个 trait 定义为拥有 fly 方法，并在直接定义有 fly 方法的 Human 类型上实现这两个 trait 当调用 Human 实例的 fly 时，编译器默认调用直接实现在类型上的方法，如示例 19-17 所示。文件名：src/main.rs # trait Pilot {\n# fn fly(&self);\n# }\n# # trait Wizard {\n# fn fly(&self);\n# }\n# # struct Human;\n# # impl Pilot for Human {\n# fn fly(&self) {\n# println!(\"This is your captain speaking.\");\n# }\n# }\n# # impl Wizard for Human {\n# fn fly(&self) {\n# println!(\"Up!\");\n# }\n# }\n# # impl Human {\n# fn fly(&self) {\n# println!(\"*waving arms furiously*\");\n# }\n# }\n# fn main() { let person = Human; person.fly();\n} 示例 19-17: 调用 Human 实例的 fly 运行这段代码会打印出 *waving arms furiously*，这表明 Rust 调用了直接实现在 Human 上的 fly 方法。为了能够调用 Pilot trait 或 Wizard trait 的 fly 方法，我们需要使用更明显的语法以便能指定我们指的是哪个 fly 方法。这个语法展示在示例 19-18 中：文件名：src/main.rs # trait Pilot {\n# fn fly(&self);\n# }\n# # trait Wizard {\n# fn fly(&self);\n# }\n# # struct Human;\n# # impl Pilot for Human {\n# fn fly(&self) {\n# println!(\"This is your captain speaking.\");\n# }\n# }\n# # impl Wizard for Human {\n# fn fly(&self) {\n# println!(\"Up!\");\n# }\n# }\n# # impl Human {\n# fn fly(&self) {\n# println!(\"*waving arms furiously*\");\n# }\n# }\n# fn main() { let person = Human; Pilot::fly(&person); Wizard::fly(&person); person.fly();\n} 示例 19-18: 指定我们希望调用哪一个 trait 的 fly 方法在方法名前指定 trait 名向 Rust 澄清了我们希望调用哪个 fly 实现。也可以选择写成 Human::fly(&person)，这等同于示例 19-18 中的 person.fly()，不过如果无需消歧义的话这么写就有点长了。运行这段代码会打印出： $ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.46s Running `target/debug/traits-example`\nThis is your captain speaking.\nUp!\n*waving arms furiously* 因为 fly 方法获取一个 self 参数，如果有两个类型都实现了同一 trait ，Rust 可以根据 self 的类型计算出应该使用哪一个 trait 实现。然而，不是方法的关联函数没有 self 参数。当存在多个类型或者 trait 定义了相同函数名的非方法函数时，Rust 就不总是能计算出我们期望的是哪一个类型，除非使用完全限定语法（ fully qualified syntax ）。例如示例 19-19 中的创建了一个希望将所有小狗叫做 Spot 的动物收容所的 trait。Animal trait 有一个关联非方法函数 baby_name。结构体 Dog 实现了 Animal，同时又直接提供了关联非方法函数 baby_name。文件名：src/main.rs trait Animal { fn baby_name() -> String;\n} struct Dog; impl Dog { fn baby_name() -> String { String::from(\"Spot\") }\n} impl Animal for Dog { fn baby_name() -> String { String::from(\"puppy\") }\n} fn main() { println!(\"A baby dog is called a {}\", Dog::baby_name());\n} 示例 19-19: 一个带有关联函数的 trait 和一个带有同名关联函数并实现了此 trait 的类型 Dog 上定义的关联函数 baby_name 的实现代码将所有的小狗起名为 Spot。Dog 类型还实现了 Animal trait，它描述了所有动物的共有的特征。小狗被称为 puppy，这表现为 Dog 的 Animal trait 实现中与 Animal trait 相关联的函数 baby_name。在 main 调用了 Dog::baby_name 函数，它直接调用了定义于 Dog 之上的关联函数。这段代码会打印出： $ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.54s Running `target/debug/traits-example`\nA baby dog is called a Spot 这并不是我们需要的。我们希望调用的是 Dog 上 Animal trait 实现那部分的 baby_name 函数，这样能够打印出 A baby dog is called a puppy。示例 19-18 中用到的技术在这并不管用；如果将 main 改为示例 19-20 中的代码，则会得到一个编译错误：文件名：src/main.rs # trait Animal {\n# fn baby_name() -> String;\n# }\n# # struct Dog;\n# # impl Dog {\n# fn baby_name() -> String {\n# String::from(\"Spot\")\n# }\n# }\n# # impl Animal for Dog {\n# fn baby_name() -> String {\n# String::from(\"puppy\")\n# }\n# }\n# fn main() { println!(\"A baby dog is called a {}\", Animal::baby_name());\n} 示例 19-20: 尝试调用 Animal trait 的 baby_name 函数，不过 Rust 并不知道该使用哪一个实现因为 Animal::baby_name 没有 self 参数，同时这可能会有其它类型实现了 Animal trait，Rust 无法计算出所需的是哪一个 Animal::baby_name 实现。我们会得到这个编译错误： $ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example)\nerror[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type --> src/main.rs:20:43 |\n2 | fn baby_name() -> String; | ------------------------- `Animal::baby_name` defined here\n...\n20 | println!(\"A baby dog is called a {}\", Animal::baby_name()); | ^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait |\nhelp: use the fully-qualified path to the only available implementation |\n20 | println!(\"A baby dog is called a {}\", <Dog as Animal>::baby_name()); | +++++++ + For more information about this error, try `rustc --explain E0790`.\nerror: could not compile `traits-example` (bin \"traits-example\") due to 1 previous error 为了消歧义并告诉 Rust 我们希望使用的是 Dog 的 Animal 实现而不是其它类型的 Animal 实现，需要使用完全限定语法，这是调用函数时最为明确的方式。示例 19-21 展示了如何使用完全限定语法：文件名：src/main.rs # trait Animal {\n# fn baby_name() -> String;\n# }\n# # struct Dog;\n# # impl Dog {\n# fn baby_name() -> String {\n# String::from(\"Spot\")\n# }\n# }\n# # impl Animal for Dog {\n# fn baby_name() -> String {\n# String::from(\"puppy\")\n# }\n# }\n# fn main() { println!(\"A baby dog is called a {}\", <Dog as Animal>::baby_name());\n} 示例 19-21: 使用完全限定语法来指定我们希望调用的是 Dog 上 Animal trait 实现中的 baby_name 函数我们在尖括号中向 Rust 提供了类型注解，并通过在此函数调用中将 Dog 类型当作 Animal 对待，来指定希望调用的是 Dog 上 Animal trait 实现中的 baby_name 函数。现在这段代码会打印出我们期望的数据： $ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s Running `target/debug/traits-example`\nA baby dog is called a puppy 通常，完全限定语法定义为： <Type as Trait>::function(receiver_if_method, next_arg, ...); 对于不是方法的关联函数，其没有一个 receiver，故只会有其他参数的列表。可以选择在任何函数或方法调用处使用完全限定语法。然而，允许省略任何 Rust 能够从程序中的其他信息中计算出的部分。只有当存在多个同名实现而 Rust 需要帮助以便知道我们希望调用哪个实现时，才需要使用这个较为冗长的语法。","breadcrumbs":"高级特征 » 高级 trait » 完全限定语法与消歧义：调用相同名称的方法","id":"371","title":"完全限定语法与消歧义：调用相同名称的方法"},"372":{"body":"有时我们可能会需要编写一个依赖另一个 trait 的 trait 定义：对于一个实现了第一个 trait 的类型，你希望要求这个类型也实现了第二个 trait。如此就可使 trait 定义使用第二个 trait 的关联项。这个所需的 trait 是我们实现的 trait 的父（超）trait （ supertrait ）。例如我们希望创建一个带有 outline_print 方法的 trait OutlinePrint，它会将给定的值格式化为带有星号框。也就是说，给定一个实现了标准库 Display trait 的并返回 (x, y) 的 Point，当调用以 1 作为 x 和 3 作为 y 的 Point 实例的 outline_print 会显示如下： **********\n* *\n* (1, 3) *\n* *\n********** 在 outline_print 的实现中，因为希望能够使用 Display trait 的功能，则需要说明 OutlinePrint 只能用于同时也实现了 Display 并提供了 OutlinePrint 需要的功能的类型。可以通过在 trait 定义中指定 OutlinePrint: Display 来做到这一点。这类似于为 trait 增加 trait bound。示例 19-22 展示了一个 OutlinePrint trait 的实现：文件名：src/main.rs use std::fmt; trait OutlinePrint: fmt::Display { fn outline_print(&self) { let output = self.to_string(); let len = output.len(); println!(\"{}\", \"*\".repeat(len + 4)); println!(\"*{}*\", \" \".repeat(len + 2)); println!(\"* {output} *\"); println!(\"*{}*\", \" \".repeat(len + 2)); println!(\"{}\", \"*\".repeat(len + 4)); }\n}\n# # fn main() {} 示例 19-22: 实现 OutlinePrint trait，它要求来自 Display 的功能因为指定了 OutlinePrint 需要 Display trait，则可以在 outline_print 中使用 to_string，其会为任何实现 Display 的类型自动实现。如果不在 trait 名后增加 : Display 并尝试在 outline_print 中使用 to_string，则会得到一个错误说在当前作用域中没有找到用于 &Self 类型的方法 to_string。让我们看看如果尝试在一个没有实现 Display 的类型上实现 OutlinePrint 会发生什么，比如 Point 结构体：文件名：src/main.rs # use std::fmt;\n# # trait OutlinePrint: fmt::Display {\n# fn outline_print(&self) {\n# let output = self.to_string();\n# let len = output.len();\n# println!(\"{}\", \"*\".repeat(len + 4));\n# println!(\"*{}*\", \" \".repeat(len + 2));\n# println!(\"* {output} *\");\n# println!(\"*{}*\", \" \".repeat(len + 2));\n# println!(\"{}\", \"*\".repeat(len + 4));\n# }\n# }\n# struct Point { x: i32, y: i32,\n} impl OutlinePrint for Point {}\n# # fn main() {\n# let p = Point { x: 1, y: 3 };\n# p.outline_print();\n# } 这样会得到一个错误说 Display 是必须的而未被实现： $ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example)\nerror[E0277]: `Point` doesn't implement `std::fmt::Display` --> src/main.rs:20:23 |\n20 | impl OutlinePrint for Point {} | ^^^^^ `Point` cannot be formatted with the default formatter | = help: the trait `std::fmt::Display` is not implemented for `Point` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead\nnote: required by a bound in `OutlinePrint` --> src/main.rs:3:21 |\n3 | trait OutlinePrint: fmt::Display { | ^^^^^^^^^^^^ required by this bound in `OutlinePrint` error[E0277]: `Point` doesn't implement `std::fmt::Display` --> src/main.rs:24:7 |\n24 | p.outline_print(); | ^^^^^^^^^^^^^ `Point` cannot be formatted with the default formatter | = help: the trait `std::fmt::Display` is not implemented for `Point` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead\nnote: required by a bound in `OutlinePrint::outline_print` --> src/main.rs:3:21 |\n3 | trait OutlinePrint: fmt::Display { | ^^^^^^^^^^^^ required by this bound in `OutlinePrint::outline_print`\n4 | fn outline_print(&self) { | ------------- required by a bound in this associated function For more information about this error, try `rustc --explain E0277`.\nerror: could not compile `traits-example` (bin \"traits-example\") due to 2 previous errors 一旦在 Point 上实现 Display 并满足 OutlinePrint 要求的限制，比如这样：文件名：src/main.rs # trait OutlinePrint: fmt::Display {\n# fn outline_print(&self) {\n# let output = self.to_string();\n# let len = output.len();\n# println!(\"{}\", \"*\".repeat(len + 4));\n# println!(\"*{}*\", \" \".repeat(len + 2));\n# println!(\"* {output} *\");\n# println!(\"*{}*\", \" \".repeat(len + 2));\n# println!(\"{}\", \"*\".repeat(len + 4));\n# }\n# }\n# # struct Point {\n# x: i32,\n# y: i32,\n# }\n# # impl OutlinePrint for Point {}\n# use std::fmt; impl fmt::Display for Point { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, \"({}, {})\", self.x, self.y) }\n}\n# # fn main() {\n# let p = Point { x: 1, y: 3 };\n# p.outline_print();\n# } 那么在 Point 上实现 OutlinePrint trait 将能成功编译，并可以在 Point 实例上调用 outline_print 来显示位于星号框中的点的值。","breadcrumbs":"高级特征 » 高级 trait » 父 trait 用于在另一个 trait 中使用某 trait 的功能","id":"372","title":"父 trait 用于在另一个 trait 中使用某 trait 的功能"},"373":{"body":"在第十章的 “为类型实现 trait” 部分，我们提到了孤儿规则（orphan rule），它说明只要 trait 或类型对于当前 crate 是本地的话就可以在此类型上实现该 trait。一个绕开这个限制的方法是使用 newtype 模式（ newtype pattern ），它涉及到在一个元组结构体（第五章 “用没有命名字段的元组结构体来创建不同的类型” 部分介绍了元组结构体）中创建一个新类型。这个元组结构体带有一个字段作为希望实现 trait 的类型的简单封装。接着这个封装类型对于 crate 是本地的，这样就可以在这个封装上实现 trait。 Newtype 是一个源自 Haskell 编程语言的概念。使用这个模式没有运行时性能惩罚，这个封装类型在编译时就被省略了。例如，如果想要在 Vec<T> 上实现 Display，而孤儿规则阻止我们直接这么做，因为 Display trait 和 Vec<T> 都定义于我们的 crate 之外。可以创建一个包含 Vec<T> 实例的 Wrapper 结构体，接着可以如列表 19-23 那样在 Wrapper 上实现 Display 并使用 Vec<T> 的值：文件名：src/main.rs use std::fmt; struct Wrapper(Vec<String>); impl fmt::Display for Wrapper { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, \"[{}]\", self.0.join(\", \")) }\n} fn main() { let w = Wrapper(vec![String::from(\"hello\"), String::from(\"world\")]); println!(\"w = {w}\");\n} 示例 19-23: 创建 Wrapper 类型封装 Vec<String> 以便能够实现 Display Display 的实现使用 self.0 来访问其内部的 Vec<T>，因为 Wrapper 是元组结构体而 Vec<T> 是结构体总位于索引 0 的项。接着就可以使用 Wrapper 中 Display 的功能了。此方法的缺点是，因为 Wrapper 是一个新类型，它没有定义于其值之上的方法；必须直接在 Wrapper 上实现 Vec<T> 的所有方法，这样就可以代理到self.0 上 —— 这就允许我们完全像 Vec<T> 那样对待 Wrapper。如果希望新类型拥有其内部类型的每一个方法，为封装类型实现 Deref trait（第十五章 “通过 Deref trait 将智能指针当作常规引用处理” 部分讨论过）并返回其内部类型是一种解决方案。如果不希望封装类型拥有所有内部类型的方法 —— 比如为了限制封装类型的行为 —— 则必须只自行实现所需的方法。甚至当不涉及 trait 时 newtype 模式也很有用。现在让我们将话题的焦点转移到一些与 Rust 类型系统交互的高级方法上来吧。","breadcrumbs":"高级特征 » 高级 trait » newtype 模式用以在外部类型上实现外部 trait","id":"373","title":"newtype 模式用以在外部类型上实现外部 trait"},"374":{"body":"ch20-04-advanced-types.md commit 95e931170404cb98d476b19017cbbdbc00d0834d Rust 的类型系统有一些我们曾经提到但没有讨论过的功能。首先我们从一个关于为什么 newtype 与类型一样有用的更宽泛的讨论开始。接着会转向类型别名（type aliases），一个类似于 newtype 但有着稍微不同的语义的功能。我们还会讨论 ! 类型和动态大小类型。这一部分假设你已经阅读了之前的 “newtype 模式用于在外部类型上实现外部 trait” 部分。","breadcrumbs":"高级特征 » 高级类型 » 高级类型","id":"374","title":"高级类型"},"375":{"body":"newtype 模式也可以用于一些其他我们还未讨论的功能，包括静态的确保某值不被混淆，和用来表示一个值的单位。实际上示例 19-15 中已经有一个这样的例子：Millimeters 和 Meters 结构体都在 newtype 中封装了 u32 值。如果编写了一个有 Millimeters 类型参数的函数，不小心使用 Meters 或普通的 u32 值来调用该函数的程序是不能编译的。 newtype 模式也可以用于抽象掉一些类型的实现细节：例如，封装类型可以暴露出与直接使用其内部私有类型时所不同的公有 API。 newtype 也可以隐藏其内部的泛型类型。例如，可以提供一个封装了 HashMap<i32, String> 的 People 类型，用来储存人名以及相应的 ID。使用 People 的代码只需与提供的公有 API 交互即可，比如向 People 集合增加名字字符串的方法，这样这些代码就无需知道在内部我们将一个 i32 ID 赋予了这个名字了。newtype 模式是一种实现第十八章 “封装隐藏了实现细节” 部分所讨论的隐藏实现细节的封装的轻量级方法。","breadcrumbs":"高级特征 » 高级类型 » 为了类型安全和抽象而使用 newtype 模式","id":"375","title":"为了类型安全和抽象而使用 newtype 模式"},"376":{"body":"Rust 提供了声明类型别名（ type alias ）的能力，使用 type 关键字来给予现有类型另一个名字。例如，可以像这样创建 i32 的别名 Kilometers： # fn main() { type Kilometers = i32;\n# # let x: i32 = 5;\n# let y: Kilometers = 5;\n# # println!(\"x + y = {}\", x + y);\n# } 这意味着 Kilometers 是 i32 的同义词（ synonym ）；不同于示例 19-15 中创建的 Millimeters 和 Meters 类型。Kilometers 不是一个新的、单独的类型。Kilometers 类型的值将被完全当作 i32 类型值来对待： # fn main() { type Kilometers = i32; let x: i32 = 5; let y: Kilometers = 5; println!(\"x + y = {}\", x + y);\n# } 因为 Kilometers 是 i32 的别名，它们是同一类型，可以将 i32 与 Kilometers 相加，也可以将 Kilometers 传递给获取 i32 参数的函数。但通过这种手段无法获得上一部分讨论的 newtype 模式所提供的类型检查的好处。换句话说，如果在哪里混用 Kilometers 和 i32 的值，编译器也不会给出一个错误。类型别名的主要用途是减少重复。例如，可能会有这样很长的类型： Box<dyn Fn() + Send + 'static> 在函数签名或类型注解中每次都书写这个类型将是枯燥且易于出错的。想象一下如示例 19-24 这样全是如此代码的项目： # fn main() { let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!(\"hi\")); fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) { // --snip-- } fn returns_long_type() -> Box<dyn Fn() + Send + 'static> { // --snip--\n# Box::new(|| ()) }\n# } 示例 19-24: 在很多地方使用名称很长的类型类型别名通过减少项目中重复代码的数量来使其更加易于控制。这里我们为这个冗长的类型引入了一个叫做 Thunk 的别名，这样就可以如示例 19-25 所示将所有使用这个类型的地方替换为更短的 Thunk： # fn main() { type Thunk = Box<dyn Fn() + Send + 'static>; let f: Thunk = Box::new(|| println!(\"hi\")); fn takes_long_type(f: Thunk) { // --snip-- } fn returns_long_type() -> Thunk { // --snip--\n# Box::new(|| ()) }\n# } 示例 19-25: 引入类型别名 Thunk 来减少重复这样读写起来就容易多了！为类型别名选择一个好名字也可以帮助你表达意图（单词 thunk 表示会在之后被计算的代码，所以这是一个存放闭包的合适的名字）。类型别名也经常与 Result<T, E> 结合使用来减少重复。考虑一下标准库中的 std::io 模块。I/O 操作通常会返回一个 Result<T, E>，因为这些操作可能会失败。标准库中的 std::io::Error 结构体代表了所有可能的 I/O 错误。std::io 中大部分函数会返回 Result<T, E>，其中 E 是 std::io::Error，比如 Write trait 中的这些函数： use std::fmt;\nuse std::io::Error; pub trait Write { fn write(&mut self, buf: &[u8]) -> Result<usize, Error>; fn flush(&mut self) -> Result<(), Error>; fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>; fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;\n} 这里出现了很多的 Result<..., Error>。为此，std::io 有这个类型别名声明： # use std::fmt;\n# type Result<T> = std::result::Result<T, std::io::Error>;\n# # pub trait Write {\n# fn write(&mut self, buf: &[u8]) -> Result<usize>;\n# fn flush(&mut self) -> Result<()>;\n# # fn write_all(&mut self, buf: &[u8]) -> Result<()>;\n# fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;\n# } 因为这位于 std::io 中，可用的完全限定的别名是 std::io::Result<T>；也就是说，Result<T, E> 中 E 放入了 std::io::Error。Write trait 中的函数最终看起来像这样： # use std::fmt;\n# # type Result<T> = std::result::Result<T, std::io::Error>;\n# pub trait Write { fn write(&mut self, buf: &[u8]) -> Result<usize>; fn flush(&mut self) -> Result<()>; fn write_all(&mut self, buf: &[u8]) -> Result<()>; fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;\n} 类型别名在两个方面有帮助：易于编写并在整个 std::io 中提供了一致的接口。因为这是一个别名，它只是另一个 Result<T, E>，这意味着可以在其上使用 Result<T, E> 的任何方法，以及像 ? 这样的特殊语法。","breadcrumbs":"高级特征 » 高级类型 » 类型别名用来创建类型同义词","id":"376","title":"类型别名用来创建类型同义词"},"377":{"body":"Rust 有一个叫做 ! 的特殊类型。在类型理论术语中，它被称为 empty type ，因为它没有值。我们更倾向于称之为 never type 。这个名字描述了它的作用：在函数从不返回的时候充当返回值。例如： fn bar() -> ! { // --snip--\n# panic!();\n} 这读 “函数 bar 从不返回”，而从不返回的函数被称为发散函数（ diverging functions ）。不能创建 ! 类型的值，所以 bar 也不可能返回值。不过一个不能创建值的类型有什么用呢？如果你回想一下示例 2-5 中的代码，曾经有一些看起来像这样的代码，如示例 19-26 所重现的： # use rand::Rng;\n# use std::cmp::Ordering;\n# use std::io;\n# # fn main() {\n# println!(\"Guess the number!\");\n# # let secret_number = rand::thread_rng().gen_range(1..=100);\n# # println!(\"The secret number is: {secret_number}\");\n# # loop {\n# println!(\"Please input your guess.\");\n# # let mut guess = String::new();\n# # // --snip--\n# # io::stdin()\n# .read_line(&mut guess)\n# .expect(\"Failed to read line\");\n# let guess: u32 = match guess.trim().parse() { Ok(num) => num, Err(_) => continue, };\n# # println!(\"You guessed: {guess}\");\n# # // --snip--\n# # match guess.cmp(&secret_number) {\n# Ordering::Less => println!(\"Too small!\"),\n# Ordering::Greater => println!(\"Too big!\"),\n# Ordering::Equal => {\n# println!(\"You win!\");\n# break;\n# }\n# }\n# }\n# } 示例 19-26: match 语句和一个以 continue 结束的分支当时我们忽略了代码中的一些细节。在第六章 “match 控制流运算符” 部分，我们学习了 match 的分支必须返回相同的类型。如下代码不能工作： # fn main() {\n# let guess = \"3\"; let guess = match guess.trim().parse() { Ok(_) => 5, Err(_) => \"hello\", };\n# } 这里的 guess 必须既是整型也是字符串，而 Rust 要求 guess 只能是一个类型。那么 continue 返回了什么呢？为什么示例 19-26 中会允许一个分支返回 u32 而另一个分支却以 continue 结束呢？正如你可能猜到的，continue 的值是 !。也就是说，当 Rust 要计算 guess 的类型时，它查看这两个分支。前者是 u32 值，而后者是 ! 值。因为 ! 并没有一个值，Rust 决定 guess 的类型是 u32。描述 ! 的行为的正式方式是 never type 可以强转为任何其他类型。允许 match 的分支以 continue 结束是因为 continue 并不真正返回一个值；相反它把控制权交回上层循环，所以在 Err 的情况，事实上并未对 guess 赋值。 never type 的另一个用途是 panic!。还记得 Option<T> 上的 unwrap 函数吗？它产生一个值或 panic。这里是它的定义： # enum Option<T> {\n# Some(T),\n# None,\n# }\n# # use crate::Option::*;\n# impl<T> Option<T> { pub fn unwrap(self) -> T { match self { Some(val) => val, None => panic!(\"called `Option::unwrap()` on a `None` value\"), } }\n} 这里与示例 19-34 中的 match 发生了相同的情况：Rust 知道 val 是 T 类型，panic! 是 ! 类型，所以整个 match 表达式的结果是 T 类型。这能工作是因为 panic! 并不产生一个值；它会终止程序。对于 None 的情况，unwrap 并不返回一个值，所以这些代码是有效的。最后一个有着 ! 类型的表达式是 loop： # fn main() { print!(\"forever \"); loop { print!(\"and ever \"); }\n# } 这里，循环永远也不结束，所以此表达式的值是 !。但是如果引入 break 这就不为真了，因为循环在执行到 break 后就会终止。","breadcrumbs":"高级特征 » 高级类型 » 从不返回的 never type","id":"377","title":"从不返回的 never type"},"378":{"body":"Rust 需要知道有关类型的某些细节，例如为特定类型的值需要分配多少空间。这便是起初留下的一个类型系统中令人迷惑的角落：即动态大小类型（ dynamically sized types ）。这有时被称为 “DST” 或 “unsized types”，这些类型允许我们处理只有在运行时才知道大小的类型。让我们深入研究一个贯穿本书都在使用的动态大小类型的细节：str。没错，不是 &str，而是 str 本身。str 是一个 DST；直到运行时我们都不知道字符串有多长。因为直到运行时都不能知道其大小，也就意味着不能创建 str 类型的变量，也不能获取 str 类型的参数。考虑一下这些代码，它们不能工作： # fn main() { let s1: str = \"Hello there!\"; let s2: str = \"How's it going?\";\n# } Rust 需要知道应该为特定类型的值分配多少内存，同时所有同一类型的值必须使用相同数量的内存。如果允许编写这样的代码，也就意味着这两个 str 需要占用完全相同大小的空间，不过它们有着不同的长度。这也就是为什么不可能创建一个存放动态大小类型的变量的原因。那么该怎么办呢？你已经知道了这种问题的答案：s1 和 s2 的类型是 &str 而不是 str。如果你回想第四章 “字符串 slice” 部分，slice 数据结构仅仅储存了开始位置和 slice 的长度。所以虽然 &T 是一个储存了 T 所在的内存位置的单个值，&str 则是两个值：str 的地址和其长度。这样，&str 就有了一个在编译时可以知道的大小：它是 usize 长度的两倍。也就是说，我们总是知道 &str 的大小，而无论其引用的字符串是多长。这里是 Rust 中动态大小类型的常规用法：它们有一些额外的元信息来储存动态信息的大小。这引出了动态大小类型的黄金规则：必须将动态大小类型的值置于某种指针之后。可以将 str 与所有类型的指针结合：比如 Box<str> 或 Rc<str>。事实上，之前我们已经见过了，不过是另一个动态大小类型：trait。每一个 trait 都是一个可以通过 trait 名称来引用的动态大小类型。在第十八章顾及不同类型值的 trait 对象” 部分，我们提到了为了将 trait 用于 trait 对象，必须将它们放入指针之后，比如 &dyn Trait 或 Box<dyn Trait>（Rc<dyn Trait> 也可以）。为了处理 DST，Rust 提供了 Sized trait 来决定一个类型的大小是否在编译时可知。这个 trait 自动为编译器在编译时就知道大小的类型实现。另外，Rust 隐式的为每一个泛型函数增加了 Sized bound。也就是说，对于如下泛型函数定义： fn generic<T>(t: T) { // --snip--\n} 实际上被当作如下处理： fn generic<T: Sized>(t: T) { // --snip--\n} 泛型函数默认只能用于在编译时已知大小的类型。然而可以使用如下特殊语法来放宽这个限制： fn generic<T: ?Sized>(t: &T) { // --snip--\n} ?Sized 上的 trait bound 意味着 “T 可能是也可能不是 Sized” 同时这个注解会覆盖泛型类型必须在编译时拥有固定大小的默认规则。这种意义的 ?Trait 语法只能用于 Sized ，而不能用于任何其他 trait。另外注意我们将 t 参数的类型从 T 变为了 &T：因为其类型可能不是 Sized 的，所以需要将其置于某种指针之后。在这个例子中选择了引用。接下来，让我们讨论一下函数和闭包！","breadcrumbs":"高级特征 » 高级类型 » 动态大小类型和 Sized trait","id":"378","title":"动态大小类型和 Sized trait"},"379":{"body":"ch20-05-advanced-functions-and-closures.md commit 21cf840842bdf768a798869f06373c96c1cc5122 本部分将探索一些有关函数和闭包的高级功能，这包括函数指针以及返回值闭包。","breadcrumbs":"高级特征 » 高级函数与闭包 » 高级函数与闭包","id":"379","title":"高级函数与闭包"},"38":{"body":"让我们来测试下猜数字游戏的第一部分。使用 cargo run 运行： $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 6.44s Running `target/debug/guessing_game`\nGuess the number!\nPlease input your guess.\n6\nYou guessed: 6 至此为止，游戏的第一部分已经完成：我们从键盘获取输入并打印了出来。","breadcrumbs":"写个猜数字游戏 » 测试第一部分代码","id":"38","title":"测试第一部分代码"},"380":{"body":"我们讨论过了如何向函数传递闭包；也可以向函数传递常规函数！这个技术在我们希望传递已经定义的函数而不是重新定义闭包作为参数时很有用。函数满足类型 fn（小写的 f），不要与闭包 trait 的 Fn 相混淆。fn 被称为函数指针（ function pointer ）。通过函数指针允许我们使用函数作为另一个函数的参数。指定参数为函数指针的语法类似于闭包，如示例 19-27 所示，这里定义了一个 add_one 函数将其参数加一。do_twice 函数获取两个参数：一个指向任何获取一个 i32 参数并返回一个 i32 的函数指针，和一个 i32 值。do_twice 函数传递 arg 参数调用 f 函数两次，接着将两次函数调用的结果相加。main 函数使用 add_one 和 5 作为参数调用 do_twice。文件名：src/main.rs fn add_one(x: i32) -> i32 { x + 1\n} fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 { f(arg) + f(arg)\n} fn main() { let answer = do_twice(add_one, 5); println!(\"The answer is: {answer}\");\n} 示例 19-27: 使用 fn 类型接受函数指针作为参数这会打印出 The answer is: 12。do_twice 中的 f 被指定为一个接受一个 i32 参数并返回 i32 的 fn。接着就可以在 do_twice 函数体中调用 f。在 main 中，可以将函数名 add_one 作为第一个参数传递给 do_twice。不同于闭包，fn 是一个类型而不是一个 trait，所以直接指定 fn 作为参数而不是声明一个带有 Fn 作为 trait bound 的泛型参数。函数指针实现了所有三个闭包 trait（Fn、FnMut 和 FnOnce），所以总是可以在调用期望闭包的函数时传递函数指针作为参数。倾向于编写使用泛型和闭包 trait 的函数，这样它就能接受函数或闭包作为参数。一个只期望接受 fn 而不接受闭包的情况的例子是与不存在闭包的外部代码交互时：C 语言的函数可以接受函数作为参数，但 C 语言没有闭包。作为一个既可以使用内联定义的闭包又可以使用命名函数的例子，让我们看看一个 map 的应用。使用 map 函数将一个数字 vector 转换为一个字符串 vector，就可以使用闭包，比如这样： # fn main() { let list_of_numbers = vec![1, 2, 3]; let list_of_strings: Vec<String> = list_of_numbers.iter().map(|i| i.to_string()).collect();\n# } 或者可以将函数作为 map 的参数来代替闭包，像是这样： # fn main() { let list_of_numbers = vec![1, 2, 3]; let list_of_strings: Vec<String> = list_of_numbers.iter().map(ToString::to_string).collect();\n# } 注意这里必须使用 “高级 trait” 部分讲到的完全限定语法，因为存在多个叫做 to_string 的函数；这里使用了定义于 ToString trait 的 to_string 函数，标准库为所有实现了 Display 的类型实现了这个 trait。回忆一下第六章 “枚举值” 部分中定义的每一个枚举成员也变成了一个构造函数。我们可以使用这些构造函数作为实现了闭包 trait 的函数指针，这意味着可以指定构造函数作为接受闭包的方法的参数，如下： # fn main() { enum Status { Value(u32), Stop, } let list_of_statuses: Vec<Status> = (0u32..20).map(Status::Value).collect();\n# } 这里创建了 Status::Value 实例，它通过 map 用范围的每一个 u32 值调用 Status::Value 的初始化函数。一些人倾向于函数风格，一些人喜欢闭包。这两种形式最终都会产生同样的代码，所以请使用对你来说更明白的形式吧。","breadcrumbs":"高级特征 » 高级函数与闭包 » 函数指针","id":"380","title":"函数指针"},"381":{"body":"闭包表现为 trait，这意味着不能直接返回闭包。对于大部分需要返回 trait 的情况，可以使用实现了期望返回的 trait 的具体类型来替代函数的返回值。但是这不能用于闭包，因为它们没有一个可返回的具体类型；例如不允许使用函数指针 fn 作为返回值类型。这段代码尝试直接返回闭包，它并不能编译： fn returns_closure() -> dyn Fn(i32) -> i32 { |x| x + 1\n} 编译器给出的错误是： $ cargo build Compiling functions-example v0.1.0 (file:///projects/functions-example)\nerror[E0746]: return type cannot have an unboxed trait object --> src/lib.rs:1:25 |\n1 | fn returns_closure() -> dyn Fn(i32) -> i32 { | ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time |\nhelp: consider returning an `impl Trait` instead of a `dyn Trait` |\n1 | fn returns_closure() -> impl Fn(i32) -> i32 { | ~~~~\nhelp: alternatively, box the return type, and wrap all of the returned values in `Box::new` |\n1 ~ fn returns_closure() -> Box<dyn Fn(i32) -> i32> {\n2 ~ Box::new(|x| x + 1) | For more information about this error, try `rustc --explain E0746`.\nerror: could not compile `functions-example` (lib) due to 1 previous error 错误又一次指向了 Sized trait！Rust 并不知道需要多少空间来储存闭包。不过我们在上一部分见过这种情况的解决办法：可以使用 trait 对象： fn returns_closure() -> Box<dyn Fn(i32) -> i32> { Box::new(|x| x + 1)\n} 这段代码正好可以编译。关于 trait 对象的更多内容，请回顾第十八章的顾及不同类型值的 trait 对象” 部分。接下来让我们学习宏！","breadcrumbs":"高级特征 » 高级函数与闭包 » 返回闭包","id":"381","title":"返回闭包"},"382":{"body":"ch20-06-macros.md commit 95e931170404cb98d476b19017cbbdbc00d0834d 我们已经在本书中使用过像 println! 这样的宏了，不过还没完全探索什么是宏以及它是如何工作的。宏（ Macro ）指的是 Rust 中一系列的功能：使用 macro_rules! 的声明（ Declarative ）宏，和三种过程（ Procedural ）宏：自定义 #[derive] 宏在结构体和枚举上指定通过 derive 属性添加的代码类属性（Attribute-like）宏定义可用于任意项的自定义属性类函数宏看起来像函数不过作用于作为参数传递的 token 我们会依次讨论每一种宏，不过首要的是，为什么已经有了函数还需要宏呢？","breadcrumbs":"高级特征 » 宏 » 宏","id":"382","title":"宏"},"383":{"body":"从根本上来说，宏是一种为写其他代码而写代码的方式，即所谓的元编程（ metaprogramming ）。在附录 C 中会探讨 derive 属性，其生成各种 trait 的实现。我们也在本书中使用过 println! 宏和 vec! 宏。所有的这些宏以展开的方式来生成比你所手写出的更多的代码。元编程对于减少大量编写和维护的代码是非常有用的，它也扮演了函数扮演的角色。但宏有一些函数所没有的附加能力。一个函数签名必须声明函数参数个数和类型。相比之下，宏能够接收不同数量的参数：用一个参数调用 println!(\"hello\") 或用两个参数调用 println!(\"hello {}\", name) 。而且，宏可以在编译器翻译代码前展开，例如，宏可以在一个给定类型上实现 trait。而函数则不行，因为函数是在运行时被调用，同时 trait 需要在编译时实现。实现宏不如实现函数的一面是宏定义要比函数定义更复杂，因为你正在编写生成 Rust 代码的 Rust 代码。由于这样的间接性，宏定义通常要比函数定义更难阅读、理解以及维护。宏和函数的最后一个重要的区别是：在一个文件里调用宏之前必须定义它，或将其引入作用域，而函数则可以在任何地方定义和调用。","breadcrumbs":"高级特征 » 宏 » 宏和函数的区别","id":"383","title":"宏和函数的区别"},"384":{"body":"Rust 最常用的宏形式是声明宏（ declarative macros ）。它们有时也被称为 “macros by example”、“macro_rules! 宏” 或者就是 “macros”。其核心概念是，声明宏允许我们编写一些类似 Rust match 表达式的代码。正如在第六章讨论的那样，match 表达式是控制结构，其接收一个表达式，与表达式的结果进行模式匹配，然后根据模式匹配执行相关代码。宏也将一个值和包含相关代码的模式进行比较；此种情况下，该值是传递给宏的 Rust 源代码字面值，模式用于和前面提到的源代码字面值进行比较，每个模式的相关代码会替换传递给宏的代码。所有这一切都发生于编译时。可以使用 macro_rules! 来定义宏。让我们通过查看 vec! 宏定义来探索如何使用 macro_rules! 结构。第八章讲述了如何使用 vec! 宏来生成一个给定值的 vector。例如，下面的宏用三个整数创建一个 vector： let v: Vec<u32> = vec![1, 2, 3]; 也可以使用 vec! 宏来构造两个整数的 vector 或五个字符串 slice 的 vector。但却无法使用函数做相同的事情，因为我们无法预先知道参数值的数量和类型。在示例 19-28 中展示了一个 vec! 稍微简化的定义。文件名：src/lib.rs #[macro_export]\nmacro_rules! vec { ( $( $x:expr ),* ) => { { let mut temp_vec = Vec::new(); $( temp_vec.push($x); )* temp_vec } };\n} 示例 19-28: 一个 vec! 宏定义的简化版本注意：标准库中实际定义的 vec! 包括预分配适当量的内存的代码。这部分为代码优化，为了让示例简化，此处并没有包含在内。 #[macro_export] 注解表明只要导入了定义这个宏的 crate，该宏就应该是可用的。如果没有该注解，这个宏不能被引入作用域。接着使用 macro_rules! 和宏名称开始宏定义，且所定义的宏并不带感叹号。名字后跟大括号表示宏定义体，在该例中宏名称是 vec 。 vec! 宏的结构和 match 表达式的结构类似。此处有一个分支模式 ( $( $x:expr ),* ) ，后跟 => 以及和模式相关的代码块。如果模式匹配，该相关代码块将被执行。这里这个宏只有一个模式，那就只有一个有效匹配方向，其他任何模式方向（译者注：不匹配这个模式）都会导致错误。更复杂的宏会有多个分支模式。宏定义中有效模式语法和在第十九章提及的模式语法是不同的，因为宏模式所匹配的是 Rust 代码结构而不是值。回过头来检查下示例 19-28 中模式片段什么意思。对于全部的宏模式语法，请查阅 Rust 参考。首先，一对括号包含了整个模式。我们使用美元符号（$）在宏系统中声明一个变量来包含匹配该模式的 Rust 代码。美元符号明确表明这是一个宏变量而不是普通 Rust 变量。之后是一对括号，其捕获了符合括号内模式的值用以在替代代码中使用。$() 内则是 $x:expr ，其匹配 Rust 的任意表达式，并将该表达式命名为 $x。 $() 之后的逗号说明一个可有可无的逗号分隔符可以出现在 $() 所匹配的代码之后。紧随逗号之后的 * 说明该模式匹配零个或更多个 * 之前的任何模式。当以 vec![1, 2, 3]; 调用宏时，$x 模式与三个表达式 1、2 和 3 进行了三次匹配。现在让我们来看看与此分支模式相关联的代码块中的模式：匹配到模式中的$()的每一部分，都会在（=>右侧）$()* 里生成temp_vec.push($x)，生成零次还是多次取决于模式匹配到多少次。$x 由每个与之相匹配的表达式所替换。当以 vec![1, 2, 3]; 调用该宏时，替换该宏调用所生成的代码会是下面这样： { let mut temp_vec = Vec::new(); temp_vec.push(1); temp_vec.push(2); temp_vec.push(3); temp_vec\n} 我们已经定义了一个宏，其可以接收任意数量和类型的参数，同时可以生成能够创建包含指定元素的 vector 的代码。请查阅在线文档或其他资源，如 “The Little Book of Rust Macros” 来更多地了解如何写宏，该书由 Daniel Keep 开始编写并由 Lukas Wirth 继续维护。","breadcrumbs":"高级特征 » 宏 » 使用 macro_rules! 的声明宏用于通用元编程","id":"384","title":"使用 macro_rules! 的声明宏用于通用元编程"},"385":{"body":"第二种形式的宏被称为过程宏（ procedural macros ），因为它们更像函数（一种过程类型）。过程宏接收 Rust 代码作为输入，在这些代码上进行操作，然后产生另一些代码作为输出，而非像声明式宏那样匹配对应模式然后以另一部分代码替换当前代码。有三种类型的过程宏（自定义派生（derive），类属性和类函数），不过它们的工作方式都类似。创建过程宏时，其定义必须驻留在它们自己的具有特殊 crate 类型的 crate 中。这么做出于复杂的技术原因，将来我们希望能够消除这些限制。在示例 19-29 中展示了如何定义过程宏，其中 some_attribute 是一个使用特定宏变体的占位符。文件名：src/lib.rs use proc_macro; #[some_attribute]\npub fn some_name(input: TokenStream) -> TokenStream {\n} 示例 19-29: 一个定义过程宏的例子定义过程宏的函数接收一个 TokenStream 作为输入并生成 TokenStream 作为输出。TokenStream 是定义于proc_macro crate 里代表一系列 token 的类型，Rust 默认携带了proc_macro crate。这就是宏的核心：宏所处理的源代码组成了输入 TokenStream，宏生成的代码是输出 TokenStream。函数上还有一个属性；这个属性指明了我们创建的过程宏的类型。在同一 crate 中可以有多种的过程宏。让我们看看不同种类的程序宏。我们将从一个自定义的派生宏开始，然后解释使其他形式不同的小差异。","breadcrumbs":"高级特征 » 宏 » 用于从属性生成代码的过程宏","id":"385","title":"用于从属性生成代码的过程宏"},"386":{"body":"让我们创建一个 hello_macro crate，其包含名为 HelloMacro 的 trait 和关联函数 hello_macro。不同于让用户为其每一个类型实现 HelloMacro trait，我们将会提供一个过程式宏以便用户可以使用 #[derive(HelloMacro)] 注解它们的类型来得到 hello_macro 函数的默认实现。该默认实现会打印 Hello, Macro! My name is TypeName!，其中 TypeName 为定义了 trait 的类型名。换言之，我们会创建一个 crate，使程序员能够写类似示例 19-30 中的代码。文件名：src/main.rs use hello_macro::HelloMacro;\nuse hello_macro_derive::HelloMacro; #[derive(HelloMacro)]\nstruct Pancakes; fn main() { Pancakes::hello_macro();\n} 示例 19-30: crate 用户所写的能够使用过程式宏的代码运行该代码将会打印 Hello, Macro! My name is Pancakes! 第一步是像下面这样新建一个库 crate： $ cargo new hello_macro --lib 接下来，会定义 HelloMacro trait 以及其关联函数：文件名：src/lib.rs pub trait HelloMacro { fn hello_macro();\n} 现在有了一个包含函数的 trait。此时，crate 用户可以实现该 trait 以达到其期望的功能，像这样： use hello_macro::HelloMacro; struct Pancakes; impl HelloMacro for Pancakes { fn hello_macro() { println!(\"Hello, Macro! My name is Pancakes!\"); }\n} fn main() { Pancakes::hello_macro();\n} 然而，他们需要为每一个他们想使用 hello_macro 的类型编写实现的代码块。我们希望为其节约这些工作。另外，我们也无法为 hello_macro 函数提供一个能够打印实现了该 trait 的类型的名字的默认实现：Rust 没有反射的能力，因此其无法在运行时获取类型名。我们需要一个在编译时生成代码的宏。下一步是定义过程式宏。在编写本部分时，过程式宏必须在其自己的 crate 内。该限制最终可能被取消。构造 crate 和其中宏的惯例如下：对于一个 foo 的包来说，一个自定义的派生过程宏的包被称为 foo_derive 。在 hello_macro 项目中新建名为 hello_macro_derive 的包。 $ cargo new hello_macro_derive --lib 由于两个 crate 紧密相关，因此在 hello_macro 包的目录下创建过程式宏的 crate。如果改变在 hello_macro 中定义的 trait，同时也必须改变在 hello_macro_derive 中实现的过程式宏。这两个包需要分别发布，编程人员如果使用这些包，则需要同时添加这两个依赖并将其引入作用域。我们也可以只用 hello_macro 包而将 hello_macro_derive 作为一个依赖，并重新导出过程式宏的代码。但现在我们组织项目的方式使编程人员在无需 derive 功能时也能够单独使用 hello_macro。我们需要声明 hello_macro_derive crate 是过程宏 (proc-macro) crate。我们还需要 syn 和 quote crate 中的功能，正如你即将看到的，需要将它们加到依赖中。将下面的代码加入到 hello_macro_derive 的 Cargo.toml 文件中。文件名：hello_macro_derive/Cargo.toml [lib]\nproc-macro = true [dependencies]\nsyn = \"2.0\"\nquote = \"1.0\" 为定义一个过程式宏，请将示例 19-31 中的代码放在 hello_macro_derive crate 的 src/lib.rs 文件里面。注意这段代码在我们添加 impl_hello_macro 函数的定义之前是无法编译的。文件名：hello_macro_derive/src/lib.rs use proc_macro::TokenStream;\nuse quote::quote; #[proc_macro_derive(HelloMacro)]\npub fn hello_macro_derive(input: TokenStream) -> TokenStream { // Construct a representation of Rust code as a syntax tree // that we can manipulate let ast = syn::parse(input).unwrap(); // Build the trait implementation impl_hello_macro(&ast)\n} 示例 19-31: 大多数过程式宏处理 Rust 代码时所需的代码注意我们将代码分成了hello_macro_derive 和 impl_hello_macro 两个函数，前者负责解析 TokenStream，后者负责转换语法树：这使得编写过程宏更方便。几乎你看到或者创建的每一个过程宏的外部函数（这里是hello_macro_derive）中的代码都跟这里是一样的。你放入内部函数（这里是impl_hello_macro）中的代码根据你的过程宏的设计目的会有所不同。现在，我们已经引入了三个新的 crate：proc_macro 、 syn 和 quote 。Rust 自带 proc_macro crate，因此无需将其加到 Cargo.toml 文件的依赖中。proc_macro crate 是编译器用来读取和操作我们 Rust 代码的 API。 syn crate 将字符串中的 Rust 代码解析成为一个可以操作的数据结构。quote 则将 syn 解析的数据结构转换回 Rust 代码。这些 crate 让解析任何我们所要处理的 Rust 代码变得更简单：为 Rust 编写整个的解析器并不是一件简单的工作。当用户在一个类型上指定 #[derive(HelloMacro)] 时，hello_macro_derive 函数将会被调用。因为我们已经使用 proc_macro_derive 及其指定名称HelloMacro对 hello_macro_derive 函数进行了注解，指定名称HelloMacro就是 trait 名，这是大多数过程宏遵循的习惯。该函数首先将来自 TokenStream 的 input 转换为一个我们可以解释和操作的数据结构。这正是 syn 派上用场的地方。syn 中的 parse 函数获取一个 TokenStream 并返回一个表示解析出 Rust 代码的 DeriveInput 结构体。示例 19-32 展示了从字符串 struct Pancakes; 中解析出来的 DeriveInput 结构体的相关部分： DeriveInput { // --snip-- ident: Ident { ident: \"Pancakes\", span: #0 bytes(95..103) }, data: Struct( DataStruct { struct_token: Struct, fields: Unit, semi_token: Some( Semi ) } )\n} 示例 19-32: 解析示例 19-30 中带有宏属性的代码时得到的 DeriveInput 实例该结构体的字段展示了我们解析的 Rust 代码是一个类单元结构体，其 ident（identifier，表示名字）为 Pancakes。该结构体里面有更多字段描述了所有类型的 Rust 代码，查阅 syn 中 DeriveInput 的文档以获取更多信息。很快我们将定义 impl_hello_macro 函数，其用于构建所要包含在内的 Rust 新代码。但在此之前，注意其输出也是 TokenStream。所返回的 TokenStream 会被加到我们的 crate 用户所写的代码中，因此，当用户编译他们的 crate 时，他们会通过修改后的 TokenStream 获取到我们所提供的额外功能。你可能也注意到了，当调用 syn::parse 函数失败时，我们用 unwrap 来使 hello_macro_derive 函数 panic。在错误时 panic 对过程宏来说是必须的，因为 proc_macro_derive 函数必须返回 TokenStream 而不是 Result，以此来符合过程宏的 API。这里选择用 unwrap 来简化了这个例子；在生产代码中，则应该通过 panic! 或 expect 来提供关于发生何种错误的更加明确的错误信息。现在我们有了将注解的 Rust 代码从 TokenStream 转换为 DeriveInput 实例的代码，让我们来创建在注解类型上实现 HelloMacro trait 的代码，如示例 19-33 所示。文件名：hello_macro_derive/src/lib.rs # use proc_macro::TokenStream;\n# use quote::quote;\n# # #[proc_macro_derive(HelloMacro)]\n# pub fn hello_macro_derive(input: TokenStream) -> TokenStream {\n# // Construct a representation of Rust code as a syntax tree\n# // that we can manipulate\n# let ast = syn::parse(input).unwrap();\n# # // Build the trait implementation\n# impl_hello_macro(&ast)\n# }\n# fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream { let name = &ast.ident; let gen = quote! { impl HelloMacro for #name { fn hello_macro() { println!(\"Hello, Macro! My name is {}!\", stringify!(#name)); } } }; gen.into()\n} 示例 19-33: 使用解析过的 Rust 代码实现 HelloMacro trait 我们得到一个包含以 ast.ident 作为注解类型名字（标识符）的 Ident 结构体实例。示例 19-32 中的结构体表明当 impl_hello_macro 函数运行于示例 19-30 中的代码上时 ident 字段的值是 \"Pancakes\"。因此，示例 19-33 中 name 变量会包含一个 Ident 结构体的实例，当打印时，会是字符串 \"Pancakes\"，也就是示例 19-30 中结构体的名称。 quote! 宏能让我们编写希望返回的 Rust 代码。quote! 宏执行的直接结果并不是编译器所期望的所以需要转换为 TokenStream。为此需要调用 into 方法，它会消费这个中间表示（intermediate representation，IR）并返回所需的 TokenStream 类型值。这个宏也提供了一些非常酷的模板机制；我们可以写 #name ，然后 quote! 会以名为 name 的变量值来替换它。你甚至可以做一些类似常用宏那样的重复代码的工作。查阅 quote crate 的文档来获取详尽的介绍。我们期望我们的过程式宏能够为通过 #name 获取到的用户注解类型生成 HelloMacro trait 的实现。该 trait 的实现有一个函数 hello_macro ，其函数体包括了我们期望提供的功能：打印 Hello, Macro! My name is 和注解的类型名。此处所使用的 stringify! 为 Rust 内置宏。其接收一个 Rust 表达式，如 1 + 2 ，然后在编译时将表达式转换为一个字符串常量，如 \"1 + 2\" 。这与 format! 或 println! 是不同的，它计算表达式并将结果转换为 String 。有一种可能的情况是，所输入的 #name 可能是一个需要打印的表达式，因此我们用 stringify! 。stringify! 也能通过在编译时将 #name 转换为字符串来节省内存分配。此时，cargo build 应该都能成功编译 hello_macro 和 hello_macro_derive 。我们将这些 crate 连接到示例 19-30 的代码中来看看过程宏的行为！在 projects 目录下用 cargo new pancakes 命令新建一个二进制项目。需要将 hello_macro 和 hello_macro_derive 作为依赖加到 pancakes 包的 Cargo.toml 文件中去。如果你正将 hello_macro 和 hello_macro_derive 的版本发布到 crates.io 上，其应为常规依赖；如果不是，则可以像下面这样将其指定为 path 依赖： hello_macro = { path = \"../hello_macro\" }\nhello_macro_derive = { path = \"../hello_macro/hello_macro_derive\" } 把示例 19-30 中的代码放在 src/main.rs ，然后执行 cargo run：其应该打印 Hello, Macro! My name is Pancakes!。其包含了该过程宏中 HelloMacro trait 的实现，而无需 pancakes crate 实现它；#[derive(HelloMacro)] 增加了该 trait 实现。接下来，让我们探索一下其他类型的过程宏与自定义派生宏有何区别。","breadcrumbs":"高级特征 » 宏 » 如何编写自定义 derive 宏","id":"386","title":"如何编写自定义 derive 宏"},"387":{"body":"类属性宏与自定义派生宏相似，不同的是 derive 属性生成代码，它们（类属性宏）能让你创建新的属性。它们也更为灵活；derive 只能用于结构体和枚举；属性还可以用于其它的项，比如函数。作为一个使用类属性宏的例子，可以创建一个名为 route 的属性用于注解 web 应用程序框架（web application framework）的函数： #[route(GET, \"/\")]\nfn index() { #[route] 属性将由框架本身定义为一个过程宏。其宏定义的函数签名看起来像这样： #[proc_macro_attribute]\npub fn route(attr: TokenStream, item: TokenStream) -> TokenStream { 这里有两个 TokenStream 类型的参数；第一个用于属性内容本身，也就是 GET, \"/\" 部分。第二个是属性所标记的项：在本例中，是 fn index() {} 和剩下的函数体。除此之外，类属性宏与自定义派生宏工作方式一致：创建 proc-macro crate 类型的 crate 并实现希望生成代码的函数！","breadcrumbs":"高级特征 » 宏 » 类属性宏","id":"387","title":"类属性宏"},"388":{"body":"类函数（Function-like）宏的定义看起来像函数调用的宏。类似于 macro_rules!，它们比函数更灵活；例如，可以接受未知数量的参数。然而 macro_rules! 宏只能使用之前 “使用 macro_rules! 的声明宏用于通用元编程” 介绍的类匹配的语法定义。类函数宏获取 TokenStream 参数，其定义使用 Rust 代码操纵 TokenStream，就像另两种过程宏一样。一个类函数宏例子是可以像这样被调用的 sql! 宏： let sql = sql!(SELECT * FROM posts WHERE id=1); 这个宏会解析其中的 SQL 语句并检查其是否是句法正确的，这是比 macro_rules! 可以做到的更为复杂的处理。sql! 宏应该被定义为如此： #[proc_macro]\npub fn sql(input: TokenStream) -> TokenStream { 这类似于自定义派生宏的签名：获取括号中的 token，并返回希望生成的代码。","breadcrumbs":"高级特征 » 宏 » 类函数宏","id":"388","title":"类函数宏"},"389":{"body":"好的！现在我们学习了 Rust 并不常用但在特定情况下你可能用得着的功能。我们介绍了很多复杂的主题，这样若你在错误信息提示或阅读他人代码时遇到它们，至少可以说之前已经见过这些概念和语法了。你可以使用本章作为一个解决方案的参考。接下来，我们将再开始一个项目，将本书所学的所有内容付与实践！","breadcrumbs":"高级特征 » 宏 » 总结","id":"389","title":"总结"},"39":{"body":"接下来，需要生成一个秘密数字，好让用户来猜。秘密数字应该每次都不同，这样重复玩才不会乏味；范围应该在 1 到 100 之间，这样才不会太困难。Rust 标准库中尚未包含随机数功能。然而，Rust 团队还是提供了一个包含上述功能的 rand crate 。","breadcrumbs":"写个猜数字游戏 » 生成一个秘密数字","id":"39","title":"生成一个秘密数字"},"390":{"body":"ch21-00-final-project-a-web-server.md commit 5df6909c57b3ba55f156a4122a42b805436de90c 这是一次漫长的旅途，不过我们到达了本书的结束。在本章中，我们将一同构建另一个项目，来展示最后几章所学，同时复习更早的章节。作为最后的项目，我们将要实现一个返回 “hello” 的 web server，它在浏览器中看起来就如图例 20-1 所示： hello from rust 图例 20-1: 我们最后将一起分享的项目如下是构建 web server 的计划：学习一些 TCP 与 HTTP 知识在套接字（socket）上监听 TCP 请求解析少量的 HTTP 请求创建一个合适的 HTTP 响应通过线程池改善 server 的吞吐量不过在开始之前，需要提到一点细节：这里使用的方法并不是使用 Rust 构建 web server 最好的方法。 crates.io 上有很多可用于生产环境的 crate，它们提供了比我们所要编写的更为完整的 web server 和线程池实现。然而，本章的目的在于学习，而不是走捷径。因为 Rust 是一个系统编程语言，我们能够选择处理什么层次的抽象，并能够选择比其他语言可能或可用的层次更低的层次。因此我们将自己编写一个基础的 HTTP server 和线程池，以便学习将来可能用到的 crate 背后的通用理念和技术。","breadcrumbs":"最后的项目：构建多线程 web server » 最后的项目：构建多线程 web server","id":"390","title":"最后的项目：构建多线程 web server"},"391":{"body":"ch21-01-single-threaded.md commit 5df6909c57b3ba55f156a4122a42b805436de90c 首先让我们创建一个可运行的单线程 web server，不过在开始之前，我们将快速了解一下构建 web server 所涉及到的协议。这些协议的细节超出了本书的范畴，不过一个简单的概括会提供我们所需的信息。 web server 中涉及到的两个主要协议是超文本传输协议（ Hypertext Transfer Protocol ， HTTP ）和传输控制协议（ Transmission Control Protocol ， TCP ）。这两者都是请求 - 响应（ request-response ）协议，也就是说，有客户端（ client ）来初始化请求，并有服务端（ server ）监听请求并向客户端提供响应。请求与响应的内容由协议本身定义。 TCP 是一个底层协议，它描述了信息如何从一个 server 到另一个的细节，不过其并不指定信息是什么。HTTP 构建于 TCP 之上，它定义了请求和响应的内容。为此，技术上讲可将 HTTP 用于其他协议之上，不过对于绝大部分情况，HTTP 通过 TCP 传输。我们将要做的就是处理 TCP 和 HTTP 请求与响应的原始字节数据。","breadcrumbs":"最后的项目：构建多线程 web server » 建立单线程 web server » 构建单线程 web server","id":"391","title":"构建单线程 web server"},"392":{"body":"我们的 web server 所需做的第一件事，是监听 TCP 连接。标准库提供了 std::net 模块处理这些功能。让我们一如既往新建一个项目： $ cargo new hello Created binary (application) `hello` project\n$ cd hello 现在，在 src/main.rs 输入示例 20-1 中的代码，作为一个开始。这段代码会在地址 127.0.0.1:7878 上监听传入的 TCP 流。当获取到传入的流，它会打印出 Connection established!：文件名：src/main.rs use std::net::TcpListener; fn main() { let listener = TcpListener::bind(\"127.0.0.1:7878\").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); println!(\"Connection established!\"); }\n} 示例 20-1: 监听传入的流并在接收到流时打印信息 TcpListener 用于监听 TCP 连接。我们选择监听本地地址 127.0.0.1:7878。将这个地址拆开来看，冒号之前的部分是一个代表本机的 IP 地址（在每台计算机上，这个地址都指本机，并不特指作者的计算机），而 7878 是端口。选择这个端口出于两个原因：通常 HTTP 服务器不在这个端口上接受请求，所以它不太可能与你机器上运行的其它 web server 的端口冲突；而且 7878 在电话上打出来就是 \"rust\"（译者注：九宫格键盘上的英文）。在这个场景中 bind 函数类似于 new 函数，在这里它返回一个新的 TcpListener 实例。这个函数叫做 bind 是因为，在网络领域，连接到要监听的端口称为“绑定到端口”（“binding to a port”） bind 函数返回 Result<T, E>，这表明绑定可能会失败。例如，监听 80 端口需要管理员权限（非管理员用户只能监听大于 1023 的端口），所以如果尝试监听 80 端口而没有管理员权限，则会绑定失败。再比如，如果我们运行这个程序的两个实例，并因此有两个实例监听同一个端口，那么绑定也将失败。我们是出于学习目的来编写一个基础的服务器，不用关心处理这类错误，而仅仅使用 unwrap 在出现这些情况时直接停止程序。 TcpListener 的 incoming 方法返回一个迭代器，它提供了一系列的流（更准确的说是 TcpStream 类型的流）。流（ stream ）代表一个客户端和服务端之间打开的连接。连接（ connection ）代表客户端连接服务端、服务端生成响应以及服务端关闭连接的全部请求 / 响应过程。为此，我们会从 TcpStream 读取客户端发送了什么并接着向流发送响应以向客户端发回数据。总体来说，这个 for 循环会依次处理每个连接并产生一系列的流供我们处理。目前，处理流的代码中也有一个 unwrap 调用，如果 stream 出现任何错误会终止程序；如果没有任何错误，则打印出信息。下一个例子中，我们将为成功的情况增加更多功能。当客户端连接到服务端时，incoming 方法是可能返回错误的，因为我们实际上不是在遍历连接，而是遍历连接尝试（ connection attempts ）。连接的尝试可能会因为多种原因不能成功，大部分是操作系统相关的。例如，很多系统限制同时打开的连接数，超出数量限制的新连接尝试会产生错误，直到一些现有的连接关闭为止。让我们试试这段代码！首先在终端执行 cargo run，接着在浏览器中打开 127.0.0.1:7878。浏览器会显示出看起来类似于“连接重置”（“Connection reset”）的错误信息，因为 server 目前并没响应任何数据。如果我们观察终端，会发现当浏览器连接我们的服务端时，会打印出一系列的信息！ Running `target/debug/hello`\nConnection established!\nConnection established!\nConnection established! 有时，对于一次浏览器请求，可能会打印出多条信息；这可能是因为，浏览器在请求页面的同时，还请求了其他资源，比如出现在浏览器标签页开头的图标（ favicon.ico ）。这也可能是因为浏览器尝试多次连接服务端，因为服务端没有响应任何数据。作为 drop 实现的一部分，当 stream 在循环的结尾离开作用域并被丢弃，其连接将被关闭。浏览器有时通过重连来处理关闭的连接，因为对于一般网站而言，这些问题可能是暂时的。这些都不重要；现在重要的是，我们成功的处理了 TCP 连接！记得当运行完特定版本的代码后，使用 ctrl-C 来停止程序。并通过执行 cargo run 命令在做出最新的代码修改之后重启服务。","breadcrumbs":"最后的项目：构建多线程 web server » 建立单线程 web server » 监听 TCP 连接","id":"392","title":"监听 TCP 连接"},"393":{"body":"让我们实现读取来自浏览器请求的功能！为了分离“获取连接”以及“接下来对连接的操作”，我们将开始写一个新函数来处理连接。在这个新的 handle_connection 函数中，我们从 TCP 流中读取数据，并打印出来，以便观察浏览器发送过来的数据。将代码修改为如示例 20-2 所示：文件名：src/main.rs use std::{ io::{prelude::*, BufReader}, net::{TcpListener, TcpStream},\n}; fn main() { let listener = TcpListener::bind(\"127.0.0.1:7878\").unwrap(); for stream in listener.incoming() { let stream = stream.unwrap(); handle_connection(stream); }\n} fn handle_connection(mut stream: TcpStream) { let buf_reader = BufReader::new(&stream); let http_request: Vec<_> = buf_reader .lines() .map(|result| result.unwrap()) .take_while(|line| !line.is_empty()) .collect(); println!(\"Request: {http_request:#?}\");\n} 示例 20-2: 读取 TcpStream 并打印数据这里将 std::io::prelude 和 std::io::BufReader 引入作用域，来获取读写流所需的特定 trait。在 main 函数的 for 循环中，相比获取到连接时打印信息，现在调用新的 handle_connection 函数并向其传递 stream。在 handle_connection 中，我们新建了一个 BufReader 实例来封装一个 stream 的可变引用。BufReader 增加了缓存来替我们管理 std::io::Read trait 方法的调用。我们创建了一个 http_request 变量来收集浏览器发送给服务端的请求行。这里增加了 Vec<_> 类型注解表明希望将这些行收集到一个 vector 中。 BufReader 实现了 std::io::BufRead trait，它提供了 lines 方法。lines 方法通过遇到换行符（newline）字节就切分数据流的方式返回一个 Result<String, std::io::Error> 的迭代器。为了获取每一个 String，通过 map 并 unwrap 每一个 Result。如果数据不是有效的 UTF-8 编码或者读取流遇到问题时，Result 可能是一个错误。一如既往生产环境的程序应该更优雅地处理这些错误，不过出于简单的目的我们选择在错误情况下停止程序。浏览器通过连续发送两个换行符来代表一个 HTTP 请求的结束，所以为了从流中获取一个请求，我们获取行直到它们不为空。一旦将这些行收集进 vector，就可以使用友好的 debug 格式化打印它们，以便看看 web 浏览器发送给服务端的指令。让我们试一试！启动程序并再次在浏览器中发起请求。注意浏览器中仍然会出现错误页面，不过终端中程序的输出现在看起来像这样： $ cargo run Compiling hello v0.1.0 (file:///projects/hello) Finished dev [unoptimized + debuginfo] target(s) in 0.42s Running `target/debug/hello`\nRequest: [ \"GET / HTTP/1.1\", \"Host: 127.0.0.1:7878\", \"User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:99.0) Gecko/20100101 Firefox/99.0\", \"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8\", \"Accept-Language: en-US,en;q=0.5\", \"Accept-Encoding: gzip, deflate, br\", \"DNT: 1\", \"Connection: keep-alive\", \"Upgrade-Insecure-Requests: 1\", \"Sec-Fetch-Dest: document\", \"Sec-Fetch-Mode: navigate\", \"Sec-Fetch-Site: none\", \"Sec-Fetch-User: ?1\", \"Cache-Control: max-age=0\",\n] 根据使用的浏览器不同可能会出现稍微不同的数据。现在我们打印出了请求数据，可以通过观察第一行 GET 之后的路径来解释为何会从浏览器得到多个连接。如果重复的连接都是请求 / ，就知道了浏览器尝试重复获取 / 因为它没有从程序得到响应。让我们拆开请求数据来理解浏览器向程序请求了什么。仔细观察 HTTP 请求 HTTP 是一个基于文本的协议，同时一个请求有如下格式： Method Request-URI HTTP-Version CRLF\nheaders CRLF\nmessage-body 第一行叫做请求行（ request line ），它存放了客户端请求了什么的信息。请求行的第一部分是所使用的 method ，比如 GET 或 POST，这描述了客户端如何进行请求。这里客户端使用了 GET 请求，表明它在请求信息。请求行接下来的部分是 / ，它代表客户端请求的统一资源标识符（ Uniform Resource Identifier ， URI ） —— URI 大体上类似，但也不完全类似于 URL（统一资源定位符， Uniform Resource Locators ）。URI 和 URL 之间的区别对于本章的目的来说并不重要，不过 HTTP 规范使用术语 URI，所以这里可以简单的将 URL 理解为 URI。最后一部分是客户端使用的 HTTP 版本，然后请求行以 CRLF 序列（CRLF 代表回车和换行， carriage return line feed ，这是打字机时代的术语！）结束。CRLF 序列也可以写成\\r\\n，其中\\r是回车符，\\n是换行符。CRLF 序列将请求行与其余请求数据分开。请注意，打印 CRLF 时，我们会看到一个新行，而不是\\r\\n。观察目前运行程序所接收到的数据的请求行，可以看到 GET 是 method， / 是请求 URI，而 HTTP/1.1 是版本。从 Host: 开始的其余的行是 headers；GET 请求没有 body。如果你希望的话，尝试用不同的浏览器发送请求，或请求不同的地址，比如 127.0.0.1:7878/test，来观察请求数据如何变化。现在我们知道了浏览器请求了什么。让我们返回一些数据！","breadcrumbs":"最后的项目：构建多线程 web server » 建立单线程 web server » 读取请求","id":"393","title":"读取请求"},"394":{"body":"我们将实现在客户端请求的响应中发送数据的功能。响应有如下格式： HTTP-Version Status-Code Reason-Phrase CRLF\nheaders CRLF\nmessage-body 第一行叫做状态行（ status line ），它包含响应的 HTTP 版本、一个数字状态码用以总结请求的结果和一个描述之前状态码的文本原因短语。CRLF 序列之后是任意 header，另一个 CRLF 序列，和响应的 body。这里是一个使用 HTTP 1.1 版本的响应例子，其状态码为 200，原因短语为 OK，没有 header，也没有 body： HTTP/1.1 200 OK\\r\\n\\r\\n 状态码 200 是一个标准的成功响应。这些文本是一个微型的成功 HTTP 响应。让我们将这些文本写入流作为成功请求的响应！在 handle_connection 函数中，我们需要去掉打印请求数据的 println!，并替换为示例 20-3 中的代码：文件名：src/main.rs # use std::{\n# io::{prelude::*, BufReader},\n# net::{TcpListener, TcpStream},\n# };\n# # fn main() {\n# let listener = TcpListener::bind(\"127.0.0.1:7878\").unwrap();\n# # for stream in listener.incoming() {\n# let stream = stream.unwrap();\n# # handle_connection(stream);\n# }\n# }\n# fn handle_connection(mut stream: TcpStream) { let buf_reader = BufReader::new(&stream); let http_request: Vec<_> = buf_reader .lines() .map(|result| result.unwrap()) .take_while(|line| !line.is_empty()) .collect(); let response = \"HTTP/1.1 200 OK\\r\\n\\r\\n\"; stream.write_all(response.as_bytes()).unwrap();\n} 示例 20-3: 将一个微型成功 HTTP 响应写入流新代码中的第一行定义了变量 response 来存放将要返回的成功响应的数据。接着，在 response 上调用 as_bytes，因为 stream 的 write_all 方法获取一个 &[u8] 并直接将这些字节发送给连接。因为 write_all 操作可能会失败，所以像之前那样对任何错误结果使用 unwrap。同理，在真实世界的应用中这里需要添加错误处理。有了这些修改，运行我们的代码并进行请求！我们不再向终端打印任何数据，所以不会再看到除了 Cargo 以外的任何输出。不过当在浏览器中加载 127.0.0.1:7878 时，会得到一个空页面而不是错误。太棒了！我们刚刚手写收发了一个 HTTP 请求与响应。","breadcrumbs":"最后的项目：构建多线程 web server » 建立单线程 web server » 编写响应","id":"394","title":"编写响应"},"395":{"body":"让我们实现不只是返回空页面的功能。在项目根目录创建一个新文件， hello.html —— 也就是说，不是在 src 目录。在此可以放入任何你期望的 HTML；列表 20-4 展示了一个可能的文本：文件名：hello.html <!DOCTYPE html>\n<html lang=\"en\"> <head> <meta charset=\"utf-8\"> <title>Hello!