update ch01

README.md

@@ -16,7 +16,7 @@ PS:
 
 ## 校对
 
-部分章节采用 ChatGPT 进行校对。提示词详见 [proofreading_prompt.md](proofreading_prompt.md)
+部分章节采用 Codex 进行校对。提示词可参考 [proofreading_prompt.md](proofreading_prompt.md)
 
 ## 静态页面构建与文档撰写
 

src/ch01-00-getting-started.md

@@ -1,10 +1,9 @@
 # 入门指南
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch01-00-getting-started.md -->
-<!-- commit 3a30e4c1fbe641afc066b3af9eb01dcdf5ed8b24 -->
+[ch01-00-getting-started.md](https://github.com/rust-lang/book/blob/3a30e4c1fbe641afc066b3af9eb01dcdf5ed8b24/src/ch01-00-getting-started.md)
 
-让我们开始 Rust 之旅！有很多内容需要学习，但每次旅程总有起点。在本章中，我们会讨论：
+让我们开始 Rust 之旅吧！需要学习的内容有很多，但每段旅程都始于某处。在本章中，我们将讨论：
 
-* 在 Linux、macOS 和 Windows 上安装 Rust
-* 编写一个打印 `Hello, world!` 的程序
-* 使用 Rust 的包管理器和构建系统 `cargo`
+- 在 Linux、macOS 和 Windows 上安装 Rust
+- 编写一个打印 `Hello, world!` 的程序
+- 使用 Rust 的包管理器和构建系统 `cargo`

src/ch01-01-installation.md

@@ -1,13 +1,12 @@
 ## 安装
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch01-01-installation.md -->
-<!-- a4f94174155ff413f23af936c3a31ab71f11cb6f -->
+[ch01-01-installation.md](https://github.com/rust-lang/book/blob/369386fefd1138cbdf50ae628bae1ffc4ffce669/src/ch01-01-installation.md)
 
 第一步是安装 Rust。我们会通过 `rustup` 下载 Rust，这是一个管理 Rust 版本和相关工具的命令行工具。下载时需要联网。
 
 > 注意：如果你出于某些理由倾向于不使用 `rustup`，请到 [Rust 的其他安装方法页面][otherinstall] 查看其它安装选项。
 
-接下来的步骤会安装最新的稳定版 Rust 编译器。Rust 的稳定性确保本书所有示例在最新版本的 Rust 中能够继续编译。不同版本的输出可能略有不同，因为 Rust 经常改进错误信息和警告。也就是说，任何通过这些步骤安装的最新稳定版 Rust，都应该能正常运行本书中的内容。
+接下来的步骤会安装最新稳定版 Rust 编译器。Rust 的稳定性保证意味着，本书中所有能够编译的示例，在更新的 Rust 版本中也应继续能够编译。不同版本之间的输出可能略有差异，因为 Rust 经常会改进错误信息和警告。也就是说，按照这些步骤安装的任何较新的稳定版 Rust，都应该能正常配合本书内容使用。
 
 > ### 命令行标记
 >
@@ -21,13 +20,13 @@
 $ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
 ```
 
-此命令下载一个脚本并开始安装 `rustup` 工具，这会安装最新稳定版 Rust。过程中可能会提示你输入密码。如果安装成功，将会出现如下内容：
+这条命令会下载一个脚本并启动 `rustup` 工具的安装，它会安装最新稳定版 Rust。过程中可能会提示你输入密码。如果安装成功，将会出现如下内容：
 
 ```text
 Rust is installed now. Great!
 ```
 
-另外，你还需要一个 *链接器（linker）*，它是 Rust 用来将其编译的输出链接成一个文件的程序。很可能你已经有一个了。如果你遇到了链接器错误，请尝试安装一个 C 编译器，它通常包括一个链接器。C 编译器也很有用，因为一些常见的 Rust 包依赖于 C 代码，因此需要安装一个 C 编译器。
+另外，你还需要一个 *链接器（linker）*，它是 Rust 用来将编译输出连接成单个文件的程序。你很可能已经安装了它。如果遇到链接器错误，你应该安装一个 C 编译器，其中通常会包含链接器。C 编译器本身也很有用，因为一些常见的 Rust 包依赖 C 代码，因此需要 C 编译器。
 
 在 macOS 上，你可以通过运行以下命令获得 C 语言编译器：
 
@@ -35,29 +34,29 @@ Rust is installed now. Great!
 $ xcode-select --install
 ```
 
-Linux 用户通常需要根据发行版（distribution）文档安装 GCC 或 Clang。比如，如果你使用 Ubuntu，可以安装 `build-essential` 包。
+Linux 用户通常应根据自己发行版（distribution）的文档安装 GCC 或 Clang。比如，如果你使用 Ubuntu，可以安装 `build-essential` 包。
 
 ### 在 Windows 上安装 `rustup`
 
-在 Windows 上，前往 [https://www.rust-lang.org/install.html][install] 并按照说明安装 Rust。在安装过程的某个步骤，你会被提示要安装 Visual Studio。它提供了一个链接器和编译程序所需的原生库。如果你在此步骤需要更多帮助，请访问 [https://rust-lang.github.io/rustup/installation/windows-msvc.html][msvc]。
+在 Windows 上，前往 [https://www.rust-lang.org/tools/install][install] 并按照说明安装 Rust。在安装过程中的某一步，你会被提示安装 Visual Studio。它提供了链接器以及编译程序所需的本地库。如果你在这一步需要更多帮助，请访问 [https://rust-lang.github.io/rustup/installation/windows-msvc.html][msvc]。
 
 本书的余下部分会使用能同时运行于 *cmd.exe* 和 PowerShell 的命令。如果存在特定差异，我们会解释使用哪一个。
 
 ### 故障排除（Troubleshooting）
 
-要检查是否正确安装了 Rust，打开命令行并输入：
+要检查 Rust 是否安装正确，打开 shell 并输入：
 
 ```console
 $ rustc --version
 ```
 
-你应该可以看到按照以下格式显示的最新稳定版本的版本号、对应的 Commit Hash 和 Commit 日期：
+你应该会看到已发布的最新稳定版的版本号、commit hash 和 commit 日期，格式如下：
 
 ```text
 rustc x.y.z (abcabcabc yyyy-mm-dd)
 ```
 
-如果看到了这样的信息，就说明 Rust 已经安装成功了！如果没看到，请按照下面说明的方法检查 Rust 是否在您的 `%PATH%` 系统变量中。
+如果看到了这些信息，就说明 Rust 已经安装成功了！如果没有看到，请按下面的方法检查 Rust 是否在你的 `%PATH%` 系统变量中。
 
 在 Windows CMD 中，请使用命令：
 
@@ -77,17 +76,17 @@ rustc x.y.z (abcabcabc yyyy-mm-dd)
 $ echo $PATH
 ```
 
-如果一切正确但 Rust 仍不能使用，有许多地方可以求助。您可以在[社区页面][community]查看如何与其他 Rustaceans（Rust 用户的称号，有自嘲意味）联系。
+如果这些都没问题但 Rust 仍然无法使用，还有很多地方可以求助。你可以在[社区页面][community]查看如何联系其他 Rustaceans（Rust 用户对自己的一个戏称）。
 
 ## 更新与卸载
 
-通过 `rustup` 安装了 Rust 之后，更新到最新版本就很简单了。只需要在您对应的命令行中运行如下更新脚本：
+通过 `rustup` 安装 Rust 之后，更新到新发布的版本很简单。只需要在 shell 中运行下面的更新脚本：
 
 ```console
 $ rustup update
 ```
 
-若要卸载 Rust 和 `rustup`，请在命令行中运行如下卸载脚本：
+若要卸载 Rust 和 `rustup`，请在 shell 中运行下面的卸载脚本：
 
 ```console
 $ rustup self uninstall
@@ -95,17 +94,18 @@ $ rustup self uninstall
 
 ### 本地文档
 
-安装程序也自带一份文档的本地拷贝，可以离线阅读。运行 `rustup doc` 在浏览器中查看本地文档。
+安装 Rust 时也会附带一份文档的本地副本，供你离线阅读。运行 `rustup doc` 即可在浏览器中打开本地文档。
+
+任何时候，如果标准库提供了某个类型或函数，而你不确定它是做什么的或该如何使用，请查阅应用程序接口（application programming interface，API）文档！
 
-任何时候，如果你拿不准标准库中的类型或函数的用途和用法，请查阅应用程序接口（application programming interface，API）文档！
 
 ### 文本编辑器和集成开发环境（Integrated Development Environments, IDE）
 
-本书不会假设你使用何种工具来编写 Rust 代码。几乎任何文本编辑器都可以搞定！然而，很多文本编辑器和集成开发环境（IDE）内置了 Rust 支持。你总是可以在 Rust 官网的[工具页面][tools]找到很多相对流行的编辑器和 IDE 列表。
+本书不假设你使用什么工具来编写 Rust 代码。几乎任何文本编辑器都能胜任！不过，许多文本编辑器和集成开发环境（IDE）都内置了对 Rust 的支持。你总是可以在 Rust 官网的[工具页面][tools]找到一个相对较新的常见编辑器和 IDE 列表。
 
 ### 离线使用本书
 
-在一些示例中，我们将会使用标准库之外的 Rust 包。要运行这些示例，你需要保持网络连接，或者事先下载好这些依赖。要提前下载依赖，可以运行以下命令。（我们稍后会详细解释 `cargo` 是什么，以及这些命令分别的作用。）
+在一些示例中，我们会使用标准库之外的 Rust 包。要运行这些示例，你需要保持网络连接，或者提前下载好这些依赖。要预先下载依赖，可以运行以下命令。（稍后我们会详细解释 `cargo` 是什么，以及这些命令分别有什么作用。）
 
 ```console
 $ cargo new get-dependencies
@@ -113,7 +113,7 @@ $ cd get-dependencies
 $ cargo add rand@0.8.5 trpl@0.2.0
 ```
 
-这会将这些包的下载结果缓存起来，因此你之后就不需要再下载它们了。运行完该命令后，你无需保留 `get-dependencies` 文件夹。一旦你运行了这些命令，就可以在本书之后所有的 `cargo` 命令中，使用 `--offline` 参数来使用这些缓存的版本，而不必尝试使用网络。
+这会把这些包下载并缓存起来，因此之后你就不需要再次下载它们了。运行完这些命令后，你无需保留 `get-dependencies` 文件夹。只要你执行过这些命令，在本书后续所有的 `cargo` 命令中，都可以使用 `--offline` 参数来使用这些已缓存的版本，而不必尝试联网。
 
 [otherinstall]: https://forge.rust-lang.org/infra/other-installation-methods.html
 [install]: https://www.rust-lang.org/tools/install

src/ch01-02-hello-world.md

@@ -1,7 +1,6 @@
 ## Hello, World!
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch01-02-hello-world.md -->
-<!-- commit aba1ee29dca6c90a1737c996efd7c870957aefb8 -->
+[ch01-02-hello-world.md](https://github.com/rust-lang/book/blob/d46785983db2d2f94ca3d571db2cfbad0f5ad3e6/src/ch01-02-hello-world.md)
 
 既然安装好了 Rust，是时候来编写第一个 Rust 程序了。当学习一门新语言的时候，使用该语言在屏幕上打印 `Hello, world!` 是一项传统，我们将沿用这一传统！
 
@@ -9,7 +8,7 @@
 
 ### 创建项目目录
 
-首先创建一个存放 Rust 代码的目录。Rust 并不关心代码的存放位置，不过对于本书的练习和项目来说，我们建议你在 home 目录中创建 *projects* 目录，并将你的所有项目存放在这里。
+首先创建一个存放 Rust 代码的目录。Rust 并不关心代码存放在哪里，不过对于本书中的练习和项目，我们建议你在 home 目录中创建一个 *projects* 目录，并将所有项目都放在那里。
 
 打开终端并输入如下命令创建 *projects* 目录，并在 *projects* 目录中为 “Hello, world!” 项目创建一个目录。
 
@@ -31,9 +30,9 @@ $ cd hello_world
 > cd hello_world
 ```
 
-### 编写并运行 Rust 程序
+### Rust 程序基础
 
-接下来，新建一个源文件，命名为 *main.rs*。Rust 源文件总是以 *.rs* 扩展名结尾。如果文件名包含多个单词，那么按照命名习惯，应当使用下划线来分隔单词。例如命名为 *hello_world.rs*，而不是 *helloworld.rs*。
+接下来，新建一个源文件，命名为 *main.rs*。Rust 文件总是以 *.rs* 扩展名结尾。如果文件名包含多个单词，那么按照命名习惯，应当使用下划线来分隔单词。例如应命名为 *hello_world.rs*，而不是 *helloworld.rs*。
 
 现在打开刚创建的 *main.rs* 文件，输入示例 1-1 中的代码。
 
@@ -60,7 +59,7 @@ $ ./main
 Hello, world!
 ```
 
-在 Windows 上，输入命令 `.\main.exe`，而不是 `./main`：
+在 Windows 上，输入命令 `.\main`，而不是 `./main`：
 
 ```powershell
 > rustc main.rs
@@ -70,7 +69,7 @@ Hello, world!
 
 不管使用何种操作系统，终端应该打印字符串 `Hello, world!`。如果没有看到这些输出，回到安装部分的 [“故障排除”][troubleshooting] 小节查找有帮助的方法。
 
-如果 `Hello, world!` 出现了，恭喜你！你已经正式编写了一个 Rust 程序。现在你成为一名 Rust 程序员，欢迎！
+如果 `Hello, world!` 确实打印出来了，恭喜你！你已经正式写出了一个 Rust 程序。现在你已经是一名 Rust 程序员了，欢迎加入！
 
 ### Rust 程序的结构
 
@@ -82,7 +81,7 @@ fn main() {
 }
 ```
 
-这几行定义了一个名叫 `main` 的函数。`main` 函数是一个特殊的函数：在可执行的 Rust 程序中，它总是最先运行的代码。第一行代码声明了一个叫做 `main` 的函数，它没有参数也没有返回值。如果有参数的话，它们的名称应该出现在小括号 `()` 中。
+这几行定义了一个名叫 `main` 的函数。`main` 函数很特殊：在每个可执行的 Rust 程序中，它都是最先运行的代码。这里第一行声明了一个名为 `main` 的函数，它没有参数也没有返回值。如果有参数，它们会写在小括号 `()` 中。
 
 函数体被包裹在 `{}` 中。Rust 要求所有函数体都要用花括号包裹起来。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。
 
@@ -96,13 +95,13 @@ println!("Hello, world!");
 
 这行代码完成这个简单程序的所有工作：在屏幕上打印文本。这里有三个重要的细节需要注意。
 
-首先，`println!` 调用了一个 Rust 宏（macro）。如果是调用函数，则应输入 `println`（没有`!`）。我们将在[第二十章][ch20-macros]详细讨论宏。现在你只需记住，当看到符号 `!` 的时候，就意味着调用的是宏而不是普通函数，并且宏并不总是遵循与函数相同的规则。
+首先，`println!` 调用了一个 Rust 宏（macro）。如果调用的是函数，就应该写成 `println`（不带 `!`）。Rust 宏是一种用来编写可生成代码的代码，从而扩展 Rust 语法的方式；我们将在[第二十章][ch20-macros]详细讨论宏。现在你只需要知道，看到 `!` 就意味着调用的是宏而不是普通函数，并且宏并不总是遵循与函数相同的规则。
 
 第二，`"Hello, world!"` 是一个字符串。我们把这个字符串作为一个参数传递给 `println!`，字符串将被打印到屏幕上。
 
 第三，该行以分号结尾（`;`），这代表一个表达式的结束和下一个表达式可以开始。大部分 Rust 代码行以分号结尾。
 
-### 编译和运行是彼此独立的步骤
+### 编译与运行
 
 你刚刚运行了一个新创建的程序，那么让我们检查此过程中的每一个步骤。
 
@@ -114,7 +113,7 @@ $ rustc main.rs
 
 如果你有 C 或 C++ 背景，就会发现这与 `gcc` 和 `clang` 类似。编译成功后，Rust 会输出一个二进制的可执行文件。
 
-在 Linux、macOS 或 Windows 的 PowerShell 上，在 shell 中输入 `ls` 命令可以看见这个可执行文件。
+在 Linux、macOS，以及 Windows 的 PowerShell 上，你可以在 shell 中输入 `ls` 命令来查看这个可执行文件。
 
 ```console
 $ ls
@@ -130,7 +129,7 @@ main.pdb
 main.rs
 ```
 
-这展示了扩展名为 *.rs* 的源文件、可执行文件（在 Windows 下是 *main.exe*，其它平台是 *main*），以及当使用 CMD 时会有一个包含调试信息、扩展名为 *.pdb* 的文件。从这里开始运行 *main* 或 *main.exe* 文件，如下：
+这展示了带有 *.rs* 扩展名的源代码文件、可执行文件（Windows 上是 *main.exe*，其他平台上则是 *main*），以及在 Windows 上一个带有 *.pdb* 扩展名、包含调试信息的文件。接下来，你可以运行 *main* 或 *main.exe*，如下所示：
 
 ```console
 $ ./main # Windows 是 .\main.exe
@@ -138,7 +137,7 @@ $ ./main # Windows 是 .\main.exe
 
 如果这里的 *main.rs* 是上文所述的 “Hello, world!” 程序，那么在终端上就会打印出 `Hello, world!`。
 
-如果你更熟悉动态语言，如 Ruby、Python 或 JavaScript，则可能不习惯将编译和运行分为两个单独的步骤。Rust 是一种 **预编译静态类型**（*ahead-of-time compiled*）语言，这意味着你可以编译程序，并将可执行文件送给其他人，他们甚至不需要安装 Rust 就可以运行。如果你给他人一个 *.rb*、*.py* 或 *.js* 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM）。不过在这些语言中，只需要一句命令就可以编译和运行程序。这一切都是语言设计上的权衡取舍。
+如果你更熟悉 Ruby、Python 或 JavaScript 这样的动态语言，可能不太习惯把编译和运行分成两个独立步骤。Rust 是一种 **预先编译**（*ahead-of-time compiled*）语言，这意味着你可以先将程序编译好，再把可执行文件交给其他人；即使他们没有安装 Rust，也可以直接运行。如果你给别人的是一个 *.rb*、*.py* 或 *.js* 文件，他们就需要分别安装 Ruby、Python 或 JavaScript 的实现（运行时环境）。不过在这些语言中，编译和运行程序通常只需要一条命令。语言设计中的一切都是权衡取舍。
 
 仅仅使用 `rustc` 编译简单程序是没问题的，不过随着项目的增长，你可能需要管理你项目的方方面面，并让代码易于分享。接下来，我们要介绍一个叫做 Cargo 的工具，它会帮助你编写真实世界中的 Rust 程序。
 

src/ch01-03-hello-cargo.md

@@ -1,19 +1,18 @@
 ## Hello, Cargo!
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch01-03-hello-cargo.md -->
-<!-- commit b8b94b3d93ddd5186efa079913a78cb49a679a13 -->
+[ch01-03-hello-cargo.md](https://github.com/rust-lang/book/blob/369386fefd1138cbdf50ae628bae1ffc4ffce669/src/ch01-03-hello-cargo.md)
 
-Cargo 是 Rust 的构建系统和包管理器。大多数 Rustacean 们使用 Cargo 来管理他们的 Rust 项目，因为它可以为你处理很多任务，比如构建代码、下载依赖库并编译这些库。（我们把代码所需要的库叫做 **依赖**（*dependencies*））。
+Cargo 是 Rust 的构建系统和包管理器。大多数 Rustaceans 都使用 Cargo 来管理他们的 Rust 项目，因为 Cargo 会替你处理许多任务，比如构建代码、下载代码依赖的库并编译这些库。（我们把代码所需要的库称为 **依赖**（*dependencies*）。）
 
-最简单的 Rust 程序，比如我们刚刚编写的，没有任何依赖。如果使用 Cargo 来构建 “Hello, world!” 项目，将只会用到 Cargo 构建代码的那部分功能。在编写更复杂的 Rust 程序时，你将添加依赖项，如果使用 Cargo 启动项目，则添加依赖项将更加容易。
+最简单的 Rust 程序，比如我们刚刚编写的那个，没有任何依赖。如果使用 Cargo 来构建 “Hello, world!” 项目，那么只会用到 Cargo 中负责构建代码的那部分功能。随着你编写更复杂的 Rust 程序，就会加入依赖项；如果项目一开始就是用 Cargo 创建的，那么添加依赖项会容易得多。
 
-由于绝大多数 Rust 项目使用 Cargo，本书接下来的部分假设你也使用 Cargo。如果使用 [“安装”][installation] 部分介绍的官方安装包的话，则自带了 Cargo。如果通过其他方式安装的话，可以在终端输入如下命令检查是否安装了 Cargo：
+由于绝大多数 Rust 项目都使用 Cargo，本书接下来的部分也假设你会使用 Cargo。如果你使用的是 [“安装”][installation] 部分介绍的官方安装方式，那么 Cargo 会随 Rust 一起安装。如果你通过其他方式安装 Rust，可以在终端输入如下命令检查是否安装了 Cargo：
 
 ```console
 $ cargo --version
 ```
 
-如果你看到了版本号，说明已安装！如果看到类似 `command not found` 的错误，你应该查看相应安装文档以确定如何单独安装 Cargo。
+如果你看到了版本号，说明 Cargo 已经安装好了！如果看到类似 `command not found` 的错误，你应该查阅相应安装方式的文档，确定如何单独安装 Cargo。
 
 ### 使用 Cargo 创建项目
 
@@ -24,13 +23,13 @@ $ cargo new hello_cargo
 $ cd hello_cargo
 ```
 
-第一行命令新建了名为 *hello_cargo* 的目录和项目。我们将项目命名为 *hello_cargo*，同时 Cargo 在一个同名目录中创建项目文件。
+第一条命令会新建一个名为 *hello_cargo* 的目录和项目。我们将项目命名为 *hello_cargo*，Cargo 也会在同名目录中创建项目文件。
 
-进入 *hello_cargo* 目录并列出文件。将会看到 Cargo 生成了两个文件和一个目录：一个 *Cargo.toml* 文件，一个 *src* 目录，以及位于 *src* 目录中的 *main.rs* 文件。
+进入 *hello_cargo* 目录并列出文件。你会看到 Cargo 为我们生成了两个文件和一个目录：一个 *Cargo.toml* 文件、一个 *src* 目录，以及位于 *src* 目录中的 *main.rs* 文件。
 
-这也会在 *hello_cargo* 目录初始化了一个 git 仓库，以及一个 *.gitignore* 文件。如果在一个已经存在的 git 仓库中运行 `cargo new`，则这些 git 相关文件则不会生成；可以通过运行 `cargo new --vcs=git` 来覆盖这些行为。
+它还会在 *hello_cargo* 目录中初始化一个 Git 仓库，并生成一个 *.gitignore* 文件。如果在一个已经存在的 Git 仓库中运行 `cargo new`，这些 Git 相关文件就不会再生成；你可以通过运行 `cargo new --vcs=git` 来覆盖这个行为。
 
-> 注意：git 是一个常用的版本控制系统（version control system，VCS）。可以通过 `--vcs` 参数使 `cargo new` 切换到其它版本控制系统（VCS），或者不使用 VCS。运行 `cargo new --help` 查看可用的选项。
+> 注意：Git 是一种常见的版本控制系统（version control system，VCS）。你可以通过 `--vcs` 参数让 `cargo new` 使用其他版本控制系统，或者不使用 VCS。运行 `cargo new --help` 可以查看可用选项。
 
 请自行选用文本编辑器打开 *Cargo.toml* 文件。它应该看起来与示例 1-2 中代码类似：
 
@@ -51,13 +50,13 @@ edition = "2024"
 
 </figure>
 
-这个文件使用 [*TOML*][toml]<!-- ignore --> (*Tom's Obvious, Minimal Language*) 格式，这是 Cargo 配置文件的格式。
+这个文件使用 [*TOML*][toml]<!-- ignore -->（*Tom's Obvious, Minimal Language*）格式，这是 Cargo 配置文件所使用的格式。
 
-第一行，`[package]`，是一个片段 section 标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他 section。
+第一行 `[package]` 是一个 section 标题，表明下面的语句是在配置一个 package。随着我们在这个文件中加入更多信息，还会增加其他 section。
 
-接下来的三行设置了 Cargo 编译程序所需的配置：项目的名称、项目的版本以及要使用的 Rust 版本。[附录 E][appendix-e] 会介绍 `edition` 的值。
+接下来的三行设置了 Cargo 编译程序所需的配置信息：项目名称、项目版本，以及要使用的 Rust edition。[附录 E][appendix-e] 会介绍 `edition` 这个键。
 
-最后一行，`[dependencies]`，是罗列项目依赖的 section 的开始。在 Rust 中，代码包被称为 *crates*。这个项目并不需要其他的 crate，不过在第二章的第一个项目会用到依赖，那时会用得上这个 section。
+最后一行 `[dependencies]` 是列出项目依赖的 section 的开始。在 Rust 中，代码包被称为 *crates*。这个项目不需要其他 crate，不过在第二章的第一个项目中我们就会需要依赖，到时候会用到这个 section。
 
 现在打开 *src/main.rs* 看看：
 
@@ -69,15 +68,15 @@ fn main() {
 }
 ```
 
-Cargo 为你生成了一个 “Hello, world!” 程序，正如我们之前编写的示例 1-1！目前为止，我们的项目与 Cargo 生成项目的区别是 Cargo 将代码放在 *src* 目录，同时项目根目录包含一个 *Cargo.toml* 配置文件。
+Cargo 为你生成了一个 “Hello, world!” 程序，正如我们之前写的示例 1-1！到目前为止，我们的项目与 Cargo 生成的项目之间的区别在于：Cargo 将代码放在 *src* 目录中，并在项目根目录放置了一个 *Cargo.toml* 配置文件。
 
-Cargo 期望源文件存放在 *src* 目录中。项目根目录只存放 README、license 信息、配置文件和其他跟代码无关的文件。使用 Cargo 帮助你保持项目干净整洁。一切各得其所，井井有条。
+Cargo 期望你的源文件位于 *src* 目录中。项目根目录则只用来放 README、license 信息、配置文件，以及其他与代码无关的内容。使用 Cargo 有助于让项目保持整洁：各类文件各归其位。
 
-如果没有使用 Cargo 开始项目，比如我们创建的 “Hello, world!” 项目，你可以将其转换为使用 Cargo 的项目。将项目代码移入 *src* 目录，并创建一个合适的 *Cargo.toml* 文件。一个简单的创建 *Cargo.toml* 文件的方法是运行 `cargo init`，它会自动为你创建该文件。
+如果你一开始没有使用 Cargo 创建项目，比如我们之前创建的 “Hello, world!” 项目，你也可以把它转换成一个使用 Cargo 的项目。只要把项目代码移到 *src* 目录中，并创建一个合适的 *Cargo.toml* 文件即可。一个简单的办法是运行 `cargo init`，它会自动为你创建这个文件。
 
 ### 构建并运行 Cargo 项目
 
-现在让我们看看通过 Cargo 构建和运行 “Hello, world!” 程序有什么不同！在 *hello_cargo* 目录下，输入下面的命令来构建项目：
+现在让我们来看看，使用 Cargo 构建和运行 “Hello, world!” 程序有什么不同！在 *hello_cargo* 目录下，输入下面的命令来构建项目：
 
 ```console
 $ cargo build
@@ -85,16 +84,16 @@ $ cargo build
     Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
 ```
 
-这个命令会创建一个可执行文件 *target/debug/hello_cargo* （在 Windows 上是 *target\debug\hello_cargo.exe*），而不是放在目前目录下。由于默认的构建方法是调试构建（debug build），Cargo 会将可执行文件放在名为 *debug* 的目录中。可以通过这个命令运行可执行文件：
+这条命令会在 *target/debug/hello_cargo* 生成一个可执行文件（Windows 上是 *target\debug\hello_cargo.exe*），而不是放在当前目录下。因为默认构建方式是调试构建（debug build），Cargo 会把可执行文件放在名为 *debug* 的目录中。你可以用下面的命令运行这个可执行文件：
 
 ```console
 $ ./target/debug/hello_cargo # 或者在 Windows 下为 .\target\debug\hello_cargo.exe
 Hello, world!
 ```
 
-如果一切顺利，终端上应该会打印出 `Hello, world!`。首次运行 `cargo build` 时，也会使 Cargo 在项目根目录创建一个新文件：*Cargo.lock*。这个文件记录项目依赖的实际版本。这个项目并没有依赖，所以其内容比较少。你永远也不需要手动编辑该文件；`Cargo` 会为你管理它。
+如果一切顺利，终端上应该会打印出 `Hello, world!`。第一次运行 `cargo build` 时，Cargo 还会在项目根目录创建一个新文件：*Cargo.lock*。这个文件会记录项目依赖的精确版本。由于这个项目没有依赖，所以文件内容比较少。你永远都不需要手动修改这个文件；Cargo 会替你管理它的内容。
 
-我们刚刚使用 `cargo build` 构建了项目，并使用 `./target/debug/hello_cargo` 运行了程序，也可以使用 `cargo run` 在一个命令中同时编译并运行生成的可执行文件：
+我们刚刚使用 `cargo build` 构建了项目，并使用 `./target/debug/hello_cargo` 运行了程序；也可以使用 `cargo run`，在一条命令中完成编译并运行生成的可执行文件：
 
 ```console
 $ cargo run
@@ -105,7 +104,7 @@ Hello, world!
 
 比起必须先运行 `cargo build` 再用可执行文件的完整路径来执行程序，使用 `cargo run` 更方便，所以大多数开发者会选择 `cargo run`。
 
-注意这一次并没有出现表明 Cargo 正在编译 `hello_cargo` 的输出。Cargo 发现文件并没有被改变，所以它并没有重新构建，而是直接运行了二进制文件。如果修改了源文件的话，Cargo 会在运行之前重新构建项目，并会出现像这样的输出：
+注意，这一次并没有出现表明 Cargo 正在编译 `hello_cargo` 的输出。Cargo 发现文件没有发生变化，所以它没有重新构建，而是直接运行了二进制文件。如果你修改了源文件，Cargo 就会在运行之前重新构建项目，并会出现像这样的输出：
 
 ```console
 $ cargo run
@@ -123,27 +122,27 @@ $ cargo check
     Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
 ```
 
-为什么你会不需要可执行文件呢？通常 `cargo check` 要比 `cargo build` 快得多，因为它省略了生成可执行文件的步骤。如果你在编写代码时持续的进行检查，`cargo check` 可以让你快速了解现在的代码能不能正常通过编译！为此很多 Rustaceans 编写代码时定期运行 `cargo check` 确保它们可以编译。当准备好使用可执行文件时才运行 `cargo build`。
+为什么你会不需要可执行文件呢？通常 `cargo check` 比 `cargo build` 快得多，因为它省略了生成可执行文件这一步。如果你在编写代码时持续检查，`cargo check` 可以让你更快知道当前代码是否还能正常编译！因此，很多 Rustaceans 都会在编写程序时定期运行 `cargo check` 来确保代码可以编译；等到准备好使用可执行文件时，再运行 `cargo build`。
 
 我们回顾下已学习的 Cargo 内容：
 
-* 可以使用 `cargo new` 创建项目。
-* 可以使用 `cargo build` 构建项目。
-* 可以使用 `cargo run` 一步构建并运行项目。
-* 可以使用 `cargo check` 在不生成二进制文件的情况下构建项目来检查错误。
-* 有别于将构建结果放在与源码相同的目录，Cargo 会将其放到 *target/debug* 目录。
+- 可以使用 `cargo new` 创建项目。
+- 可以使用 `cargo build` 构建项目。
+- 可以使用 `cargo run` 一步构建并运行项目。
+- 可以使用 `cargo check` 在不生成二进制文件的情况下构建项目来检查错误。
+- 有别于将构建结果放在与源码相同的目录，Cargo 会将其放到 *target/debug* 目录。
 
-使用 Cargo 的一个额外的优点是，不论你使用什么操作系统，其命令都是一样的。所以从现在开始本书将不再分别为 Linux 和 macOS 以及 Windows 提供相应的命令。
+使用 Cargo 的另一个优点是，不论你使用什么操作系统，这些命令都是相同的。所以从现在开始，本书将不再分别为 Linux、macOS 和 Windows 提供单独的命令。
 
 ### 发布（release）构建
 
-当项目最终准备好发布时，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种是为了开发，你需要快速且频繁地重新构建；另一种是为用户构建最终程序，它们不会经常重新构建，并且希望程序运行得越快越好。如果你在基准测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。
+当项目最终准备好发布时，可以使用 `cargo build --release` 以启用优化方式编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化会让 Rust 代码运行得更快，不过开启优化也会延长编译时间。这就是为什么会有两种不同的 profile：一种用于开发，你会希望它能快速且频繁地重新构建；另一种用于构建最终交付给用户的程序，这种程序不会频繁重新构建，但会希望它运行得尽可能快。如果你在做代码运行时间的基准测试，请务必运行 `cargo build --release`，并使用 *target/release* 下的可执行文件进行测试。
 
 ### 把 Cargo 当作习惯
 
-对于简单项目，Cargo 并不比 `rustc` 提供了更多的优势，但随着程序变得更复杂，其价值会逐渐显现。一旦程序壮大到由多个文件组成，亦或者是需要其他的依赖，让 Cargo 协调构建过程就会简单得多。
+对于简单项目，Cargo 相比直接使用 `rustc` 并不会带来太多额外价值，但随着程序变得更复杂，它的价值就会逐渐显现。一旦程序增长到由多个文件组成，或者需要其他依赖，让 Cargo 来协调构建过程就会容易得多。
 
-即便 `hello_cargo` 项目十分简单，它现在也使用了很多在你之后的 Rust 生涯将会用到的实用工具。其实，要在任何已存在的项目上工作时，可以使用如下命令通过 Git 检出代码，移动到该项目目录并构建：
+尽管 `hello_cargo` 项目很简单，但它已经用上了许多你在后续 Rust 开发中会经常使用的真实工具。实际上，当你在任何已有项目上工作时，都可以使用如下命令，通过 Git 检出代码、进入项目目录并构建它：
 
 ```console
 $ git clone example.org/someproject
@@ -155,15 +154,15 @@ $ cargo build
 
 ## 总结
 
-你已经准备好开启 Rust 之旅了！在本章中，你学习了如何：
+你已经为继续 Rust 之旅做好准备了！在本章中，你学习了如何：
 
-* 使用 `rustup` 安装最新稳定版的 Rust
-* 更新到新版的 Rust
-* 打开本地安装的文档
-* 直接通过 `rustc` 编写并运行 Hello, world! 程序
-* 使用 Cargo 创建并运行新项目
+- 使用 `rustup` 安装最新稳定版 Rust
+- 更新到较新的 Rust 版本
+- 打开本地安装的文档
+- 直接通过 `rustc` 编写并运行 Hello, world! 程序
+- 使用 Cargo 创建并运行新项目
 
-是时候通过构建更实质性的程序来熟悉读写 Rust 代码了。所以在第二章我们会构建一个猜数字游戏程序。如果你更愿意从学习 Rust 常用的编程概念开始，请阅读第三章，接着再回到第二章。
+现在正是通过构建一个更实在的程序来熟悉 Rust 代码读写的好时机。因此，在第二章中我们会构建一个猜数字游戏程序。如果你更想先学习 Rust 中常见的编程概念，请先阅读第三章，然后再回到第二章。
 
 [installation]: ch01-01-installation.html#安装
 [toml]: https://toml.io