diff --git a/README.md b/README.md
index 45482ff4..7e8ad63a 100644
--- a/README.md
+++ b/README.md
@@ -31,18 +31,20 @@
 
 - **规避陷阱和对抗编译器**，只有真的上手写过一长段时间 Rust 项目，才知道该如何规避常见的陷阱以及解决一些难搞的编译器错误，而本书将帮助你大大缩短这个过程，提前规避这些问题
 
-- **Cook Book**，涵盖多个应用场景的实战代码片段，程序员上网查询文件操作、正则解析、数据库操作是常事，没有人能记住所有代码，而 Cook Book 可解君忧，Ctrl + C/V 走天下
+- **[Cookbook](https://cook.rs)**，涵盖多个应用场景的实战代码片段，程序员上网查询文件操作、正则解析、数据库操作是常事，没有人能记住所有代码，而 Cook Book 可解君忧，Ctrl + C/V 走天下
 
-- **配套练习题**，像学习一门大学课程一样学习 Rust 是一种什么感觉？*Rust语言圣经 + [Rust语言实战](https://github.com/sunface/rust-by-practice)* 双剑合璧，给你最极致的学习体验
+- **[配套练习题](https://github.com/sunface/rust-by-practice)**，像学习一门大学课程一样学习 Rust 是一种什么感觉？*Rust语言圣经 + Rust语言实战* 双剑合璧，给你最极致的学习体验
 
 总之在写作过程中我们始终铭记初心：为中国用户打造一门**全面的、深入的、持续更新的** Rust 教程。 新手用来入门，老手用来提高，高手用来提升生产力。
 
-## 配套学习资源 
+## Rustt 翻译计划
+
+想要获取更多关于 Rust 的高质量技术文章、学习资料和新闻资讯嘛？请订阅 [Rustt 翻译计划](https://rustt.org)。
+
+## Rust语言周刊
+
+每周一发布，精选过去一周的技术文章、业界新闻、开源项目和 Rust 语言动态。与 Rustt 翻译计划不同，周刊不区分中英文，只是把最新产生的内容分门别类的呈现给广大读者。
 
-- [Rust语言实战](https://github.com/sunface/rust-by-practice)，它是本书的配套练习册，提供了大量有挑战性的示例、练习和实践项目，帮助大家解决 Rust 语言从学习到实战的问题 — 毕竟这之间还隔着好几个 Go 语言的难度 :D
-- [Rust语言周刊](https://github.com/sunface/rust-weekly)，每周一发布，精选过去一周的技术文章、业界新闻、开源项目和 Rust 语言动态
-- [Rust酷库推荐](https://github.com/sunface/fancy-rust)，优秀项目很多，如何在茫茫码海中与它们相遇？相比 Awesome Rust，它能带给你全新的体验和选择
-- [Rustt 翻译组](https://rustt.org)，目前最专业的 Rust 翻译组织，这里有 Rust 技术文章、学习教程和新闻资讯的高质量中文翻译
 
 ## 🏅 贡献者
 
diff --git a/book.toml b/book.toml
index 5e439c80..00c73b29 100644
--- a/book.toml
+++ b/book.toml
@@ -5,7 +5,7 @@ title = "Rust语言圣经(Rust Course)"
 src = "src"
 
 [output.html]
-additional-css = ["theme/style2.css"]
+additional-css = ["theme/style3.css"]
 additional-js = ["assets/custom.js", "assets/bigPicture.js"]
 git-repository-url = "https://github.com/sunface/rust-course"
 edit-url-template = "https://github.com/sunface/rust-course/edit/main/{path}"
@@ -13,11 +13,11 @@ edit-url-template = "https://github.com/sunface/rust-course/edit/main/{path}"
 [output.html.playground]
 editable = true
 copy-js = true
-line-numbers = true
+# line-numbers = true
 
 [output.html.fold]
 enable = true
-level = 2
+level = 1
 
 [rust]
 edition = "2021"   #在线运行用2021版本的
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index f145a29f..5cc4abae 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -2,9 +2,12 @@
 
 [Rust语言圣经](about-book.md)
 [进入 Rust 编程世界](into-rust.md)
-[AWS 为何这么喜欢 Rust?](usecases/aws-rust.md)
 [快速查询入口](index-list.md)
 
+---
+[Cook Rust: Awesome + Cookbook](cookbook.md)
+[Rust 语言周刊](rust-weekly.md)
+[Rustt 翻译计划](rustt.md)
 
 # 快速开始
 ---
@@ -162,9 +165,11 @@
     - [构建脚本 build.rs](cargo/reference/build-script/intro.md)
       - [构建脚本示例](cargo/reference/build-script/examples.md)  
 
-
-# 高级专题
+# 应用实战
 ---
+- [企业落地实践](usecases/intro.md)
+  - [AWS 为何这么喜欢 Rust?](usecases/aws-rust.md)
+
 - [Rust 最佳实践](practice/intro.md)
   - [对抗编译检查](practice/fight-with-compiler/intro.md)
     - [生命周期](practice/fight-with-compiler/lifetime/intro.md)
@@ -231,6 +236,9 @@
       - [栈上的链表](too-many-lists/advanced-lists/stack-allocated.md)
 
 
+# 高级专题
+---
+
 - [Rust 性能优化 todo](profiling/intro.md)
   - [深入内存 todo](profiling/memory/intro.md)
     - [指针和引用 todo](profiling/memory/pointer-ref.md)
@@ -263,16 +271,9 @@
   - [HashMap todo](std/hashmap.md)
   - [Iterator 常用方法 todo](std/iterator.md)
 
-- [CookBook doing](cookbook/intro.md)
-  - [实用算法](cookbook/algos/intro.md)
-    - [生成随机值](cookbook/algos/randomness.md)
-    - [Vec 排序](cookbook/algos/sorting.md)
-  - [命令行]()
-    - [参数解析](cookbook/cmd/parsing.md)
-    - [终端输出格式化](cookbook/cmd/ansi.md)
-  - [压缩](cookbook/compression/intro.md)
-    - [使用.tar包](cookbook/compression/tar.md)
-  - [配置文件解析 todo](cookbook/config.md)
+
+
+  <!-- - [配置文件解析 todo](cookbook/config.md)
   - [编解码 todo](cookbook/encoding/intro.md)
     - [JSON](cookbook/encoding/json.md)
     - [CSV](cookbook/encoding/csv.md)
@@ -291,7 +292,7 @@
   - [时间日期](cookbook/date.md)
   - [开发调试 todo](cookbook/dev/intro.md)
     - [日志](cookbook/dev/logs.md)
-    - [性能分析](cookbook/dev/profile.md)
+    - [性能分析](cookbook/dev/profile.md) -->
 
 <!--
 - [Rust区块链入门]()
diff --git a/src/basic/flow-control.md b/src/basic/flow-control.md
index e5f24560..d17544bc 100644
--- a/src/basic/flow-control.md
+++ b/src/basic/flow-control.md
@@ -6,7 +6,7 @@
 
 ## 使用 if 来做分支控制
 
-> if else 无处不在 - 鲁迅
+> if else 无处不在 -- 鲁迅
 
 但凡你能找到一门编程语言没有 `if else`，那么一定更要反馈给鲁迅，反正不是我说的:) 总之，只要你拥有其它语言的编程经验，就一定会有以下认知：`if else` **表达式**根据条件执行不同的代码分支：
 
@@ -56,7 +56,7 @@ error[E0308]: if and else have incompatible types
              found type `&str`
 ```
 
-#### 使用 else if 来处理多重条件
+## 使用 else if 来处理多重条件
 
 可以将 `else if` 与 `if`、`else` 组合在一起实现更复杂的条件分支判断：
 
@@ -82,20 +82,20 @@ fn main() {
 
 如果代码中有大量的 `else if ` 会让代码变得极其丑陋，不过不用担心，下一章的 `match` 专门用以解决多分支模式匹配的问题。
 
-## 循环控制
+# 循环控制
 
 循环无处不在，上到数钱，下到数年，你能想象的很多场景都存在循环，因此它也是流程控制中最重要的组成部分之一。
 
 在 Rust 语言中有三种循环方式：`for`、`while` 和 `loop`，其中 `for` 循环是 Rust 循环王冠上的明珠。
 
-#### for 循环
+## for 循环
 
 `for` 循环是 Rust 的大杀器：
 
 ```rust
 fn main() {
     for i in 1..=5 {
-        println!("{}",i);
+        println!("{}", i);
     }
 }
 ```
@@ -140,10 +140,10 @@ for item in &mut collection {
 
 ```rust
 fn main() {
-    let a = [4,3,2,1];
+    let a = [4, 3, 2, 1];
     // `.iter()` 方法把 `a` 数组变成一个迭代器
-    for (i,v) in a.iter().enumerate() {
-        println!("第{}个元素是{}",i+1,v);
+    for (i, v) in a.iter().enumerate() {
+        println!("第{}个元素是{}", i + 1, v);
     }
 }
 ```
@@ -183,7 +183,7 @@ for item in collection {
 
 由于 `for` 循环无需任何条件限制，也不需要通过索引来访问，因此是最安全也是最常用的，通过与下面的 `while` 的对比，我们能看到为什么 `for` 会更加安全。
 
-#### `continue`
+## `continue`
 
 使用 `continue` 可以跳过当前当次的循环，开始下次的循环：
 
@@ -192,7 +192,7 @@ for item in collection {
      if i == 2 {
          continue;
      }
-     println!("{}",i);
+     println!("{}", i);
  }
 ```
 
@@ -203,7 +203,7 @@ for item in collection {
 3
 ```
 
-#### `break`
+## `break`
 
 使用 `break` 可以直接跳出当前整个循环：
 
@@ -212,7 +212,7 @@ for item in collection {
      if i == 2 {
          break;
      }
-     println!("{}",i);
+     println!("{}", i);
  }
 ```
 
@@ -222,7 +222,7 @@ for item in collection {
 1
 ```
 
-#### while 循环
+## while 循环
 
 如果你需要一个条件来循环，当该条件为 `true` 时，继续循环，条件为 `false`，跳出循环，那么 `while` 就非常适用：
 
@@ -262,7 +262,7 @@ fn main() {
         if n > 5 {
             break
         }
-        println!("{}",n);
+        println!("{}", n);
         n+=1;
     }
 
@@ -317,7 +317,7 @@ fn main() {
 
 可以看出，`for` 并不会使用索引去访问数组，因此更安全也更简洁，同时避免 `运行时的边界检查`，性能更高。
 
-#### loop 循环
+## loop 循环
 
 对于循环而言，`loop` 循环毋庸置疑，是适用面最高的，它可以适用于所有循环场景（虽然能用，但是在很多场景下， `for` 和 `while` 才是最优选择），因为 `loop` 就是一个简单的无限循环，你可以在内部实现逻辑通过 `break` 关键字来控制循环何时结束。
 
@@ -368,8 +368,6 @@ fn main() {
 - **break 可以单独使用，也可以带一个返回值**，有些类似 `return`
 - **loop 是一个表达式**，因此可以返回一个值
 
-
 ## 课后练习
 
 > [Rust By Practice](https://zh.practice.rs/flow-control.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。
-
diff --git a/src/cookbook.md b/src/cookbook.md
new file mode 100644
index 00000000..7fc87b10
--- /dev/null
+++ b/src/cookbook.md
@@ -0,0 +1,44 @@
+<h1 align="center">Cook Rust</h1>
+
+<div align="center">
+    <img height="200px" src="https://github.com/sunface/rust-cookbook/blob/main/assets/banner1.png?raw=true">
+</div>
+   
+<div align="center">
+
+    
+在线阅读: [https://cook.rs](https://cook.rs)
+</div>
+
+学习一门语言、做一个项目就像烹饪一顿美食一样，你需要往项目中添加许多调味料，而 Cook Rust 就是教大家如何烹饪一个优秀的 Rust 项目。
+
+| 烹饪美食 | Cook Rust |
+| --- | --- |
+| 找到合适的厨具、调料、食材 | 为项目挑选 Awesome 依赖库 |
+| 按照食谱做好一道道菜，最终呈现一桌大餐 | 在 Cookbook 中查询实用的代码片段，直接复制到项目中，最终快速搭建好一个项目 | 
+
+可以看出 `Cook Rust` = `Awesome Rust` + `Rust Cookbook`，**在这里你可以找到各种优秀的依赖库和代码片段**，无论是学习还是快速搭建项目，本书都可以助你一臂之力！
+
+关于 Awesome，相信大家已经非常熟悉。但目前最火的 awesome-rust 项目有一个非常大的问题：里面的项目鱼龙混杂，因为它的目的是列出所有项目，但对于用户而言，更想看到的是可以在生产中使用的、稳定更新的优秀项目。
+
+对于开发者而言，Cookbook 非常实用的，几乎每一门编程语言都是如此。原因无他：聪明的开发者大部分时间不是在复制粘贴就是在复制粘贴的路上。而 CookBook 恰恰为各种实用场景提供了可供直接复制粘贴的代码，例如网络协议、数据库和文件操作、随机数生成、命令行解析等。既可以用于学习 Rust ，还能大幅提升你的编码效率。
+
+> Cookbook 的部分内容翻译自 [Rust CookBook](https://rust-lang-nursery.github.io/rust-cookbook/intro.html)，但由于这本英文书更新不太活跃，导致了内容存在较多的遗漏或过期，因此我们并没有完全照搬翻译这本书的内容，而是在此基础上增加了大量新的实用库和代码片段，希望大家喜欢
+
+
+## 这本书的读者
+本书适合所有程度的 Rust 开发者使用:
+
+- 新手用来了解 Rust 的常用库和常用代码片段
+- 老手在写代码时，可以直接用来复制粘贴，大幅提升工作效率
+
+毕竟咱不是在面试造飞机，谁脑袋中能记住文件操作的各种细节，对不？
+
+## 怎么使用
+
+Cookbook 中的代码都是完整的，换而言之，这些代码片段包含了 `fn main` 函数，可以直接运行，如果你是拷贝到自己的代码中，请注意拷贝相应的代码部分，而不是全盘复制。
+
+同时，这些代码( 大部分 )支持在线编辑和运行，大家无需复制到 IDE 中即可进行把玩研究。
+
+
+
diff --git a/src/cookbook/algos/intro.md b/src/cookbook/algos/intro.md
deleted file mode 100644
index ace373bf..00000000
--- a/src/cookbook/algos/intro.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# 实用算法
-本章将收集一些在实战中经常使用的算法 API。
-
-> Note: 这里没有具体的算法实现，都是关于如何应用的
\ No newline at end of file
diff --git a/src/cookbook/algos/randomness.md b/src/cookbook/algos/randomness.md
deleted file mode 100644
index 04241a7e..00000000
--- a/src/cookbook/algos/randomness.md
+++ /dev/null
@@ -1,155 +0,0 @@
-# 生成随机值
-
-### 生成随机数
-
-使用 [rand::thread_rng](https://docs.rs/rand/*/rand/fn.thread_rng.html) 可以获取一个随机数生成器 [rand::Rng](https://docs.rs/rand/0.8.5/rand/trait.Rng.html) ，该生成器需要在每个线程都初始化一个。
-
-整数的随机分布范围等于类型的取值范围，但是浮点数只分布在 `[0, 1)` 区间内。
-
-```rust,editable
-use rand::Rng;
-
-fn main() {
-    let mut rng = rand::thread_rng();
-
-    let n1: u8 = rng.gen();
-    let n2: u16 = rng.gen();
-    println!("Random u8: {}", n1);
-    println!("Random u16: {}", n2);
-    println!("Random u32: {}", rng.gen::<u32>());
-    println!("Random i32: {}", rng.gen::<i32>());
-    println!("Random float: {}", rng.gen::<f64>());
-}
-```
-
-### 指定范围生成随机数
-
-使用 [Rng::gen_range](https://rust-lang-nursery.github.io/rust-cookbook/algorithms/randomness.html) 生成 [0, 10) 区间内的随机数( 右开区间，不包括 `10` )。
-```rust,editable
-use rand::Rng;
-
-fn main() {
-    let mut rng = rand::thread_rng();
-    println!("Integer: {}", rng.gen_range(0..10));
-    println!("Float: {}", rng.gen_range(0.0..10.0));
-}
-```
-
-[Uniform](https://docs.rs/rand/*/rand/distributions/uniform/struct.Uniform.html) 可以用于生成<ruby>均匀分布<rt>uniform distribution</rt></ruby>的随机数。当需要在同一个范围内重复生成随机数时，该方法虽然和之前的方法效果一样，但会更快一些。
-
-```rust,editable
-use rand::distributions::{Distribution, Uniform};
-
-fn main() {
-    let mut rng = rand::thread_rng();
-    let die = Uniform::from(1..7);
-
-    loop {
-        let throw = die.sample(&mut rng);
-        println!("Roll the die: {}", throw);
-        if throw == 6 {
-            break;
-        }
-    }
-}
-```
-
-### 使用指定分布来生成随机数
-
-默认情况下，`rand` 包使用均匀分布来生成随机数，而 [rand_distr](https://docs.rs/rand_distr/*/rand_distr/index.html) 包提供了其它类型的分布方式。
-
-首先，你需要获取想要使用的分布的实例，然后在 [rand::Rng](https://docs.rs/rand/*/rand/trait.Rng.html) 的帮助下使用 [Distribution::sample](https://docs.rs/rand/*/rand/distributions/trait.Distribution.html#tymethod.sample) 对该实例进行取样。
-
-如果想要查询可用的分布列表，可以访问[这里](https://docs.rs/rand_distr/*/rand_distr/index.html)，下面的示例中我们将使用 [Normal](https://docs.rs/rand_distr/0.4.3/rand_distr/struct.Normal.html) 分布:
-```rust,editable
-use rand_distr::{Distribution, Normal, NormalError};
-use rand::thread_rng;
-
-fn main() -> Result<(), NormalError> {
-    let mut rng = thread_rng();
-    let normal = Normal::new(2.0, 3.0)?;
-    let v = normal.sample(&mut rng);
-    println!("{} is from a N(2, 9) distribution", v);
-    Ok(())
-}
-```
-
-### 在自定义类型中生成随机值
-
-
-使用 [Distribution](https://docs.rs/rand/*/rand/distributions/trait.Distribution.html) 特征包裹我们的自定义类型，并为 [Standard](https://docs.rs/rand/*/rand/distributions/struct.Standard.html) 实现该特征，可以为自定义类型的指定字段生成随机数。
-
-
-```rust,editable
-use rand::Rng;
-use rand::distributions::{Distribution, Standard};
-
-#[derive(Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-impl Distribution<Point> for Standard {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point {
-        let (rand_x, rand_y) = rng.gen();
-        Point {
-            x: rand_x,
-            y: rand_y,
-        }
-    }
-}
-
-fn main() {
-    let mut rng = rand::thread_rng();
-
-    // 生成一个随机的 Point
-    let rand_point: Point = rng.gen();
-    println!("Random Point: {:?}", rand_point);
-
-    // 通过类型暗示( hint )生成一个随机的元组
-    let rand_tuple = rng.gen::<(i32, bool, f64)>();
-    println!("Random tuple: {:?}", rand_tuple);
-}
-```
-
-### 生成随机的字符串(A-Z, a-z, 0-9)
-通过 [Alphanumeric](https://docs.rs/rand/0.8.5/rand/distributions/struct.Alphanumeric.html) 采样来生成随机的 ASCII 字符串，包含从 `A-Z, a-z, 0-9` 的字符。
-
-```rust,editble
-use rand::{thread_rng, Rng};
-use rand::distributions::Alphanumeric;
-
-fn main() {
-    let rand_string: String = thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(30)
-        .map(char::from)
-        .collect();
-
-    println!("{}", rand_string);
-}
-```
-
-### 生成随机的字符串( 用户指定 ASCII 字符 )
-通过 [gen_string](https://docs.rs/rand/0.8.5/rand/trait.Rng.html#method.gen_range) 生成随机的 ASCII 字符串，包含用户指定的字符。
-
-```rust,editable
-fn main() {
-    use rand::Rng;
-    const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                            abcdefghijklmnopqrstuvwxyz\
-                            0123456789)(*&^%$#@!~";
-    const PASSWORD_LEN: usize = 30;
-    let mut rng = rand::thread_rng();
-
-    let password: String = (0..PASSWORD_LEN)
-        .map(|_| {
-            let idx = rng.gen_range(0..CHARSET.len());
-            CHARSET[idx] as char
-        })
-        .collect();
-
-    println!("{:?}", password);
-}
-```
diff --git a/src/cookbook/algos/sorting.md b/src/cookbook/algos/sorting.md
deleted file mode 100644
index 76e44e8c..00000000
--- a/src/cookbook/algos/sorting.md
+++ /dev/null
@@ -1,84 +0,0 @@
-## Vector 排序
-
-
-### 对整数 Vector 排序
-
-以下示例使用 [Vec::sort](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.sort) 来排序，如果大家希望获得更高的性能，可以使用 [Vec::sort_unstable](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.sort_unstable)，但是该方法无法保留相等元素的顺序。
-
-```rust,editable
-fn main() {
-    let mut vec = vec![1, 5, 10, 2, 15];
-    
-    vec.sort();
-
-    assert_eq!(vec, vec![1, 2, 5, 10, 15]);
-}
-```
-
-### 对浮点数 Vector 排序
-
-浮点数数组可以使用 [Vec::sort_by](https://doc.rust-lang.org/std/primitive.slice.html#method.sort_by) 和 [PartialOrd::partial_cmp](https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html#tymethod.partial_cmp) 进行排序。
-
-```rust,editable
-fn main() {
-    let mut vec = vec![1.1, 1.15, 5.5, 1.123, 2.0];
-
-    vec.sort_by(|a, b| a.partial_cmp(b).unwrap());
-
-    assert_eq!(vec, vec![1.1, 1.123, 1.15, 2.0, 5.5]);
-}
-```
-
-### 对结构体 Vector 排序
-
-以下示例中的结构体 `Person` 将实现基于字段 `name` 和 `age` 的自然排序。为了让 `Person` 变为可排序的，我们需要为其派生 `Eq、PartialEq、Ord、PartialOrd` 特征，关于这几个特征的详情，请见[这里](https://course.rs/advance/confonding/eq.html)。
-
-当然，还可以使用 [vec:sort_by](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.sort_by) 方法配合一个自定义比较函数，只按照 `age` 的维度对 `Person` 数组排序。
-
-```rust,editable
-#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
-struct Person {
-    name: String,
-    age: u32
-}
-
-impl Person {
-    pub fn new(name: String, age: u32) -> Self {
-        Person {
-            name,
-            age
-        }
-    }
-}
-
-fn main() {
-    let mut people = vec![
-        Person::new("Zoe".to_string(), 25),
-        Person::new("Al".to_string(), 60),
-        Person::new("John".to_string(), 1),
-    ];
-
-    // 通过派生后的自然顺序(Name and age)排序
-    people.sort();
-
-    assert_eq!(
-        people,
-        vec![
-            Person::new("Al".to_string(), 60),
-            Person::new("John".to_string(), 1),
-            Person::new("Zoe".to_string(), 25),
-        ]);
-
-    // 只通过 age 排序
-    people.sort_by(|a, b| b.age.cmp(&a.age));
-
-    assert_eq!(
-        people,
-        vec![
-            Person::new("Al".to_string(), 60),
-            Person::new("Zoe".to_string(), 25),
-            Person::new("John".to_string(), 1),
-        ]);
-
-}
-```
\ No newline at end of file
diff --git a/src/cookbook/cmd/ansi.md b/src/cookbook/cmd/ansi.md
deleted file mode 100644
index 87c18682..00000000
--- a/src/cookbook/cmd/ansi.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# ANSI 终端
-
-[ansi_term](https://crates.io/crates/ansi_term) 包可以帮我们控制终端上的输出样式，例如使用颜色文字、控制输出格式等，当然，前提是在 ANSI 终端上。
-
-`ansi_term` 中有两个主要数据结构：[ANSIString](https://docs.rs/ansi_term/0.12.1/ansi_term/type.ANSIString.html) 和 [Style](https://docs.rs/ansi_term/0.12.1/ansi_term/struct.Style.html)。
-
-`Style` 用于控制样式：颜色、加粗、闪烁等，而前者是一个带有样式的字符串。
-
-## 颜色字体
-
-```rust,editable
-use ansi_term::Colour;
-
-fn main() {
-    println!("This is {} in color, {} in color and {} in color",
-             Colour::Red.paint("red"),
-             Colour::Blue.paint("blue"),
-             Colour::Green.paint("green"));
-}
-```
-
-## 加粗字体
-
-比颜色复杂的样式构建需要使用 `Style` 结构体:
-```rust,editable
-use ansi_term::Style;
-
-fn main() {
-    println!("{} and this is not",
-             Style::new().bold().paint("This is Bold"));
-}
-```
-
-## 加粗和颜色
-
-`Colour` 实现了很多跟 `Style` 类似的函数，因此可以实现链式调用。
-
-```rust,editable
-use ansi_term::Colour;
-use ansi_term::Style;
-
-fn main(){
-    println!("{}, {} and {}",
-             Colour::Yellow.paint("This is colored"),
-             Style::new().bold().paint("this is bold"),
-             // Colour 也可以使用 bold 方法进行加粗
-             Colour::Yellow.bold().paint("this is bold and colored"));
-}
-```
-
diff --git a/src/cookbook/cmd/parsing.md b/src/cookbook/cmd/parsing.md
deleted file mode 100644
index b0356aef..00000000
--- a/src/cookbook/cmd/parsing.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# 参数解析
-
-## Clap
-下面的程序给出了使用 `clap` 来解析命令行参数的样式结构，如果大家想了解更多，在 `clap` [文档](https://docs.rs/clap/)中还给出了另外两种初始化一个应用的方式。
-
-在下面的构建中，`value_of` 将获取通过 `with_name` 解析出的值。`short` 和 `long` 用于设置用户输入的长短命令格式，例如短命令 `-f` 和长命令 `--file`。
-
-```rust,editable
-use clap::{Arg, App};
-
-fn main() {
-    let matches = App::new("My Test Program")
-        .version("0.1.0")
-        .author("Hackerman Jones <hckrmnjones@hack.gov>")
-        .about("Teaches argument parsing")
-        .arg(Arg::with_name("file")
-                 .short("f")
-                 .long("file")
-                 .takes_value(true)
-                 .help("A cool file"))
-        .arg(Arg::with_name("num")
-                 .short("n")
-                 .long("number")
-                 .takes_value(true)
-                 .help("Five less than your favorite number"))
-        .get_matches();
-
-    let myfile = matches.value_of("file").unwrap_or("input.txt");
-    println!("The file passed is: {}", myfile);
-
-    let num_str = matches.value_of("num");
-    match num_str {
-        None => println!("No idea what your favorite number is."),
-        Some(s) => {
-            match s.parse::<i32>() {
-                Ok(n) => println!("Your favorite number must be {}.", n + 5),
-                Err(_) => println!("That's not a number! {}", s),
-            }
-        }
-    }
-}
-```
-
-`clap` 针对上面提供的构建样式，会自动帮我们生成相应的使用方式说明。例如，上面代码生成的使用说明如下：
-```shell
-My Test Program 0.1.0
-Hackerman Jones <hckrmnjones@hack.gov>
-Teaches argument parsing
-
-USAGE:
-    testing [OPTIONS]
-
-FLAGS:
-    -h, --help       Prints help information
-    -V, --version    Prints version information
-
-OPTIONS:
-    -f, --file <file>     A cool file
-    -n, --number <num>    Five less than your favorite number
-```
-
-最后，再使用一些参数来运行下我们的代码:
-```shell
-$ cargo run -- -f myfile.txt -n 251
-The file passed is: myfile.txt
-Your favorite number must be 256.
-```
-
-## Structopt
-@todo
\ No newline at end of file
diff --git a/src/cookbook/compression/intro.md b/src/cookbook/compression/intro.md
deleted file mode 100644
index aa2d4d8b..00000000
--- a/src/cookbook/compression/intro.md
+++ /dev/null
@@ -1,3 +0,0 @@
-## 压缩
-
-我们会对常用的压缩方法进行介绍，例如 `tar`, `gzip`, `lz4` 等。
\ No newline at end of file
diff --git a/src/cookbook/compression/tar.md b/src/cookbook/compression/tar.md
deleted file mode 100644
index 992d8ddc..00000000
--- a/src/cookbook/compression/tar.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# 使用tar包
-
-## 解压 tar 包
-以下代码将解压缩( [GzDecoder](https://docs.rs/flate2/*/flate2/read/struct.GzDecoder.html) )当前目录中的 `archive.tar.gz` ，并将所有文件抽取出( [Archive::unpack](https://docs.rs/tar/*/tar/struct.Archive.html#method.unpack) )来后当入到当前目录中。
-
-```rust,editable
-use std::fs::File;
-use flate2::read::GzDecoder;
-use tar::Archive;
-
-fn main() -> Result<(), std::io::Error> {
-    let path = "archive.tar.gz";
-
-    let tar_gz = File::open(path)?;
-    let tar = GzDecoder::new(tar_gz);
-    let mut archive = Archive::new(tar);
-    archive.unpack(".")?;
-
-    Ok(())
-}
-```
-
-## 将目录压缩成 tar 包
-以下代码将 `/var/log` 目录压缩成 `archive.tar.gz`:
-
-- 创建一个 [File](https://doc.rust-lang.org/std/fs/struct.File.html) 文件，并使用 [GzEncoder](https://docs.rs/flate2/*/flate2/write/struct.GzEncoder.html) 和 [tar::Builder](https://docs.rs/tar/*/tar/struct.Builder.html) 对其进行包裹
-- 通过 [Builder::append_dir_all](https://docs.rs/tar/*/tar/struct.Builder.html#method.append_dir_all) 将 `/var/log` 目录下的所有内容添加到压缩文件中，该文件在 `backup/logs` 目录下。
-- [GzEncoder](https://docs.rs/flate2/*/flate2/write/struct.GzEncoder.html) 负责在写入压缩文件 `archive.tar.gz` 之前对数据进行压缩。
-
-```rust,editable
-use std::fs::File;
-use flate2::Compression;
-use flate2::write::GzEncoder;
-
-fn main() -> Result<(), std::io::Error> {
-    let tar_gz = File::create("archive.tar.gz")?;
-    let enc = GzEncoder::new(tar_gz, Compression::default());
-    let mut tar = tar::Builder::new(enc);
-    tar.append_dir_all("backup/logs", "/var/log")?;
-    Ok(())
-}
-```
-
-## 解压的同时删除指定的文件前缀
-遍历目录中的文件 [Archive::entries](https://docs.rs/tar/*/tar/struct.Archive.html#method.entries)，若解压前的文件名包含 `bundle/logs` 前缀，需要将前缀从文件名移除( [Path::strip_prefix](https://doc.rust-lang.org/std/path/struct.Path.html#method.strip_prefix) )后，再解压。
-
-
-
-```rust,editable
-use std::fs::File;
-use std::path::PathBuf;
-use flate2::read::GzDecoder;
-use tar::Archive;
-
-fn main() -> Result<()> {
-    let file = File::open("archive.tar.gz")?;
-    let mut archive = Archive::new(GzDecoder::new(file));
-    let prefix = "bundle/logs";
-
-    println!("Extracted the following files:");
-    archive
-        .entries()? // 获取压缩档案中的文件条目列表
-        .filter_map(|e| e.ok())
-        // 对每个文件条目进行 map 处理
-        .map(|mut entry| -> Result<PathBuf> {
-            // 将文件路径名中的前缀移除，获取一个新的路径名
-            let path = entry.path()?.strip_prefix(prefix)?.to_owned();
-            // 将内容解压到新的路径名中
-            entry.unpack(&path)?;
-            Ok(path)
-        })
-        .filter_map(|e| e.ok())
-        .for_each(|x| println!("> {}", x.display()));
-
-    Ok(())
-}
-```
\ No newline at end of file
diff --git a/src/cookbook/config.md b/src/cookbook/config.md
deleted file mode 100644
index 33eb3d73..00000000
--- a/src/cookbook/config.md
+++ /dev/null
@@ -1 +0,0 @@
-# 配置文件 todo
diff --git a/src/cookbook/crypto.md b/src/cookbook/crypto.md
deleted file mode 100644
index f9455099..00000000
--- a/src/cookbook/crypto.md
+++ /dev/null
@@ -1 +0,0 @@
-# 加密解密 todo
diff --git a/src/cookbook/database.md b/src/cookbook/database.md
deleted file mode 100644
index de785679..00000000
--- a/src/cookbook/database.md
+++ /dev/null
@@ -1 +0,0 @@
-# 数据库访问 todo
diff --git a/src/cookbook/date.md b/src/cookbook/date.md
deleted file mode 100644
index a434528a..00000000
--- a/src/cookbook/date.md
+++ /dev/null
@@ -1 +0,0 @@
-# 时间日期
diff --git a/src/cookbook/dev/intro.md b/src/cookbook/dev/intro.md
deleted file mode 100644
index f0cc50f0..00000000
--- a/src/cookbook/dev/intro.md
+++ /dev/null
@@ -1 +0,0 @@
-# 开发调试
diff --git a/src/cookbook/dev/logs.md b/src/cookbook/dev/logs.md
deleted file mode 100644
index 65c2dbdd..00000000
--- a/src/cookbook/dev/logs.md
+++ /dev/null
@@ -1 +0,0 @@
-# 日志
diff --git a/src/cookbook/dev/profile.md b/src/cookbook/dev/profile.md
deleted file mode 100644
index 124678e8..00000000
--- a/src/cookbook/dev/profile.md
+++ /dev/null
@@ -1 +0,0 @@
-# 性能分析
diff --git a/src/cookbook/encoding/csv.md b/src/cookbook/encoding/csv.md
deleted file mode 100644
index 19f2031e..00000000
--- a/src/cookbook/encoding/csv.md
+++ /dev/null
@@ -1 +0,0 @@
-# CSV
diff --git a/src/cookbook/encoding/intro.md b/src/cookbook/encoding/intro.md
deleted file mode 100644
index 0e61f3d0..00000000
--- a/src/cookbook/encoding/intro.md
+++ /dev/null
@@ -1 +0,0 @@
-# 编解码
diff --git a/src/cookbook/encoding/json.md b/src/cookbook/encoding/json.md
deleted file mode 100644
index 02ed5a24..00000000
--- a/src/cookbook/encoding/json.md
+++ /dev/null
@@ -1 +0,0 @@
-# JSON
diff --git a/src/cookbook/encoding/protobuf.md b/src/cookbook/encoding/protobuf.md
deleted file mode 100644
index 4fdb7ce0..00000000
--- a/src/cookbook/encoding/protobuf.md
+++ /dev/null
@@ -1 +0,0 @@
-# protobuf
diff --git a/src/cookbook/file/dir.md b/src/cookbook/file/dir.md
deleted file mode 100644
index c996c7a0..00000000
--- a/src/cookbook/file/dir.md
+++ /dev/null
@@ -1 +0,0 @@
-# 目录操作
diff --git a/src/cookbook/file/file.md b/src/cookbook/file/file.md
deleted file mode 100644
index 9286f56a..00000000
--- a/src/cookbook/file/file.md
+++ /dev/null
@@ -1 +0,0 @@
-# 文件读写
diff --git a/src/cookbook/file/intro.md b/src/cookbook/file/intro.md
deleted file mode 100644
index 0f8e6d56..00000000
--- a/src/cookbook/file/intro.md
+++ /dev/null
@@ -1 +0,0 @@
-# 文件系统 todo
diff --git a/src/cookbook/intro.md b/src/cookbook/intro.md
deleted file mode 100644
index 12f5f0e6..00000000
--- a/src/cookbook/intro.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# 场景化用例
-
-对于开发者而言，CookBook 是非常实用的，几乎每一门编程语言都是如此。原因无他：聪明的开发者大部分时间不是在复制粘贴就是在复制粘贴的路上。而 CookBook 恰恰为各种实用场景提供了可供直接复制粘贴的代码，例如文件操作、随机数生成、命令行解析等等，
-
-> CookBook 的部分内容翻译自 [Rust CookBook](https://rust-lang-nursery.github.io/rust-cookbook/intro.html)，但是内容并不相同，因为我们对部分内容进行了整合，最重要的是增加了大量实用库和代码片段
-
-
-## 这本书的读者
-本书适合所有程度的 Rust 开发者使用:
-
-- 新手用来熟悉生态和常用库
-- 老手在写代码时，可以直接用来复制粘贴，大幅提升工作效率
-
-毕竟咱不是在面试造飞机，谁脑袋中能记住文件操作的各种细节，对不？
-
-## 怎么使用
-Cookbook 中的代码都是完整的，换而言之，这些代码片段包含了 `fn main` 函数，可以直接运行，如果你是拷贝到自己的代码中，请注意拷贝相应的代码部分，而不是全盘复制。
-
-同时，这些代码( 大部分 )支持在线编辑和运行，大家无需复制到 IDE 中即可进行把玩研究。
-
-
-
diff --git a/src/cookbook/protocol/grpc.md b/src/cookbook/protocol/grpc.md
deleted file mode 100644
index 37b724e9..00000000
--- a/src/cookbook/protocol/grpc.md
+++ /dev/null
@@ -1 +0,0 @@
-# gRPC
diff --git a/src/cookbook/protocol/http.md b/src/cookbook/protocol/http.md
deleted file mode 100644
index 03fe6a2d..00000000
--- a/src/cookbook/protocol/http.md
+++ /dev/null
@@ -1 +0,0 @@
-# HTTP
diff --git a/src/cookbook/protocol/intro.md b/src/cookbook/protocol/intro.md
deleted file mode 100644
index aaab51db..00000000
--- a/src/cookbook/protocol/intro.md
+++ /dev/null
@@ -1 +0,0 @@
-# 网络通信 todo
diff --git a/src/cookbook/protocol/tcp.md b/src/cookbook/protocol/tcp.md
deleted file mode 100644
index fd208cbf..00000000
--- a/src/cookbook/protocol/tcp.md
+++ /dev/null
@@ -1 +0,0 @@
-# TCP
diff --git a/src/cookbook/protocol/udp.md b/src/cookbook/protocol/udp.md
deleted file mode 100644
index 2827b96c..00000000
--- a/src/cookbook/protocol/udp.md
+++ /dev/null
@@ -1 +0,0 @@
-# UDP
diff --git a/src/cookbook/regexp.md b/src/cookbook/regexp.md
deleted file mode 100644
index b79ef0b1..00000000
--- a/src/cookbook/regexp.md
+++ /dev/null
@@ -1 +0,0 @@
-# 正则表达式 todo
diff --git a/src/first-try/hello-world.md b/src/first-try/hello-world.md
index a14910fd..9121320e 100644
--- a/src/first-try/hello-world.md
+++ b/src/first-try/hello-world.md
@@ -4,7 +4,7 @@
 
 ## 多国语言的"世界，你好"
 
-还记得大明湖畔等你的 [VSCode IDE](https://course.rs/first-try/editor.md) 和通过 `Cargo` 创建的 [世界，你好](https://course.rs/first-try/cargo.html) 工程吗？
+还记得大明湖畔等你的 [VSCode IDE](https://course.rs/first-try/editor.html) 和通过 `Cargo` 创建的 [世界，你好](https://course.rs/first-try/cargo.html) 工程吗？
 
 现在使用 VSCode 打开 [上一节](https://course.rs/first-try/cargo.html) 中创建的 `world_hello` 工程，然后进入 `main.rs` 文件。（此文件是当前 Rust 工程的入口文件，和其它语言几无区别。）
 
diff --git a/src/https:/github.com b/src/https:/github.com
deleted file mode 100644
index 83c831f0..00000000
--- a/src/https:/github.com
+++ /dev/null
@@ -1 +0,0 @@
-# test
diff --git a/src/index-list.md b/src/index-list.md
index fc949f76..3f481510 100644
--- a/src/index-list.md
+++ b/src/index-list.md
@@ -18,17 +18,18 @@
 
 ## Sym
 
-| 名称                    | 关键字         | 简介                                             |
-| ----------------------- | -------------- | ------------------------------------------------ |
-| [?]                     | 错误传播       | 用于简化错误传播                                 |
-| [()]                    | 单元类型       | 单元类型，无返回值                               |
-| `!` : [1 函数] [2 类型] | 永不返回       | 永不返回                                         |
-| [&]                     | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址 |
-| [\*]                    | 解引用         | 解出引用所指向的值                               |
-| [@]                     | 变量绑定       | 为一个字段绑定另外一个变量                       |
-| ['a: 'b]                | 生命周期约束   | 用来说明两个生命周期的长短                       |
-| [{:?}] {:#?}            | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征    |
-| A                       |                | AIntroduction                                    |
+| 名称                    | 关键字         | 简介                                                                                 |
+| ----------------------- | -------------- | ------------------------------------------------------------------------------------ |
+| [?]                     | 错误传播       | 用于简化错误传播                                                                     |
+| [()]                    | 单元类型       | 单元类型，无返回值                                                                   |
+| `!` : [1 函数] [2 类型] | 永不返回       | 永不返回                                                                             |
+| [&]                     | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址                                     |
+| [\*]                    | 解引用         | 解出引用所指向的值                                                                   |
+| [@]                     | 变量绑定       | 为一个字段绑定另外一个变量                                                           |
+| `_` : [2 模式匹配]      | 忽略           | 1. 忽略该值或者类型，否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
+| ['a: 'b]                | 生命周期约束   | 用来说明两个生命周期的长短                                                           |
+| [{:?}] {:#?}            | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征                                        |
+| A                       |                | AIntroduction                                                                        |
 
 [?]: https://course.rs/basic/result-error/result.html#传播界的大明星-
 [()]: https://course.rs/basic/base-type/function.html#无返回值
@@ -39,6 +40,7 @@
 [@]: https://course.rs/basic/match-pattern/all-patterns.html#绑定
 ['a: 'b]: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb
 [{:?}]: https://course.rs/basic/compound-type/struct.html?search=#使用-derivedebug-来打印结构体的信息
+[2 模式匹配]: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
 
 [back](#head)
 
@@ -57,18 +59,22 @@
 
 ## B
 
-| 名称         | 关键字    | 简介                                   |
-| ------------ | --------- | -------------------------------------- |
-| [变量遮蔽]   | shadowing | 允许声明相同的变量名，后者会遮蔽掉前者 |
-| [变量作用域] | 所有权    | 作用域是一个变量在程序中有效的范围     |
-| [表达式]     |           | 进行求值，结尾无 `;`，有返回值         |
-| [bool 布尔]  | 布尔类型  | `true` `false`，占用 1 字节            |
-| B            | KWB       | BIntroduction                          |
+| 名称         | 关键字    | 简介                                                                           |
+| ------------ | --------- | ------------------------------------------------------------------------------ |
+| [变量遮蔽]   | shadowing | 允许声明相同的变量名，后者会遮蔽掉前者                                         |
+| [变量覆盖]   | 模式匹配  | 无论是是 `match` 还是 `if let`，他们都可以在模式匹配时覆盖掉老的值，绑定新的值 |
+| [变量作用域] | 所有权    | 作用域是一个变量在程序中有效的范围                                             |
+| [表达式]     |           | 进行求值，结尾无 `;`，有返回值                                                 |
+| [bool 布尔]  | 布尔类型  | `true` `false`，占用 1 字节                                                    |
+| [break]      | 循环控制  | 直接跳出当前整个循环                                                           |
+| B            | KWB       | BIntroduction                                                                  |
 
 [变量遮蔽]: https://course.rs/basic/variable.html#变量遮蔽shadowing
+[变量覆盖]: https://course.rs/basic/match-pattern/match-if-let.html#变量覆盖
 [变量作用域]: https://course.rs/basic/ownership/ownership.html#变量作用域
 [bool 布尔]: https://course.rs/basic/base-type/char-bool.html#布尔bool
 [表达式]: https://course.rs/basic/base-type/statement-expression.html#表达式
+[break]: https://course.rs/basic/flow-control.html#break
 
 [back](#head)
 
@@ -79,6 +85,7 @@
 | [char 字符]  | 字符类型 | 使用 `''` 表示，所有的 Unicode 值                                                   |
 | [const 常量] | constant | `const MAX_POINTS: u32 = 100_000;`                                                  |
 | [Copy 拷贝]  | 浅拷贝   | 任何基本类型的组合可以 `Copy`，不需要分配内存或某种形式资源的类型是可以 `Copy` 的。 |
+| [continue]   | 循环控制 | 跳过当前当次的循环，开始下次的循环                                                  |
 | [Clone 克隆] | 深拷贝   | 需要复制堆上的数据时，可以使用 `.clone()` 方法                                      |
 | C            | KWC      | CIntroduction                                                                       |
 
@@ -86,6 +93,7 @@
 [const 常量]: https://course.rs/basic/variable.html#变量和常量之间的差异
 [copy 拷贝]: https://course.rs/basic/ownership/ownership.html#拷贝浅拷贝
 [clone 克隆]: https://course.rs/basic/ownership/ownership.html#克隆深拷贝
+[continue]: https://course.rs/basic/flow-control.html#continue
 
 [back](#head)
 
@@ -110,12 +118,14 @@
 
 ## F
 
-| 名称     | 关键字   | 简介                     |
-| -------- | -------- | ------------------------ |
-| [浮点数] | 数值类型 | `f32`<br>`f64`(默认类型) |
-| F        | KWF      | FIntroduction            |
+| 名称       | 关键字   | 简介                         |
+| ---------- | -------- | ---------------------------- |
+| [浮点数]   | 数值类型 | `f32`<br>`f64`(默认类型)     |
+| [for 循环] | 循环控制 | `for item in &collection {}` |
+| F          | KWF      | FIntroduction                |
 
 [浮点数]: https://course.rs/basic/base-type/numbers.html#浮点类型
+[for 循环]: https://course.rs/basic/flow-control.html#for-循环
 
 [back](#head)
 
@@ -140,9 +150,16 @@
 
 ## I
 
-| 名称 | 关键字 | 简介          |
-| ---- | ------ | ------------- |
-| I    | KWI    | IIntroduction |
+| 名称          | 关键字   | 简介                                                                  |
+| ------------- | -------- | --------------------------------------------------------------------- |
+| [if else]     | 流程控制 | 根据条件执行不同的代码分支                                            |
+| [else if]     | 流程控制 | 处理多重条件                                                          |
+| [if let 匹配] | 模式匹配 | 当你只要匹配一个条件，且忽略其他条件时就用 `if let`，否则都用 `match` |
+| I             | KWI      | IIntroduction                                                         |
+
+[if else]: https://course.rs/basic/flow-control.html#使用-if-来做分支控制
+[else if]: https://course.rs/basic/flow-control.html#使用-else-if-来处理多重条件
+[if let 匹配]: https://course.rs/basic/match-pattern/match-if-let.html#if-let-匹配
 
 [back](#head)
 
@@ -164,25 +181,38 @@
 
 ## L
 
-| 名称      | 关键字   | 简介                          |
-| --------- | -------- | ----------------------------- |
-| [let]     | 变量绑定 | `let x : u32 = 5;`            |
-| [let mut] | 可变变量 | `let mut x : u32 = 5; x = 9;` |
-| L         | KWL      | LIntroduction                 |
+| 名称        | 关键字   | 简介                           |
+| ----------- | -------- | ------------------------------ |
+| [let]       | 变量绑定 | `let x : u32 = 5;`             |
+| [let mut]   | 可变变量 | `let mut x : u32 = 5; x = 9;`  |
+| [loop 循环] | 循环控制 | 无限循环，注意要配合 [`break`] |
+| L           | KWL      | LIntroduction                  |
 
 [let]: https://course.rs/basic/variable.html#变量绑定
 [let mut]: https://course.rs/basic/variable.html#变量可变性
+[`break`]: https://course.rs/basic/flow-control.html#break
+[loop 循环]: https://course.rs/basic/flow-control.html#loop-循环
 
 [back](#head)
 
 ## M
 
-| 名称        | 关键字     | 简介                                                  |
-| ----------- | ---------- | ----------------------------------------------------- |
-| [move 移动] | 转移所有权 | `let s2 = s1;`<br>`s1` 所有权转移给了 `s2`，`s1` 失效 |
-| M           | KWM        | MIntroduction                                         |
-
+| 名称          | 关键字     | 简介                                                                                                                                                               |
+| ------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| [模式绑定]    | 模式匹配   | 从模式中取出绑定的值                                                                                                                                               |
+| [全模式列表]  | 模式匹配   | 列出了所有的模式匹配                                                                                                                                               |
+| [match 匹配]  | 模式匹配   | `match` 的匹配必须要穷举出所有可能，因此这里用 `_ ` 来代表未列出的所有可能性<br>`match` 的每一个分支都必须是一个表达式，且所有分支的表达式最终返回值的类型必须相同 |
+| [matches! 宏] | 模式匹配   | 将一个表达式跟模式进行匹配，然后返回匹配的结果 `true` 或 `false`                                                                                                   |
+| [match guard] | 匹配守卫   | 位于 `match` 分支模式之后的额外 `if` 条件，它能为分支模式提供更进一步的匹配条件                                                                                    |
+| [move 移动]   | 转移所有权 | `let s2 = s1;`<br>`s1` 所有权转移给了 `s2`，`s1` 失效                                                                                                              |
+| M             | KWM        | MIntroduction                                                                                                                                                      |
+
+[模式绑定]: https://course.rs/basic/match-pattern/match-if-let.html#模式绑定
+[match 匹配]: https://course.rs/basic/match-pattern/match-if-let.html#match-匹配
+[matches! 宏]: https://course.rs/basic/match-pattern/match-if-let.html#matches宏
 [move 移动]: https://course.rs/basic/ownership/ownership.html#转移所有权
+[全模式列表]: https://course.rs/basic/match-pattern/all-patterns.html
+[match guard]: https://course.rs/basic/match-pattern/all-patterns.html#匹配守卫提供的额外条件
 
 [back](#head)
 
@@ -196,12 +226,14 @@
 
 ## O
 
-| 名称     | 关键字      | 简介          |
-| -------- | ----------- | ------------- |
-| [Option] | Option 枚举 | 用于处理空值  |
-| O        | KWO         | OIntroduction |
+| 名称          | 关键字      | 简介                                                            |
+| ------------- | ----------- | --------------------------------------------------------------- |
+| [Option]      | Option 枚举 | 用于处理空值，**一个变量要么有值：`Some(T)`, 要么为空：`None`** |
+| [Option 解构] | 模式匹配    | 可以通过 `match` 来实现                                         |
+| O             | KWO         | OIntroduction                                                   |
 
 [option]: https://course.rs/basic/compound-type/enum.html#option-枚举用于处理空值
+[option 解构]: https://course.rs/basic/match-pattern/option.html#匹配-optiont
 
 [back](#head)
 
@@ -287,9 +319,12 @@
 
 ## W
 
-| 名称 | 关键字 | 简介          |
-| ---- | ------ | ------------- |
-| W    | KWW    | WIntroduction |
+| 名称         | 关键字   | 简介                                                   |
+| ------------ | -------- | ------------------------------------------------------ |
+| [while 循环] | 循环控制 | 当条件为 `true` 时，继续循环，条件为 `false`，跳出循环 |
+| W            | KWW      | WIntroduction                                          |
+
+[while 循环]: https://course.rs/basic/flow-control.html#while-循环
 
 [back](#head)
 
diff --git a/src/practice/third-party-libs.md b/src/practice/third-party-libs.md
index 9b187fae..c137fe6b 100644
--- a/src/practice/third-party-libs.md
+++ b/src/practice/third-party-libs.md
@@ -4,7 +4,7 @@
 
 本文就分门别类的精心挑选了一些非常适合日常开发使用的三方库，同时针对优缺点、社区活跃等进行了评价，同一个类别的库，按照**推荐度优先级降序排列**，希望大家能喜欢。
 
-> 本文节选自[Fancy Rust](https://fancy.rs), 一个Rust酷库推荐项目, 里面精选了各个领域的好项目，无论是学习还是工作使用，都能助你一臂之力。
+> 本文节选自[Cook Rust](https://cook.rs)
 
 ## 目录
 - 日常开发常用的Rust库: 
diff --git a/src/rust-weekly.md b/src/rust-weekly.md
new file mode 100644
index 00000000..6d617d66
--- /dev/null
+++ b/src/rust-weekly.md
@@ -0,0 +1,68 @@
+# Rust 语言周刊
+
+精选过去一周的文章、新闻、开源项目和 Rust 语言动态( 中文内容用 🇨🇳 进行标识 )，欢迎大家[订阅及查看往期回顾](https://github.com/studyrs/rust-weekly)。
+
+
+## 「Rust 语言周刊」 第 6 期 · 2022-04-02
+
+<img src="https://pica.zhimg.com/80/v2-23889bd3869ac6736256ac51ae4975d3_1440w.jpg">
+<h5 align="center">题图: Rust 嵌入式开发</h5>
+
+#### 精选文章
+
+1、 [Zh] [敢于要求更多 Rust 2024](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-03-28%5D%20Rust%202024：敢于要求更多.md) - 翻译 [YuKun Liu](https://github.com/mrxiaozhuox)
+
+未来几年的 Rust 和社区应该怎么发展，可以简单总结为：敢于要求更多。
+
+2、[Zh] [Rust 嵌入式开发](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-03-26%5D%20Rust%20嵌入式开发.md)  - 翻译 [Xiaobin.Liu](https://github.com/lxbwolf)
+
+本文展示了一些适用于嵌入式 Rust 的特性，总之, Rust 的高性能、高可靠和生产效率都非常适用于嵌入式系统。
+
+3、[dyn*: 尝试将 dyn 变成定长类型](https://smallcultfollowing.com/babysteps/blog/2022/03/29/dyn-can-we-make-dyn-sized/)
+
+三人行必能干翻诸葛亮，这不，作者和两个朋友在一次深入讨论后，突然诞生了这个奇妙的想法，最后还提交给了 Rust Team。作者还认为，一旦成功，那 `dyn Trait` 将更加好用、易用。
+
+4、[自修改代码](https://matklad.github.io/2022/03/26/self-modifying-code.html)
+
+对于 JIT 类似的动态机器码修改技术，大家应该都比较熟悉了，但是 Rust 中并没有。因此，作者想要通过一个简单的方法来替代宏去生成源代码。
+
+5、[异步解构器、异步泛型和完成式期约](https://sabrinajewson.org/blog/async-drop)
+
+本文的主要目标是为 Rust 设计一个系统以支持异步解构器( asynchronous destructors )。长文预警！
+
+6、[何时不应该使用 Rust](https://kerkour.com/why-not-rust)
+
+不出所料，文章内给出了快速原型设计的答案。短文预警！
+
+7、[Rust 交叉编译](https://kerkour.com/rust-cross-compilation)
+
+黑帽 Rust 作者又出手了，这次为我们带来关于交叉编译的优质内容。
+
+8、[小而美的 Rust Docker 镜像](https://azzamsa.com/n/rust-docker/)
+
+文章用 Rocket 框架写了一个 demo，然后将其打包成 Docker 镜像，最后的大小仅仅是 `8.38MB`，但... 算了，不剧透了，大家还是自己探索吧。
+
+9、[Book] [High Assurance Rust](https://highassurance.rs)
+
+由于我自己是开源书作者，因此对开源书有一种特别的偏爱。这本书主要关于如何开发高可靠、安全的软件服务，当然，书中还有一些计算机原理和架构设计的讲解。
+
+10、[Video] [Rust for Linux](https://www.youtube.com/watch?v=fVEeqo40IyQ)
+
+本视频将讲解目前 Linux 的 kernel 中，Rust 将扮演什么角色以及未来规划。
+
+#### 开源项目
+
+1、[生成你的 Github Profile](https://github.com/autarch/autarch)
+
+灵感来自于作者在简历中看到别人的炫酷 Github 个人首页展示，还写了[一篇文章](https://blog.urth.org/2022/03/28/yet-another-github-profile-generator/)。
+
+
+2、[fp-bindgen: 为全栈 WASM 插件生成相应的 binding](https://fiberplane.dev/blog/announcing-fp-bindgen/)
+
+全栈 WASM 插件是可以同时用在客户端和服务端的插件，而 `fp-bindgen` 让插件的创作变得更加简单，不仅如此，还提供了工具可以让它们在服务器上运行( hosting )。
+
+3、[BonsaiDB v0.4.0](https://bonsaidb.io/blog/bonsaidb-v0-4-0/)
+
+`BonsaiDB` 的目标是打造一个使用者友好的数据库，拥有大量常用的数据结构。但是之前的版本只支持异步 API，这个缺陷在新版本中得到了解决。
+
+
diff --git a/src/rustt.md b/src/rustt.md
new file mode 100644
index 00000000..a5df3788
--- /dev/null
+++ b/src/rustt.md
@@ -0,0 +1,13 @@
+# Rustt 翻译计划
+
+🥇Rustt 翻译计划，这里有国内最优质、最实时的 Rust 技术文章、学习资料和新闻资讯，欢迎大家[前往阅读和订阅](https://github.com/studyrs/Rustt)。
+
+## 最近优秀作品展
+
+| 中文名 |   翻译时间 | 作者 |
+| ------- | -------- | ----- |
+| [series][Rust 六边形架构](https://github.com/studyrs/Rustt/tree/main/Articles/%5B2022-04-03%5D%20Rust%20六边形架构) | 2022-04-04 | [trdthg](https://github.com/trdthg) |
+| [用 Rust 写 Devops 工具](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-04-02%5D%20用%20Rust%20写%20DevOps%20工具.md) | 2022-04-03 | [Xiaobin.Liu](https://github.com/lxbwolf) |
+| [Rust 大佬给初学者的学习建议](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-04-02%5D%20Rust%20大佬给初学者的学习建议.md) | 2022-04-02 | [Asura](https://github.com/asur4s) |
+| [Rust 背后并不是公司](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-04-01%5D%20Rust%20背后并不是公司.md) | 2022-04-01 | [子殊](https://github.com/allenli178) |
+| [在 Rust 中使用 epoll 实现非阻塞 IO](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-03-29%5D%20在%20Rust%20中使用%20epoll%20实现基本的非阻塞%20IO.md) | 2022-03-29 | [BK0717](https://github.com/hyuuko) | 
diff --git a/theme/style2.css b/theme/style3.css
similarity index 93%
rename from theme/style2.css
rename to theme/style3.css
index e4d5a8cd..acf81bc9 100644
--- a/theme/style2.css
+++ b/theme/style3.css
@@ -97,4 +97,12 @@ table {
 /* Fix on mobile device */
 code {
     word-break: break-word;
-}
\ No newline at end of file
+}
+
+/* 修改书侧边目录的区域分隔行样式 */
+
+.chapter .spacer {
+    background-color: #99CCFF;
+    height: 2px;
+    margin-top: 8px;
+}
diff --git a/内容变更记录.md b/内容变更记录.md
index 6c5c3b6a..bbca8238 100644
--- a/内容变更记录.md
+++ b/内容变更记录.md
@@ -1,6 +1,24 @@
 # ChangeLog
 记录一些值得注意的变更。
 
+## 2022-04-05
+
+- 新增章节：[Cookbook - 字符编码](https://cookbook.rs/encoding/strings.html)
+- 新增章节：[Cookbook - CSV处理](https://cookbook.rs/encoding/csv.html)
+
+## 2022-04-04 
+
+- 新增章节: [Cookbook - 使用 rayon 并行处理数据](https://course.rs/cookbook/cocurrency/parallel.html)
+- 新增章节： [Cookbook - 加密](https://course.rs/cookbook/cryptography/encryption.html)
+- 新增章节： [Cookbook - 哈希](https://course.rs/cookbook/cryptography/hashing.html)
+- 新增章节： [Cookbook - 位字段](https://course.rs/cookbook/datastructures/bitfield.html)
+- 新增章节: [Cookbook - 数据库](https://course.rs/cookbook/database/sqlite.html)
+- 新增章节: [Cookbook - 开发者工具](https://course.rs/cookbook/devtools/log.html)
+
+## 2022-04-03
+
+- 新增章节：[Cookbook - 线程](http://course.rs/cookbook/cocurrency/threads.html)
+
 ## 2022-04-01
 
 - 新增章节: [Cookbook - 生成随机值](https://course.rs/cookbook/algos/randomness.html)