diff --git a/po/zh-CN.po b/po/zh-CN.po
index 28c2d000a64..7d2eb6d7474 100644
--- a/po/zh-CN.po
+++ b/po/zh-CN.po
@@ -4689,24 +4689,24 @@ msgstr "模式匹配：解构枚举、结构体和数组（array）。"
 
 #: src/welcome-day-2.md:7
 msgid "Methods: associating functions with types."
-msgstr ""
+msgstr "方法：将函数与类型相关联。"
 
 #: src/welcome-day-2.md:8
 msgid "Traits: behaviors shared by multiple types."
-msgstr ""
+msgstr "特征：多个类型所共有的行为。"
 
 #: src/welcome-day-2.md:9
 msgid "Generics: parameterizing types on other types."
-msgstr ""
+msgstr "泛型：对其他类型进行类型参数化。"
 
 #: src/welcome-day-2.md:10
 msgid ""
 "Standard library types and traits: a tour of Rust's rich standard library."
-msgstr ""
+msgstr "标准库类型和特征：探索 Rust 丰富的标准库。"
 
 #: src/pattern-matching/destructuring.md:3
 msgid "Like tuples, structs and enums can also be destructured by matching:"
-msgstr ""
+msgstr "与元组一样，结构体和枚举也可以通过匹配方式进行解构："
 
 #: src/pattern-matching/destructuring.md:5
 #: src/pattern-matching/destructuring.md:58
@@ -4715,15 +4715,15 @@ msgstr "结构体"
 
 #: src/pattern-matching/destructuring.md:17
 msgid "\"x.0 = 1, b = {b}, y = {y}\""
-msgstr ""
+msgstr "\"x.0 = 1, b = {b}, y = {y}\""
 
 #: src/pattern-matching/destructuring.md:18
 msgid "\"y = 2, x = {i:?}\""
-msgstr ""
+msgstr "\"y = 2, x = {i:?}\""
 
 #: src/pattern-matching/destructuring.md:19
 msgid "\"y = {y}, other fields were ignored\""
-msgstr ""
+msgstr "\"y = {y}, other fields were ignored\""
 
 #: src/pattern-matching/destructuring.md:26
 msgid ""
@@ -4736,15 +4736,15 @@ msgstr ""
 
 #: src/pattern-matching/destructuring.md:39
 msgid "\"cannot divide {n} into two equal parts\""
-msgstr ""
+msgstr "\"cannot divide {n} into two equal parts\""
 
 #: src/pattern-matching/destructuring.md:46
 msgid "\"{n} divided in two is {half}\""
-msgstr ""
+msgstr "\"{n} divided in two is {half}\""
 
 #: src/pattern-matching/destructuring.md:47
 msgid "\"sorry, an error happened: {msg}\""
-msgstr ""
+msgstr "\"sorry, an error happened: {msg}\""
 
 #: src/pattern-matching/destructuring.md:52
 msgid ""
@@ -4836,7 +4836,7 @@ msgstr ""
 
 #: src/pattern-matching/let-control-flow.md:24
 msgid "\"slept for {:?}\""
-msgstr ""
+msgstr "\"slept for {:?}\""
 
 #: src/pattern-matching/let-control-flow.md:33
 #, fuzzy
@@ -4850,26 +4850,31 @@ msgid ""
 "let_else.html). The \"else\" case must diverge (`return`, `break`, or panic "
 "- anything but falling off the end of the block)."
 msgstr ""
+"如需了解匹配模式并从函数返回的常见情况，请使用 [`let else`](https://doc.rust-"
+"lang.org/rust-by-example/flow_control/let_else.html)。\"else\" 分支必须执行不"
+"同的结束方式（例如，`return`、`break` 或 `panic`，但不能直接执行到代码块的末"
+"尾）。"
 
 #: src/pattern-matching/let-control-flow.md:45
 #: src/pattern-matching/let-control-flow.md:107
 msgid "\"got None\""
-msgstr ""
+msgstr "\"got None\""
 
 #: src/pattern-matching/let-control-flow.md:51
 #: src/pattern-matching/let-control-flow.md:111
+#, fuzzy
 msgid "\"got empty string\""
-msgstr ""
+msgstr "\"got empty string\""
 
 #: src/pattern-matching/let-control-flow.md:57
 #: src/pattern-matching/let-control-flow.md:115
 msgid "\"not a hex digit\""
-msgstr ""
+msgstr "\"not a hex digit\""
 
 #: src/pattern-matching/let-control-flow.md:62
 #: src/pattern-matching/solution.md:113
 msgid "\"result: {:?}\""
-msgstr ""
+msgstr "\"result: {:?}\""
 
 #: src/pattern-matching/let-control-flow.md:62
 #: src/methods-and-traits/exercise.md:114
@@ -4879,7 +4884,7 @@ msgstr ""
 #: src/testing/googletest.md:11 src/testing/googletest.md:12
 #: src/testing/solution.md:83
 msgid "\"foo\""
-msgstr ""
+msgstr "\"foo\""
 
 #: src/pattern-matching/let-control-flow.md:66
 msgid ""
@@ -4904,8 +4909,9 @@ msgstr ""
 "`while let`能让我们持续迭代所有项。"
 
 #: src/pattern-matching/let-control-flow.md:89
+#, fuzzy
 msgid "if-let"
-msgstr ""
+msgstr "if-let"
 
 #: src/pattern-matching/let-control-flow.md:91
 #, fuzzy
@@ -4925,23 +4931,26 @@ msgstr "与 `match` 不同的是，`if let` 不支持模式匹配的 guard 子
 
 #: src/pattern-matching/let-control-flow.md:96
 msgid "let-else"
-msgstr ""
+msgstr "let-else"
 
 #: src/pattern-matching/let-control-flow.md:98
+#, fuzzy
 msgid ""
 "`if-let`s can pile up, as shown. The `let-else` construct supports "
 "flattening this nested code. Rewrite the awkward version for students, so "
 "they can see the transformation."
 msgstr ""
+"`if-let` 可以堆叠使用，如下所示。`let-else` 结构支持展平此嵌套代码。将不通顺"
+"的版本重写，以便学生们能够理解其中的变化。"
 
 #: src/pattern-matching/let-control-flow.md:102
 msgid "The rewritten version is:"
-msgstr ""
+msgstr "重写后的版本为："
 
 #: src/pattern-matching/let-control-flow.md:122
 #, fuzzy
 msgid "while-let"
-msgstr "`while let` 循环"
+msgstr "while-let"
 
 #: src/pattern-matching/let-control-flow.md:124
 msgid ""
@@ -4960,18 +4969,24 @@ msgstr ""
 "可以解封时中断。`while let` 为上述情况提供了语法糖。"
 
 #: src/pattern-matching/exercise.md:3
+#, fuzzy
 msgid "Let's write a simple recursive evaluator for arithmetic expressions."
-msgstr ""
+msgstr "为算术表达式编写一个简单的递归评估器。先从定义二进制操作的枚举开始："
 
 #: src/pattern-matching/exercise.md:5
+#, fuzzy
 msgid ""
 "The `Box` type here is a smart pointer, and will be covered in detail later "
 "in the course. An expression can be \"boxed\" with `Box::new` as seen in the "
 "tests. To evaluate a boxed expression, use the deref operator (`*`) to "
 "\"unbox\" it: `eval(*boxed_expr)`."
 msgstr ""
+"这里的 `Box` 类型是智能指针，本课程稍后会详细介绍。可以使用 `Box::new` 对表达"
+"式进行 “封装”操作，如测试中所示。如需对已封装的表达式求值，请使用 deref 运算"
+"符将其 “解封装”：`eval(*boxed_expr)`。"
 
 #: src/pattern-matching/exercise.md:10
+#, fuzzy
 msgid ""
 "Some expressions cannot be evaluated and will return an error. The standard "
 "[`Result<Value, String>`](https://doc.rust-lang.org/std/result/enum.Result."
@@ -4979,6 +4994,8 @@ msgid ""
 "(`Ok(Value)`) or an error (`Err(String)`). We will cover this type in detail "
 "later."
 msgstr ""
+"部分表达式无法求值，将返回错误。`Res` 类型表示有效值或错误消息。这与我们后面"
+"将看到的标准库的“Result”非常类似。"
 
 #: src/pattern-matching/exercise.md:15
 msgid ""
@@ -4987,37 +5004,43 @@ msgid ""
 "`todo!()` and get the tests to pass one-by-one. You can also skip a test "
 "temporarily with `#[ignore]`:"
 msgstr ""
+"将代码复制粘贴到 Rust Playground，然后开始实现 `eval`。最终结果应能通过测试。"
+"使用 `todo!()` 并使测试逐个通过可能会很有帮助。您还可以使用 `#[ignore]` 暂时"
+"跳过测试："
 
 #: src/pattern-matching/exercise.md:26
+#, fuzzy
 msgid ""
 "If you finish early, try writing a test that results in division by zero or "
 "integer overflow. How could you handle this with `Result` instead of a panic?"
 msgstr ""
+"如果提前完成测试，请尝试编写一项可导致被零除或整数溢出的测试。如何使用 `Res::"
+"Err` 而非 panic 来应对这种情况？"
 
 #: src/pattern-matching/exercise.md:30 src/pattern-matching/solution.md:4
 msgid "/// An operation to perform on two subexpressions.\n"
-msgstr ""
+msgstr "/// An operation to perform on two subexpressions.\n"
 
 #: src/pattern-matching/exercise.md:38 src/pattern-matching/solution.md:12
 msgid "/// An expression, in tree form.\n"
-msgstr ""
+msgstr "/// An expression, in tree form.\n"
 
 #: src/pattern-matching/exercise.md:42 src/pattern-matching/solution.md:16
 msgid "/// An operation on two subexpressions.\n"
-msgstr ""
+msgstr "/// An operation on two subexpressions.\n"
 
 #: src/pattern-matching/exercise.md:45 src/pattern-matching/solution.md:19
 msgid "/// A literal value\n"
-msgstr ""
+msgstr "/// A literal value\n"
 
 #: src/pattern-matching/exercise.md:104 src/pattern-matching/solution.md:40
 #: src/pattern-matching/solution.md:102
 msgid "\"division by zero\""
-msgstr ""
+msgstr "\"division by zero\""
 
 #: src/pattern-matching/solution.md:112
 msgid "\"expr: {:?}\""
-msgstr ""
+msgstr "\"expr: {:?}\""
 
 #: src/methods-and-traits/methods.md:3
 msgid ""
@@ -5027,39 +5050,39 @@ msgstr "Rust 允许您将函数与新类型相关联。您可以使用“impl”
 
 #: src/methods-and-traits/methods.md:14
 msgid "// No receiver, a static method\n"
-msgstr ""
+msgstr "// No receiver, a static method\n"
 
 #: src/methods-and-traits/methods.md:19
 msgid "// Exclusive borrowed read-write access to self\n"
-msgstr ""
+msgstr "// Exclusive borrowed read-write access to self\n"
 
 #: src/methods-and-traits/methods.md:24
 msgid "// Shared and read-only borrowed access to self\n"
-msgstr ""
+msgstr "// Shared and read-only borrowed access to self\n"
 
 #: src/methods-and-traits/methods.md:26
 msgid "\"Recorded {} laps for {}:\""
-msgstr ""
+msgstr "\"Recorded {} laps for {}:\""
 
 #: src/methods-and-traits/methods.md:28
 msgid "\"Lap {idx}: {lap} sec\""
-msgstr ""
+msgstr "\"Lap {idx}: {lap} sec\""
 
 #: src/methods-and-traits/methods.md:32
 msgid "// Exclusive ownership of self\n"
-msgstr ""
+msgstr "// Exclusive ownership of self\n"
 
 #: src/methods-and-traits/methods.md:35
 msgid "\"Race {} is finished, total lap time: {}\""
-msgstr ""
+msgstr "\"Race {} is finished, total lap time: {}\""
 
 #: src/methods-and-traits/methods.md:40
 msgid "\"Monaco Grand Prix\""
-msgstr ""
+msgstr "\"Monaco Grand Prix\""
 
 #: src/methods-and-traits/methods.md:47
 msgid "// race.add_lap(42);\n"
-msgstr ""
+msgstr "// race.add_lap(42);\n"
 
 #: src/methods-and-traits/methods.md:51
 #, fuzzy
@@ -5179,32 +5202,32 @@ msgstr "Rust 让您可以依据特征对类型进行抽象化处理。特征与
 
 #: src/methods-and-traits/traits.md:18
 msgid "\"Oh you're a cutie! What's your name? {}\""
-msgstr ""
+msgstr "\"Oh you're a cutie! What's your name? {}\""
 
 #: src/methods-and-traits/traits.md:24
 #: src/methods-and-traits/trait-objects.md:20
 msgid "\"Woof, my name is {}!\""
-msgstr ""
+msgstr "\"Woof, my name is {}!\""
 
 #: src/methods-and-traits/traits.md:30
 #: src/methods-and-traits/trait-objects.md:26
 msgid "\"Miau!\""
-msgstr ""
+msgstr "\"Miau!\""
 
 #: src/methods-and-traits/traits.md:36
 #: src/methods-and-traits/trait-objects.md:33
 msgid "\"Fido\""
-msgstr ""
+msgstr "\"Fido\""
 
 #: src/methods-and-traits/traits.md:45
 msgid ""
 "A trait defines a number of methods that types must have in order to "
 "implement the trait."
-msgstr ""
+msgstr "trait 定义了类型实现该 trait 所必须具备的一些方法。"
 
 #: src/methods-and-traits/traits.md:48
 msgid "Traits are implemented in an `impl <trait> for <type> { .. }` block."
-msgstr ""
+msgstr "trait 在 `<type> { .. } 的 impl <trait>` 代码块中实现。"
 
 #: src/methods-and-traits/traits.md:50
 #, fuzzy
@@ -5220,27 +5243,27 @@ msgstr ""
 msgid ""
 "Supported traits can be automatically implemented for your custom types, as "
 "follows:"
-msgstr ""
+msgstr "系统可以自动为您的自定义类型实现支持的 trait，如下所示："
 
 #: src/methods-and-traits/deriving.md:15
 msgid "// Default trait adds `default` constructor.\n"
-msgstr ""
+msgstr "// Default trait adds `default` constructor.\n"
 
 #: src/methods-and-traits/deriving.md:16
 msgid "// Clone trait adds `clone` method.\n"
-msgstr ""
+msgstr "// Clone trait adds `clone` method.\n"
 
 #: src/methods-and-traits/deriving.md:17
 msgid "\"EldurScrollz\""
-msgstr ""
+msgstr "\"EldurScrollz\""
 
 #: src/methods-and-traits/deriving.md:18
 msgid "// Debug trait adds support for printing with `{:?}`.\n"
-msgstr ""
+msgstr "// Debug trait adds support for printing with `{:?}`.\n"
 
 #: src/methods-and-traits/deriving.md:19
 msgid "\"{:?} vs. {:?}\""
-msgstr ""
+msgstr "\"{:?} vs. {:?}\""
 
 #: src/methods-and-traits/deriving.md:25
 msgid ""
@@ -5248,6 +5271,8 @@ msgid ""
 "macros to add useful functionality. For example, `serde` can derive "
 "serialization support for a struct using `#[derive(Serialize)]`."
 msgstr ""
+"派生功能是通过宏实现的，并且许多 crate 提供有用的派生宏，以添加实用功能。例"
+"如，`serde` 可以使用 `#[derive(Serialize)]` 为结构体派生序列化支持。"
 
 #: src/methods-and-traits/trait-objects.md:3
 msgid ""
@@ -5256,8 +5281,9 @@ msgid ""
 msgstr "特征（Trait）对象可接受不同类型的值，举例来说，在集合中会是这样："
 
 #: src/methods-and-traits/trait-objects.md:36
+#, fuzzy
 msgid "\"Hello, who are you? {}\""
-msgstr ""
+msgstr "\"Hello, who are you? {}\""
 
 #: src/methods-and-traits/trait-objects.md:41
 msgid "Memory layout after allocating `pets`:"
@@ -5323,12 +5349,71 @@ msgid ""
 "- -'\n"
 "```"
 msgstr ""
+"```bob\n"
+" Stack                             Heap\n"
+".- - - - - - - - - - - - - -.     .- - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+":                           :     :                                             :\n"
+":    pets                   :     :                     +----+----+----+----"
+"+   :\n"
+":   +-----------+-------+   :     :   +-----+-----+  .->| F  | i  | d  | o  "
+"|   :\n"
+":   | ptr       |   o---+---+-----+-->| o o | o o |  |  +----+----+----+----"
+"+   :\n"
+":   | len       |     2 |   :     :   +-|-|-+-|-|-+  "
+"`---------.                :\n"
+":   | capacity  |     2 |   :     :     | |   | |    data      "
+"|                :\n"
+":   +-----------+-------+   :     :     | |   | |   +-------+--|-------"
+"+        :\n"
+":                           :     :     | |   | '-->| name  |  o, 4, 4 "
+"|        :\n"
+":                           :     :     | |   |     | age   |        5 "
+"|        :\n"
+"`- - - - - - - - - - - - - -'     :     | |   |     +-------+----------"
+"+        :\n"
+"                                  :     | |   "
+"|                                 :\n"
+"                                  :     | |   |      "
+"vtable                     :\n"
+"                                  :     | |   |     +----------------------"
+"+    :\n"
+"                                  :     | |   '---->| \"<Dog as Pet>::talk\" "
+"|    :\n"
+"                                  :     | |         +----------------------"
+"+    :\n"
+"                                  :     | "
+"|                                     :\n"
+"                                  :     | |    "
+"data                             :\n"
+"                                  :     | |   +-------+-------"
+"+                 :\n"
+"                                  :     | '-->| lives |     9 "
+"|                 :\n"
+"                                  :     |     +-------+-------"
+"+                 :\n"
+"                                  :     "
+"|                                       :\n"
+"                                  :     |      "
+"vtable                           :\n"
+"                                  :     |     +----------------------"
+"+          :\n"
+"                                  :     '---->| \"<Cat as Pet>::talk\" "
+"|          :\n"
+"                                  :           +----------------------"
+"+          :\n"
+"                                  :                                             :\n"
+"                                  '- - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"```"
 
 #: src/methods-and-traits/trait-objects.md:77
 msgid ""
 "Types that implement a given trait may be of different sizes. This makes it "
 "impossible to have things like `Vec<dyn Pet>` in the example above."
 msgstr ""
+"实现给定 trait 的类型可能大小不同。因此，上例中不可能具有像 `Vec<dyn Pet>` 这"
+"样的项。"
 
 #: src/methods-and-traits/trait-objects.md:79
 msgid ""
@@ -5341,6 +5426,8 @@ msgid ""
 "In the example, `pets` is allocated on the stack and the vector data is on "
 "the heap. The two vector elements are _fat pointers_:"
 msgstr ""
+"在本例中，`pets` 在栈上分配内存，矢量数据存储在堆上。这两个矢量元素是 _胖指针"
+"_："
 
 #: src/methods-and-traits/trait-objects.md:83
 msgid ""
@@ -5349,12 +5436,17 @@ msgid ""
 "wikipedia.org/wiki/Virtual_method_table) (vtable) for the `Pet` "
 "implementation of that particular object."
 msgstr ""
+"胖指针属于全角指针。它包含两个部分：指向实际对象的指针，以及指向该特定对象的 "
+"`Pet` 实现的 [虚拟方法表](https://en.wikipedia.org/wiki/"
+"Virtual_method_table) (vtable) 的指针。"
 
 #: src/methods-and-traits/trait-objects.md:86
 msgid ""
 "The data for the `Dog` named Fido is the `name` and `age` fields. The `Cat` "
 "has a `lives` field."
 msgstr ""
+"`Dog`（名为 Fido）类型的数据是 `name` 和 `age` 字段。`Cat` 类型包含一个 "
+"`lives` 字段。"
 
 #: src/methods-and-traits/trait-objects.md:88
 msgid "Compare these outputs in the above example:"
@@ -5363,7 +5455,7 @@ msgstr "比较上述示例中的这些输出："
 #: src/methods-and-traits/trait-objects.md:90
 #: src/methods-and-traits/trait-objects.md:91 src/std-traits/closures.md:62
 msgid "\"{} {}\""
-msgstr ""
+msgstr "\"{} {}\""
 
 #: src/methods-and-traits/trait-objects.md:92
 #: src/methods-and-traits/trait-objects.md:93
@@ -5373,7 +5465,7 @@ msgstr ""
 #: src/android/interoperability/cpp/rust-bridge.md:17
 #: src/async/pitfalls/cancellation.md:59
 msgid "\"{}\""
-msgstr ""
+msgstr "\"{}\""
 
 #: src/methods-and-traits/exercise.md:3
 msgid ""
@@ -5381,6 +5473,8 @@ msgid ""
 "trait objects. We'll only implement the drawing of it (as text) for "
 "simplicity."
 msgstr ""
+"让我们利用关于 trait 和 trait 对象的新知识，设计一个经典的 GUI 库。为简单起"
+"见，我们仅以文本形式实现绘制。"
 
 #: src/methods-and-traits/exercise.md:6
 msgid "We will have a number of widgets in our library:"
@@ -5396,6 +5490,8 @@ msgid ""
 "to allow the program to do something when the button is clicked but we won't "
 "include that since we're only drawing the GUI."
 msgstr ""
+"`Button`：上面有一个 `Label`。实际上，它还需要一个回调函数，以便程序在用户点"
+"击按钮时执行某些操作，但由于我们仅绘制 GUI，所以不会添加该函数。"
 
 #: src/methods-and-traits/exercise.md:12
 msgid "`Label`: has a `label`."
@@ -5416,49 +5512,49 @@ msgstr ""
 #: src/methods-and-traits/exercise.md:24 src/methods-and-traits/solution.md:5
 #: src/modules/solution.md:36
 msgid "/// Natural width of `self`.\n"
-msgstr ""
+msgstr "/// Natural width of `self`.\n"
 
 #: src/methods-and-traits/exercise.md:27 src/methods-and-traits/solution.md:8
 #: src/modules/solution.md:39
 msgid "/// Draw the widget into a buffer.\n"
-msgstr ""
+msgstr "/// Draw the widget into a buffer.\n"
 
 #: src/methods-and-traits/exercise.md:30 src/methods-and-traits/solution.md:11
 #: src/modules/solution.md:42
 msgid "/// Draw the widget on standard output.\n"
-msgstr ""
+msgstr "/// Draw the widget on standard output.\n"
 
 #: src/methods-and-traits/exercise.md:34 src/methods-and-traits/solution.md:15
 #: src/modules/solution.md:46
 msgid "\"{buffer}\""
-msgstr ""
+msgstr "\"{buffer}\""
 
 #: src/methods-and-traits/exercise.md:79
 msgid "// TODO: Implement `Widget` for `Label`.\n"
-msgstr ""
+msgstr "// TODO: Implement `Widget` for `Label`.\n"
 
 #: src/methods-and-traits/exercise.md:81
 msgid "// TODO: Implement `Widget` for `Button`.\n"
-msgstr ""
+msgstr "// TODO: Implement `Widget` for `Button`.\n"
 
 #: src/methods-and-traits/exercise.md:83
 msgid "// TODO: Implement `Widget` for `Window`.\n"
-msgstr ""
+msgstr "// TODO: Implement `Widget` for `Window`.\n"
 
 #: src/methods-and-traits/exercise.md:87 src/methods-and-traits/solution.md:117
 #: src/modules/solution.md:183
 msgid "\"Rust GUI Demo 1.23\""
-msgstr ""
+msgstr "\"Rust GUI Demo 1.23\""
 
 #: src/methods-and-traits/exercise.md:88 src/methods-and-traits/solution.md:118
 #: src/modules/solution.md:185
 msgid "\"This is a small text GUI demo.\""
-msgstr ""
+msgstr "\"This is a small text GUI demo.\""
 
 #: src/methods-and-traits/exercise.md:89 src/methods-and-traits/solution.md:119
 #: src/modules/solution.md:186
 msgid "\"Click me!\""
-msgstr ""
+msgstr "\"Click me!\""
 
 #: src/methods-and-traits/exercise.md:94
 msgid "The output of the above program can be something simple like this:"
@@ -5477,15 +5573,15 @@ msgstr ""
 
 #: src/methods-and-traits/exercise.md:114
 msgid "\"left aligned:  |{:/<width$}|\""
-msgstr ""
+msgstr "\"left aligned:  |{:/<width$}|\""
 
 #: src/methods-and-traits/exercise.md:115
 msgid "\"centered:      |{:/^width$}|\""
-msgstr ""
+msgstr "\"centered:      |{:/^width$}|\""
 
 #: src/methods-and-traits/exercise.md:116
 msgid "\"right aligned: |{:/>width$}|\""
-msgstr ""
+msgstr "\"right aligned: |{:/>width$}|\""
 
 #: src/methods-and-traits/exercise.md:120
 msgid ""
@@ -5494,7 +5590,7 @@ msgstr "使用这些对齐技巧，您可以生成如下的输出内容："
 
 #: src/methods-and-traits/solution.md:63
 msgid "// Add 4 paddings for borders\n"
-msgstr ""
+msgstr "// Add 4 paddings for borders\n"
 
 #: src/methods-and-traits/solution.md:75 src/modules/solution.md:162
 msgid ""
@@ -5502,11 +5598,14 @@ msgid ""
 "        // draw_into to return Result<(), std::fmt::Error>. Then use\n"
 "        // the ?-operator here instead of .unwrap().\n"
 msgstr ""
+"// TODO: after learning about error handling, you can change\n"
+"        // draw_into to return Result<(), std::fmt::Error>. Then use\n"
+"        // the ?-operator here instead of .unwrap().\n"
 
 #: src/methods-and-traits/solution.md:78 src/methods-and-traits/solution.md:84
 #: src/modules/solution.md:165 src/modules/solution.md:171
 msgid "\"+-{:-<inner_width$}-+\""
-msgstr ""
+msgstr "\"+-{:-<inner_width$}-+\""
 
 #: src/methods-and-traits/solution.md:78 src/methods-and-traits/solution.md:80
 #: src/methods-and-traits/solution.md:84 src/methods-and-traits/solution.md:98
@@ -5515,32 +5614,32 @@ msgstr ""
 #: src/modules/solution.md:167 src/modules/solution.md:171
 #: src/testing/unit-tests.md:27 src/testing/solution.md:89
 msgid "\"\""
-msgstr ""
+msgstr "\"\""
 
 #: src/methods-and-traits/solution.md:79 src/modules/solution.md:166
 msgid "\"| {:^inner_width$} |\""
-msgstr ""
+msgstr "\"| {:^inner_width$} |\""
 
 #: src/methods-and-traits/solution.md:80 src/modules/solution.md:167
 msgid "\"+={:=<inner_width$}=+\""
-msgstr ""
+msgstr "\"+={:=<inner_width$}=+\""
 
 #: src/methods-and-traits/solution.md:82 src/modules/solution.md:169
 msgid "\"| {:inner_width$} |\""
-msgstr ""
+msgstr "\"| {:inner_width$} |\""
 
 #: src/methods-and-traits/solution.md:90 src/modules/solution.md:100
 msgid "// add a bit of padding\n"
-msgstr ""
+msgstr "// add a bit of padding\n"
 
 #: src/methods-and-traits/solution.md:98 src/methods-and-traits/solution.md:102
 #: src/modules/solution.md:110 src/modules/solution.md:114
 msgid "\"+{:-<width$}+\""
-msgstr ""
+msgstr "\"+{:-<width$}+\""
 
 #: src/methods-and-traits/solution.md:100 src/modules/solution.md:112
 msgid "\"|{:^width$}|\""
-msgstr ""
+msgstr "\"|{:^width$}|\""
 
 #: src/generics/generic-functions.md:3
 #, fuzzy
@@ -5552,29 +5651,29 @@ msgstr ""
 
 #: src/generics/generic-functions.md:7
 msgid "/// Pick `even` or `odd` depending on the value of `n`.\n"
-msgstr ""
+msgstr "/// Pick `even` or `odd` depending on the value of `n`.\n"
 
 #: src/generics/generic-functions.md:17
 msgid "\"picked a number: {:?}\""
-msgstr ""
+msgstr "\"picked a number: {:?}\""
 
 #: src/generics/generic-functions.md:18
 msgid "\"picked a tuple: {:?}\""
-msgstr ""
+msgstr "\"picked a tuple: {:?}\""
 
 #: src/generics/generic-functions.md:18
 msgid "\"dog\""
-msgstr ""
+msgstr "\"dog\""
 
 #: src/generics/generic-functions.md:18
 msgid "\"cat\""
-msgstr ""
+msgstr "\"cat\""
 
 #: src/generics/generic-functions.md:24
 msgid ""
 "Rust infers a type for T based on the types of the arguments and return "
 "value."
-msgstr ""
+msgstr "Rust 会根据参数类型和返回值推理出 T 的类型。"
 
 #: src/generics/generic-functions.md:26
 msgid ""
@@ -5584,6 +5683,10 @@ msgid ""
 "`n == 0`. Even if only the `pick` instantiation with integers is used, Rust "
 "still considers it invalid. C++ would let you do this."
 msgstr ""
+"这与 C++ 模板类似，但 Rust 会立即编译部分通用函数，因此该函数必须对所有符合约"
+"束条件的类型都有效。例如，请尝试修改 `pick` 函数，如果 `n == 0`，则返回 "
+"`even + odd`。即使仅使用带有整数的“pick”实例化，Rust 仍会将其视为无效。C++ 可"
+"让您做到这一点。"
 
 #: src/generics/generic-functions.md:32
 #, fuzzy
@@ -5601,15 +5704,15 @@ msgstr "您可以使用泛型对具体字段类型进行抽象化处理："
 
 #: src/generics/generic-data.md:17
 msgid "// fn set_x(&mut self, x: T)\n"
-msgstr ""
+msgstr "// fn set_x(&mut self, x: T)\n"
 
 #: src/generics/generic-data.md:23
 msgid "\"{integer:?} and {float:?}\""
-msgstr ""
+msgstr "\"{integer:?} and {float:?}\""
 
 #: src/generics/generic-data.md:24
 msgid "\"coords: {:?}\""
-msgstr ""
+msgstr "\"coords: {:?}\""
 
 #: src/generics/generic-data.md:30
 msgid ""
@@ -5647,6 +5750,8 @@ msgid ""
 "code to allow points that have elements of different types, by using two "
 "type variables, e.g., `T` and `U`."
 msgstr ""
+"请尝试声明一个新变量 `let p = Point { x: 5, y: 10.0 };`。通过使用两种类型变量"
+"（例如 `T` 和 `U`），更新代码以允许具有不同类型元素的点。"
 
 #: src/generics/trait-bounds.md:3
 msgid ""
@@ -5661,19 +5766,19 @@ msgstr "您可以使用 `T: Trait` 或 `impl Trait` 执行此操作："
 
 #: src/generics/trait-bounds.md:12
 msgid "// struct NotClonable;\n"
-msgstr ""
+msgstr "// struct NotClonable;\n"
 
 #: src/generics/trait-bounds.md:18
 msgid "\"{pair:?}\""
-msgstr ""
+msgstr "\"{pair:?}\""
 
 #: src/generics/trait-bounds.md:24
 msgid "Try making a `NonClonable` and passing it to `duplicate`."
-msgstr ""
+msgstr "请尝试创建一个 `NonClonable` 对象，并将其传递给 `duplicate` 函数。"
 
 #: src/generics/trait-bounds.md:26
 msgid "When multiple traits are necessary, use `+` to join them."
-msgstr ""
+msgstr "当需要多个 trait 时，请使用 `+` 将它们连接起来。"
 
 #: src/generics/trait-bounds.md:28
 msgid "Show a `where` clause, students will encounter it when reading code."
@@ -5699,6 +5804,8 @@ msgid ""
 "Note that Rust does not (yet) support specialization. For example, given the "
 "original `duplicate`, it is invalid to add a specialized `duplicate(a: u32)`."
 msgstr ""
+"请注意，Rust 尚不支持专精领域认证。例如，根据原始 `duplicate` 函数，添加专精"
+"领域认证的 `Duplicate(a: u32)` 是无效的。"
 
 #: src/generics/impl-trait.md:3
 msgid ""
@@ -5711,18 +5818,20 @@ msgid ""
 "// Syntactic sugar for:\n"
 "//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
 msgstr ""
+"// Syntactic sugar for:\n"
+"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
 
 #: src/generics/impl-trait.md:19
 msgid "\"{many}\""
-msgstr ""
+msgstr "\"{many}\""
 
 #: src/generics/impl-trait.md:21
 msgid "\"{many_more}\""
-msgstr ""
+msgstr "\"{many_more}\""
 
 #: src/generics/impl-trait.md:23
 msgid "\"debuggable: {debuggable:?}\""
-msgstr ""
+msgstr "\"debuggable: {debuggable:?}\""
 
 #: src/generics/impl-trait.md:29
 #, fuzzy
@@ -5765,35 +5874,41 @@ msgid ""
 "What is the type of `debuggable`? Try `let debuggable: () = ..` to see what "
 "the error message shows."
 msgstr ""
+"`debuggable` 是什么类型？尝试输入 `let debuggable: () = ..`，查看会显示什么错"
+"误消息。"
 
 #: src/generics/exercise.md:3
 msgid ""
 "In this short exercise, you will implement a generic `min` function that "
 "determines the minimum of two values, using a `LessThan` trait."
 msgstr ""
+"在这个简短的练习中，您将使用 `LessThan` trait，实现一个通用 `min` 函数，用于"
+"确定两个值中的最小值。"
 
 #: src/generics/exercise.md:8 src/generics/solution.md:5
 msgid "/// Return true if self is less than other.\n"
-msgstr ""
+msgstr "/// Return true if self is less than other.\n"
 
 #: src/generics/exercise.md:29
 msgid "// TODO: implement the `min` function used in `main`.\n"
-msgstr ""
+msgstr "// TODO: implement the `min` function used in `main`.\n"
 
 #: src/generics/exercise.md:33 src/generics/solution.md:36
 msgid "\"Shapiro\""
-msgstr ""
+msgstr "\"Shapiro\""
 
 #: src/generics/exercise.md:34 src/generics/exercise.md:35
 #: src/generics/solution.md:37 src/generics/solution.md:38
 msgid "\"Baumann\""
-msgstr ""
+msgstr "\"Baumann\""
 
 #: src/std-types.md:7
 msgid ""
 "For each of the slides in this section, spend some time reviewing the "
 "documentation pages, highlighting some of the more common methods."
 msgstr ""
+"对于本部分的每张幻灯片，请花些时间仔细阅读文档页面，重点了解一些较为常用的方"
+"法。"
 
 #: src/std-types/std.md:3
 #, fuzzy
@@ -5833,8 +5948,9 @@ msgid ""
 msgstr "嵌入式 Rust 应用通常只使用 `core`，偶尔会使用 `alloc`。"
 
 #: src/std-types/docs.md:3
+#, fuzzy
 msgid "Rust comes with extensive documentation. For example:"
-msgstr ""
+msgstr "Rust 附带有大量关于该语言和标准库的文档。"
 
 #: src/std-types/docs.md:5
 #, fuzzy
@@ -5850,6 +5966,7 @@ msgid ""
 "Primitive types like [`u8`](https://doc.rust-lang.org/stable/std/primitive."
 "u8.html)."
 msgstr ""
+"['u8'](https://doc.rust-lang.org/stable/std/primitive.u8.html) 等基元类型。"
 
 #: src/std-types/docs.md:9
 #, fuzzy
@@ -5863,7 +5980,7 @@ msgstr ""
 
 #: src/std-types/docs.md:13
 msgid "In fact, you can document your own code:"
-msgstr ""
+msgstr "事实上，您可以为自己的代码编写文档："
 
 #: src/std-types/docs.md:16
 msgid ""
@@ -5872,6 +5989,10 @@ msgid ""
 "///\n"
 "/// If the second argument is zero, the result is false.\n"
 msgstr ""
+"/// Determine whether the first argument is divisible by the second "
+"argument.\n"
+"///\n"
+"/// If the second argument is zero, the result is false.\n"
 
 #: src/std-types/docs.md:27
 #, fuzzy
@@ -5891,12 +6012,16 @@ msgid ""
 "To document an item from inside the item (such as inside a module), use `//!"
 "` or `/*! .. */`, called \"inner doc comments\":"
 msgstr ""
+"如需从项内（例如在模块内）为项编写文档，请使用 `//!` 或 `/*! .. */`，这称"
+"为“内部文档注释”："
 
 #: src/std-types/docs.md:36
 msgid ""
 "//! This module contains functionality relating to divisibility of "
 "integers.\n"
 msgstr ""
+"//! This module contains functionality relating to divisibility of "
+"integers.\n"
 
 #: src/std-types/docs.md:41
 #, fuzzy
@@ -5918,26 +6043,29 @@ msgid ""
 "type `T` or nothing. For example, [`String::find`](https://doc.rust-lang.org/"
 "stable/std/string/struct.String.html#method.find) returns an `Option<usize>`."
 msgstr ""
+"我们已经了解了 `Option<T>` 的一些用法。它可以存储“T”类型的值，或者不存储任何"
+"值。例如，['String::find'](https://doc.rust-lang.org/stable/std/string/"
+"struct.String.html#method.find) 会返回 `Option<usize>`。"
 
 #: src/std-types/option.md:10
 msgid "\"Löwe 老虎 Léopard Gepardi\""
-msgstr ""
+msgstr "\"Löwe 老虎 Léopard Gepardi\""
 
 #: src/std-types/option.md:11
 msgid "'é'"
-msgstr ""
+msgstr "'é'"
 
 #: src/std-types/option.md:12 src/std-types/option.md:15
 msgid "\"find returned {position:?}\""
-msgstr ""
+msgstr "\"find returned {position:?}\""
 
 #: src/std-types/option.md:14
 msgid "'Z'"
-msgstr ""
+msgstr "'Z'"
 
 #: src/std-types/option.md:16
 msgid "\"Character not found\""
-msgstr ""
+msgstr "\"Character not found\""
 
 #: src/std-types/option.md:22
 #, fuzzy
@@ -5949,28 +6077,32 @@ msgid ""
 "`unwrap` will return the value in an `Option`, or panic. `expect` is similar "
 "but takes an error message."
 msgstr ""
+"`unwrap` 会返回 `Option` 或 panic 中的值。`expect` 方法与此类似，但其使用错误"
+"消息。"
 
 #: src/std-types/option.md:25
 msgid ""
 "You can panic on None, but you can't \"accidentally\" forget to check for "
 "None."
-msgstr ""
+msgstr "出现 None 时您或许会恐慌，但不能 “无意中”忘记检查是否为 None 的情况。"
 
 #: src/std-types/option.md:27
 msgid ""
 "It's common to `unwrap`/`expect` all over the place when hacking something "
 "together, but production code typically handles `None` in a nicer fashion."
 msgstr ""
+"在草拟阶段的编程中，频繁使用 `unwrap`/`expect` 进行处理十分常见，但在正式版代"
+"码时，通常以更为妥当的方式处理 `None` 的情况。"
 
 #: src/std-types/option.md:29
 msgid ""
 "The niche optimization means that `Option<T>` often has the same size in "
 "memory as `T`."
-msgstr ""
+msgstr "小众优化意味着 `Option<T>` 在内存中的大小通常与 `T` 相同。"
 
 #: src/std-types/result.md:1
 msgid "Result"
-msgstr ""
+msgstr "Result"
 
 #: src/std-types/result.md:3
 msgid ""
@@ -5979,22 +6111,25 @@ msgid ""
 "in the expression exercise, but generic: `Result<T, E>` where `T` is used in "
 "the `Ok` variant and `E` appears in the `Err` variant."
 msgstr ""
+"`Result` 与 `Option` 相似，但表示操作成功或失败，且每个操作的类型不同。这类似"
+"于表达式练习中定义的 `Res`，但是一个泛型：`Result<T, E>`，其中 `T` 用于 `Ok` "
+"变体，`E` 出现在 `Err` 变体中。"
 
 #: src/std-types/result.md:13
 msgid "\"diary.txt\""
-msgstr ""
+msgstr "\"diary.txt\""
 
 #: src/std-types/result.md:18
 msgid "\"Dear diary: {contents} ({bytes} bytes)\""
-msgstr ""
+msgstr "\"Dear diary: {contents} ({bytes} bytes)\""
 
 #: src/std-types/result.md:20
 msgid "\"Could not read file content\""
-msgstr ""
+msgstr "\"Could not read file content\""
 
 #: src/std-types/result.md:24
 msgid "\"The diary could not be opened: {err}\""
-msgstr ""
+msgstr "\"The diary could not be opened: {err}\""
 
 #: src/std-types/result.md:32
 msgid ""
@@ -6039,28 +6174,29 @@ msgstr ""
 #: src/memory-management/review.md:23 src/memory-management/review.md:57
 #: src/testing/unit-tests.md:32 src/testing/unit-tests.md:37
 #: src/concurrency/scoped-threads.md:9 src/concurrency/scoped-threads.md:26
+#, fuzzy
 msgid "\"Hello\""
-msgstr ""
+msgstr "\"Hello\""
 
 #: src/std-types/string.md:9
 msgid "\"s1: len = {}, capacity = {}\""
-msgstr ""
+msgstr "\"s1: len = {}, capacity = {}\""
 
 #: src/std-types/string.md:13
 msgid "'!'"
-msgstr ""
+msgstr "'!'"
 
 #: src/std-types/string.md:14
 msgid "\"s2: len = {}, capacity = {}\""
-msgstr ""
+msgstr "\"s2: len = {}, capacity = {}\""
 
 #: src/std-types/string.md:16
 msgid "\"🇨🇭\""
-msgstr ""
+msgstr "\"🇨🇭\""
 
 #: src/std-types/string.md:17
 msgid "\"s3: len = {}, number of chars = {}\""
-msgstr ""
+msgstr "\"s3: len = {}, number of chars = {}\""
 
 #: src/std-types/string.md:21
 msgid ""
@@ -6117,7 +6253,7 @@ msgstr ""
 msgid ""
 "We haven't discussed the `Deref` trait yet, so at this point this mostly "
 "explains the structure of the sidebar in the documentation."
-msgstr ""
+msgstr "我们尚未讨论过 `Deref` trait，所以本部分目前主要介绍文档中边栏的结构。"
 
 #: src/std-types/string.md:42
 msgid ""
@@ -6168,27 +6304,27 @@ msgstr ""
 
 #: src/std-types/vec.md:9
 msgid "\"v1: len = {}, capacity = {}\""
-msgstr ""
+msgstr "\"v1: len = {}, capacity = {}\""
 
 #: src/std-types/vec.md:14
 msgid "\"v2: len = {}, capacity = {}\""
-msgstr ""
+msgstr "\"v2: len = {}, capacity = {}\""
 
 #: src/std-types/vec.md:16
 msgid "// Canonical macro to initialize a vector with elements.\n"
-msgstr ""
+msgstr "// Canonical macro to initialize a vector with elements.\n"
 
 #: src/std-types/vec.md:19
 msgid "// Retain only the even elements.\n"
-msgstr ""
+msgstr "// Retain only the even elements.\n"
 
 #: src/std-types/vec.md:21 src/std-types/vec.md:25
 msgid "\"{v3:?}\""
-msgstr ""
+msgstr "\"{v3:?}\""
 
 #: src/std-types/vec.md:23
 msgid "// Remove consecutive duplicates.\n"
-msgstr ""
+msgstr "// Remove consecutive duplicates.\n"
 
 #: src/std-types/vec.md:29
 msgid ""
@@ -6239,10 +6375,13 @@ msgstr ""
 "panic。此外，使用“get”将返回“Option”。“pop”函数会移除最后一个元素。"
 
 #: src/std-types/vec.md:48
+#, fuzzy
 msgid ""
 "Slices are covered on day 3. For now, students only need to know that a "
 "value of type `Vec` gives access to all of the documented slice methods, too."
 msgstr ""
+"第 3 天会介绍 slice。目前，学生只需知道使用 `Vec` 类型的值也可访问所有已载明"
+"的只读 slice 方法。"
 
 #: src/std-types/hashmap.md:3
 msgid "Standard hash map with protection against HashDoS attacks:"
@@ -6250,44 +6389,44 @@ msgstr "标准的哈希映射，内含针对 HashDoS 攻击的保护措施："
 
 #: src/std-types/hashmap.md:10
 msgid "\"Adventures of Huckleberry Finn\""
-msgstr ""
+msgstr "\"Adventures of Huckleberry Finn\""
 
 #: src/std-types/hashmap.md:11
 msgid "\"Grimms' Fairy Tales\""
-msgstr ""
+msgstr "\"Grimms' Fairy Tales\""
 
 #: src/std-types/hashmap.md:12 src/std-types/hashmap.md:21
 #: src/std-types/hashmap.md:29
 msgid "\"Pride and Prejudice\""
-msgstr ""
+msgstr "\"Pride and Prejudice\""
 
 #: src/std-types/hashmap.md:14
 msgid "\"Les Misérables\""
-msgstr ""
+msgstr "\"Les Misérables\""
 
 #: src/std-types/hashmap.md:16
 msgid "\"We know about {} books, but not Les Misérables.\""
-msgstr ""
+msgstr "\"We know about {} books, but not Les Misérables.\""
 
 #: src/std-types/hashmap.md:21 src/std-types/hashmap.md:29
 msgid "\"Alice's Adventure in Wonderland\""
-msgstr ""
+msgstr "\"Alice's Adventure in Wonderland\""
 
 #: src/std-types/hashmap.md:23
 msgid "\"{book}: {count} pages\""
-msgstr ""
+msgstr "\"{book}: {count} pages\""
 
 #: src/std-types/hashmap.md:24
 msgid "\"{book} is unknown.\""
-msgstr ""
+msgstr "\"{book} is unknown.\""
 
 #: src/std-types/hashmap.md:28
 msgid "// Use the .entry() method to insert a value if nothing is found.\n"
-msgstr ""
+msgstr "// Use the .entry() method to insert a value if nothing is found.\n"
 
 #: src/std-types/hashmap.md:34
 msgid "\"{page_counts:#?}\""
-msgstr ""
+msgstr "\"{page_counts:#?}\""
 
 #: src/std-types/hashmap.md:40
 msgid ""
@@ -6305,11 +6444,11 @@ msgstr ""
 
 #: src/std-types/hashmap.md:47 src/std-types/hashmap.md:59
 msgid "\"Harry Potter and the Sorcerer's Stone\""
-msgstr ""
+msgstr "\"Harry Potter and the Sorcerer's Stone\""
 
 #: src/std-types/hashmap.md:50 src/std-types/hashmap.md:60
 msgid "\"The Hunger Games\""
-msgstr ""
+msgstr "\"The Hunger Games\""
 
 #: src/std-types/hashmap.md:53
 msgid "Unlike `vec!`, there is unfortunately no standard `hashmap!` macro."
@@ -6368,6 +6507,9 @@ msgid ""
 "stable/std/collections/struct.HashMap.html) to keep track of which values "
 "have been seen and how many times each one has appeared."
 msgstr ""
+"在本练习中，您将学习一个非常简单的数据结构，并将其变成泛型的。该结构使用 "
+"[`std::collections::HashMap`](https://doc.rust-lang.org/stable/std/"
+"collections/struct.HashMap.html) 来跟踪已经出现过的值以及每个值出现的次数。"
 
 #: src/std-types/exercise.md:9
 msgid ""
@@ -6375,6 +6517,8 @@ msgid ""
 "values. Make the struct and its methods generic over the type of value being "
 "tracked, that way `Counter` can track any type of value."
 msgstr ""
+"`Counter` 的初始版本经过硬编码，仅适用于 `u32` 值。使结构体及其方法可用于所跟"
+"踪的值类型，以便 `Counter` 能够跟踪任何类型的值。"
 
 #: src/std-types/exercise.md:13
 msgid ""
@@ -6382,101 +6526,115 @@ msgid ""
 "stable/std/collections/struct.HashMap.html#method.entry) method to halve the "
 "number of hash lookups required to implement the `count` method."
 msgstr ""
+"如果提前完成操作，请尝试使用 [`entry`](https://doc.rust-lang.org/stable/std/"
+"collections/struct.HashMap.html#method.entry) 方法将哈希查找次数减半，从而实"
+"现 `count` 方法。"
 
 #: src/std-types/exercise.md:20 src/std-types/solution.md:6
 msgid ""
 "/// Counter counts the number of times each value of type T has been seen.\n"
 msgstr ""
+"/// Counter counts the number of times each value of type T has been seen.\n"
 
 #: src/std-types/exercise.md:27 src/std-types/solution.md:13
 msgid "/// Create a new Counter.\n"
-msgstr ""
+msgstr "/// Create a new Counter.\n"
 
 #: src/std-types/exercise.md:34 src/std-types/solution.md:18
 msgid "/// Count an occurrence of the given value.\n"
-msgstr ""
+msgstr "/// Count an occurrence of the given value.\n"
 
 #: src/std-types/exercise.md:43 src/std-types/solution.md:23
 msgid "/// Return the number of times the given value has been seen.\n"
-msgstr ""
+msgstr "/// Return the number of times the given value has been seen.\n"
 
 #: src/std-types/exercise.md:59 src/std-types/solution.md:39
 msgid "\"saw {} values equal to {}\""
-msgstr ""
+msgstr "\"saw {} values equal to {}\""
 
 #: src/std-types/exercise.md:63 src/std-types/exercise.md:65
 #: src/std-types/exercise.md:66 src/std-types/solution.md:43
 #: src/std-types/solution.md:45 src/std-types/solution.md:46
 msgid "\"apple\""
-msgstr ""
+msgstr "\"apple\""
 
 #: src/std-types/exercise.md:64 src/std-types/solution.md:44
 msgid "\"orange\""
-msgstr ""
+msgstr "\"orange\""
 
 #: src/std-types/exercise.md:66 src/std-types/solution.md:46
 msgid "\"got {} apples\""
-msgstr ""
+msgstr "\"got {} apples\""
 
 #: src/std-traits.md:7
 msgid ""
 "As with the standard-library types, spend time reviewing the documentation "
 "for each trait."
-msgstr ""
+msgstr "与标准库类型一样，请花些时间仔细阅读每个 trait 的文档。"
 
 #: src/std-traits.md:10
 msgid "This section is long. Take a break midway through."
-msgstr ""
+msgstr "此部分内容较长。中途可休息一下。"
 
 #: src/std-traits/comparisons.md:3
 msgid ""
 "These traits support comparisons between values. All traits can be derived "
 "for types containing fields that implement these traits."
 msgstr ""
+"这些 trait 支持在值之间进行比较。对于包含实现这些 trait 的字段，可以派生所有"
+"这些 trait。"
 
 #: src/std-traits/comparisons.md:6
+#, fuzzy
 msgid "`PartialEq` and `Eq`"
-msgstr ""
+msgstr "`PartialEq` 和 `Eq`"
 
 #: src/std-traits/comparisons.md:8
 msgid ""
 "`PartialEq` is a partial equivalence relation, with required method `eq` and "
 "provided method `ne`. The `==` and `!=` operators will call these methods."
 msgstr ""
+"`PartialEq` 指部分等价关系，其中包含必需的方法 `eq` 和提供的方法 `ne`。`==` "
+"和 `!=` 运算符会调用这些方法。"
 
 #: src/std-traits/comparisons.md:23
+#, fuzzy
 msgid ""
 "`Eq` is a full equivalence relation (reflexive, symmetric, and transitive) "
 "and implies `PartialEq`. Functions that require full equivalence will use "
 "`Eq` as a trait bound."
 msgstr ""
+"`Eq` 指完全等价关系（具有自反性、对称性和传递性），并且隐含了 `PartialEq`。需"
+"要完全等价的函数将使用 `Eq` 作为特征边界。"
 
 #: src/std-traits/comparisons.md:27
 #, fuzzy
 msgid "`PartialOrd` and `Ord`"
-msgstr "`Read` 和 `Write`"
+msgstr "`PartialOrd` 和 `Ord`"
 
 #: src/std-traits/comparisons.md:29
 msgid ""
 "`PartialOrd` defines a partial ordering, with a `partial_cmp` method. It is "
 "used to implement the `<`, `<=`, `>=`, and `>` operators."
 msgstr ""
+"`PartialOrd` 定义了使用 `partial_cmp` 方法的部分排序。它用于实现 `<`、`<=`、"
+"`>=` 和 `>` 运算符。"
 
 #: src/std-traits/comparisons.md:49
 msgid "`Ord` is a total ordering, with `cmp` returning `Ordering`."
-msgstr ""
+msgstr "`Ord` 是总排序，其中 `cmp` 返回 `Ordering`。"
 
 #: src/std-traits/comparisons.md:53
 msgid ""
 "`PartialEq` can be implemented between different types, but `Eq` cannot, "
 "because it is reflexive:"
-msgstr ""
+msgstr "`PartialEq` 可以在不同类型之间实现，但 `Eq` 不能，因为它具有自反性："
 
 #: src/std-traits/comparisons.md:68
 msgid ""
 "In practice, it's common to derive these traits, but uncommon to implement "
 "them."
-msgstr ""
+msgstr "在实践中，派生这些 trait 很常见，但很少会实现它们。"
 
 #: src/std-traits/operators.md:3
 msgid ""
@@ -6488,7 +6646,7 @@ msgstr ""
 
 #: src/std-traits/operators.md:23
 msgid "\"{:?} + {:?} = {:?}\""
-msgstr ""
+msgstr "\"{:?} + {:?} = {:?}\""
 
 #: src/std-traits/operators.md:29 src/memory-management/drop.md:47
 msgid "Discussion points:"
@@ -6545,7 +6703,7 @@ msgstr ""
 
 #: src/std-traits/from-and-into.md:11 src/std-traits/from-and-into.md:23
 msgid "\"{s}, {addr}, {one}, {bigger}\""
-msgstr ""
+msgstr "\"{s}, {addr}, {one}, {bigger}\""
 
 #: src/std-traits/from-and-into.md:15
 msgid ""
@@ -6578,25 +6736,31 @@ msgid ""
 "Rust has no _implicit_ type conversions, but does support explicit casts "
 "with `as`. These generally follow C semantics where those are defined."
 msgstr ""
+"Rust 不支持 _implicit_ 类型转换，但支持使用 `as` 进行显式转换。这些转换通常遵"
+"循定义它们的 C 语义。"
 
 #: src/std-traits/casting.md:9
 msgid "\"as u16: {}\""
-msgstr ""
+msgstr "\"as u16: {}\""
 
 #: src/std-traits/casting.md:10
 msgid "\"as i16: {}\""
-msgstr ""
+msgstr "\"as i16: {}\""
 
 #: src/std-traits/casting.md:11
 msgid "\"as u8: {}\""
-msgstr ""
+msgstr "\"as u8: {}\""
 
 #: src/std-traits/casting.md:15
+#, fuzzy
 msgid ""
 "The results of `as` are _always_ defined in Rust and consistent across "
 "platforms. This might not match your intuition for changing sign or casting "
 "to a smaller type -- check the docs, and comment for clarity."
 msgstr ""
+"使用 `as` 的结果在 Rust 中 _始终_ 定义明确，并且在不同平台上保持一致。这可能"
+"不符合您对于更改符号或转换为更小类型的直观理解。为清晰起见，请查看文档和注"
+"释。"
 
 #: src/std-traits/casting.md:19
 msgid ""
@@ -6618,18 +6782,21 @@ msgstr ""
 
 #: src/std-traits/casting.md:32
 msgid "Consider taking a break after this slide."
-msgstr ""
+msgstr "请在这张幻灯片之后休息一下。"
 
 #: src/std-traits/casting.md:34
+#, fuzzy
 msgid ""
 "`as` is similar to a C++ static cast. Use of `as` in cases where data might "
 "be lost is generally discouraged, or at least deserves an explanatory "
 "comment."
 msgstr ""
+"`as` 类似于 C++ 静态类型转换。通常不建议在可能丢失数据的情况下使用 `as`，或者"
+"至少应该添加说明性注释。"
 
 #: src/std-traits/casting.md:37
 msgid "This is common in casting integers to `usize` for use as an index."
-msgstr ""
+msgstr "在将整数类型转换为 `usize` 以用作索引时，这很常见。"
 
 #: src/std-traits/read-and-write.md:3
 msgid ""
@@ -6643,15 +6810,15 @@ msgstr ""
 
 #: src/std-traits/read-and-write.md:14
 msgid "b\"foo\\nbar\\nbaz\\n\""
-msgstr ""
+msgstr "b\"foo\\nbar\\nbaz\\n\""
 
 #: src/std-traits/read-and-write.md:15
 msgid "\"lines in slice: {}\""
-msgstr ""
+msgstr "\"lines in slice: {}\""
 
 #: src/std-traits/read-and-write.md:18
 msgid "\"lines in file: {}\""
-msgstr ""
+msgstr "\"lines in file: {}\""
 
 #: src/std-traits/read-and-write.md:23
 msgid ""
@@ -6663,15 +6830,16 @@ msgstr ""
 
 #: src/std-traits/read-and-write.md:30
 msgid "\"\\n\""
-msgstr ""
+msgstr "\"\\n\""
 
 #: src/std-traits/read-and-write.md:36 src/slices-and-lifetimes/str.md:12
+#, fuzzy
 msgid "\"World\""
-msgstr ""
+msgstr "\"World\""
 
 #: src/std-traits/read-and-write.md:37
 msgid "\"Logged: {:?}\""
-msgstr ""
+msgstr "\"Logged: {:?}\""
 
 #: src/std-traits/default.md:1
 msgid "The `Default` Trait"
@@ -6687,24 +6855,24 @@ msgstr ""
 
 #: src/std-traits/default.md:18
 msgid "\"John Smith\""
-msgstr ""
+msgstr "\"John Smith\""
 
 #: src/std-traits/default.md:24
 msgid "\"{default_struct:#?}\""
-msgstr ""
+msgstr "\"{default_struct:#?}\""
 
 #: src/std-traits/default.md:27
 msgid "\"Y is set!\""
-msgstr ""
+msgstr "\"Y is set!\""
 
 #: src/std-traits/default.md:28
 msgid "\"{almost_default_struct:#?}\""
-msgstr ""
+msgstr "\"{almost_default_struct:#?}\""
 
 #: src/std-traits/default.md:31 src/slices-and-lifetimes/exercise.md:211
 #: src/slices-and-lifetimes/solution.md:214
 msgid "\"{:#?}\""
-msgstr ""
+msgstr "\"{:#?}\""
 
 #: src/std-traits/default.md:37
 msgid ""
@@ -6771,15 +6939,15 @@ msgstr "调用 Unsafe 函数"
 
 #: src/std-traits/closures.md:16 src/std-traits/closures.md:17
 msgid "\"add_3: {}\""
-msgstr ""
+msgstr "\"add_3: {}\""
 
 #: src/std-traits/closures.md:24 src/std-traits/closures.md:25
 msgid "\"accumulate: {}\""
-msgstr ""
+msgstr "\"accumulate: {}\""
 
 #: src/std-traits/closures.md:28
 msgid "\"multiply_sum: {}\""
-msgstr ""
+msgstr "\"multiply_sum: {}\""
 
 #: src/std-traits/closures.md:34
 msgid ""
@@ -6847,11 +7015,11 @@ msgstr ""
 
 #: src/std-traits/closures.md:66
 msgid "\"Hi\""
-msgstr ""
+msgstr "\"Hi\""
 
 #: src/std-traits/closures.md:67
 msgid "\"there\""
-msgstr ""
+msgstr "\"there\""
 
 #: src/std-traits/exercise.md:3
 msgid ""
@@ -6860,29 +7028,34 @@ msgid ""
 "implement the missing bits. Only rotate ASCII alphabetic characters, to "
 "ensure the result is still valid UTF-8."
 msgstr ""
+"在此示例中，您将实现经典的 [“ROT13”加密](https://en.wikipedia.org/wiki/"
+"ROT13)。将此代码复制到 Playground，并实现缺失的位。请仅旋转 ASCII 字母字符，"
+"以确保结果仍为有效的 UTF-8 编码字符。"
 
 #: src/std-traits/exercise.md:15
 msgid "// Implement the `Read` trait for `RotDecoder`.\n"
-msgstr ""
+msgstr "// Implement the `Read` trait for `RotDecoder`.\n"
 
 #: src/std-traits/exercise.md:20 src/std-traits/exercise.md:33
 #: src/std-traits/solution.md:26 src/std-traits/solution.md:39
 msgid "\"Gb trg gb gur bgure fvqr!\""
-msgstr ""
+msgstr "\"Gb trg gb gur bgure fvqr!\""
 
 #: src/std-traits/exercise.md:36 src/std-traits/solution.md:42
 msgid "\"To get to the other side!\""
-msgstr ""
+msgstr "\"To get to the other side!\""
 
 #: src/std-traits/exercise.md:55
 msgid ""
 "What happens if you chain two `RotDecoder` instances together, each rotating "
 "by 13 characters?"
 msgstr ""
+"如果将两个 `RotDecoder` 实例链接在一起，每个实例旋转 13 个字符，会发生什么情"
+"况？"
 
 #: src/std-traits/solution.md:16
 msgid "'A'"
-msgstr ""
+msgstr "'A'"
 
 #: src/welcome-day-3.md:1
 msgid "Welcome to Day 3"