Merge pull request #4 from sunface/main

sync

src/advance/lifetime/basic.md

@@ -44,7 +44,7 @@ error[E0597]: `x` does not live long enough // `x` 活得不够久
    |                           - borrow later used here // 对 `x` 的借用在此处被使用
 ```
 
-在这里 `r` 拥有更大的作用域，或者说**活得更久**。如果 Rust 不阻止该垂悬引用的发生，那么当 `x` 被释放后，`r` 所引用的值就不再是合法的，会导致我们程序发生异常行为，且该异常行为有时候会很难被发现。
+在这里 `r` 拥有更大的作用域，或者说**活得更久**。如果 Rust 不阻止该悬垂引用的发生，那么当 `x` 被释放后，`r` 所引用的值就不再是合法的，会导致我们程序发生异常行为，且该异常行为有时候会很难被发现。
 
 ## 借用检查
 

src/advance/smart-pointer/box.md

@@ -264,7 +264,7 @@ fn gen_static_str() -> &'static str{
 
 光看上面的描述，大家可能还是云里雾里、一头雾水。
 
-那么我说一个简单的场景，**你需要一个在运行期初始化的值，但是可以全局有效，也就是和整个程序活得一样久**，那么久可以使用 `Box::leak`，例如有一个存储配置的结构体实例，它是在运行期动态插入内容，那么就可以将其转为全局有效，虽然 `Rc/Arc` 也可以实现此功能，但是 `Box::leak` 是性能最高的。
+那么我说一个简单的场景，**你需要一个在运行期初始化的值，但是可以全局有效，也就是和整个程序活得一样久**，那么就可以使用 `Box::leak`，例如有一个存储配置的结构体实例，它是在运行期动态插入内容，那么就可以将其转为全局有效，虽然 `Rc/Arc` 也可以实现此功能，但是 `Box::leak` 是性能最高的。
 
 ## 总结
 

src/basic/compound-type/string-slice.md

@@ -449,7 +449,7 @@ fn main() {
 代码运行结果：
 
 ```console
-string_remove 占 18 个字
+string_remove 占 18 个字节
 string_remove = "试remove方法"
 ```
 
@@ -579,6 +579,51 @@ fn main() {
 hello rust!
 ```
 
+## 字符串转义
+
+我们可以通过转义的方式 `\` 输出 ASCII 和 Unicode 字符。
+
+```rust
+fn main() {
+    // 通过 \ + 字符的十六进制表示，转义输出一个字符
+    let byte_escape = "I'm writing \x52\x75\x73\x74!";
+    println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape);
+
+    // \u 可以输出一个 unicode 字符
+    let unicode_codepoint = "\u{211D}";
+    let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";
+
+    println!(
+        "Unicode character {} (U+211D) is called {}",
+        unicode_codepoint, character_name
+    );
+
+    // 换行了也会保持之前的字符串格式
+    let long_string = "String literals
+                        can span multiple lines.
+                        The linebreak and indentation here ->\
+                        <- can be escaped too!";
+    println!("{}", long_string);
+}
+```
+
+当然，在某些情况下，可能你会希望保持字符串的原样，不要转义:
+```rust
+fn main() {
+    println!("{}", "hello \\x52\\x75\\x73\\x74");
+    let raw_str = r"Escapes don't work here: \x3F \u{211D}";
+    println!("{}", raw_str);
+
+    // 如果字符串包含双引号，可以在开头和结尾加 #
+    let quotes = r#"And then I said: "There is no escape!""#;
+    println!("{}", quotes);
+
+    // 如果还是有歧义，可以继续增加，没有限制
+    let longer_delimiter = r###"A string with "# in it. And even "##!"###;
+    println!("{}", longer_delimiter);
+}
+```
+
 ## 操作 UTF-8 字符串
 
 前文提到了几种使用 UTF-8 字符串的方式，下面来一一说明。

src/basic/match-pattern/match-if-let.md

@@ -145,7 +145,7 @@ fn value_in_cents(coin: Coin) -> u8 {
 
 上面代码中，在匹配 `Coin::Quarter(state)` 模式时，我们把它内部存储的值绑定到了 `state` 变量上，因此 `state` 变量就是对应的 `UsState` 枚举类型。
 
-例如有一个印了阿拉斯加州标记的 25 分硬币：`Coin::Quarter(UsState::Alaska))`, 它在匹配时，`state` 变量将被绑定 `UsState::Alaska` 的枚举值。
+例如有一个印了阿拉斯加州标记的 25 分硬币：`Coin::Quarter(UsState::Alaska)`, 它在匹配时，`state` 变量将被绑定 `UsState::Alaska` 的枚举值。
 
 再来看一个更复杂的例子：
 

src/basic/trait/trait-object.md

@@ -108,7 +108,10 @@ pub struct Screen {
 
 **特征对象**指向实现了 `Draw` 特征的类型的实例，也就是指向了 `Button` 或者 `SelectBox` 的实例，这种映射关系是存储在一张表中，可以在运行时通过特征对象找到具体调用的类型方法。
 
-可以通过 `&` 引用或者 `Box<T>` 智能指针的方式来创建特征对象:
+可以通过 `&` 引用或者 `Box<T>` 智能指针的方式来创建特征对象。
+
+> `Boxt<T>` 在后面章节会[详细讲解](https://course.rs/advance/smart-pointer/box.html)，大家现在把它当成一个引用即可，只不过它包裹的值会被强制分配在堆上
+
 
 ```rust
 trait Draw {
@@ -127,7 +130,9 @@ impl Draw for f64 {
     }
 }
 
+// 若 T 实现了 Draw 特征， 则调用该函数时传入的 Box<T> 可以被隐式转换成函数参数签名中的 Box<dyn Draw>
 fn draw1(x: Box<dyn Draw>) {
+    // 由于实现了 Deref 特征，Box 智能指针会自动解引用为它所包裹的值，然后调用该值对应的类型上定义的 `draw` 方法
     x.draw();
 }
 
@@ -140,7 +145,10 @@ fn main() {
     // do_something(&x);
     let y = 8u8;
 
+    // x 和 y 的类型 T 都实现了 `Draw` 特征，因为 Box<T> 可以在函数调用时隐式地被转换为特征对象 Box<dyn Draw> 
+    // 基于 x 的值创建一个 Box<f64> 类型的智能指针，指针指向的数据被放置在了堆上
     draw1(Box::new(x));
+    // 基于 y 的值创建一个 Box<u8> 类型的智能指针
     draw1(Box::new(y));
     draw2(&x);
     draw2(&y);

src/index-list.md

@@ -18,18 +18,18 @@
 
 ## Sym
 
-| 名称                    | 关键字         | 简介                                                                                 |
+| 名称                            | 关键字         | 简介                                                                                 |
-| ----------------------- | -------------- | ------------------------------------------------------------------------------------ |
+| ------------------------------- | -------------- | ------------------------------------------------------------------------------------ |
-| [?]                     | 错误传播       | 用于简化错误传播                                                                     |
+| [?]                             | 错误传播       | 用于简化错误传播                                                                     |
-| [()]                    | 单元类型       | 单元类型，无返回值                                                                   |
+| [()]                            | 单元类型       | 单元类型，无返回值                                                                   |
-| `!` : [1 函数] [2 类型] | 永不返回       | 永不返回                                                                             |
+| `!` : [1 函数] [2 类型]         | 永不返回       | 永不返回                                                                             |
-| [&]                     | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址                                     |
+| [&]                             | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址                                     |
-| [\*]                    | 解引用         | 解出引用所指向的值                                                                   |
+| [\*]                            | 解引用         | 解出引用所指向的值                                                                   |
-| [@]                     | 变量绑定       | 为一个字段绑定另外一个变量                                                           |
+| [@]                             | 变量绑定       | 为一个字段绑定另外一个变量                                                           |
-| `_` : [2 模式匹配]      | 忽略           | 1. 忽略该值或者类型，否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
+| `_` : [1 忽略变量] [2 模式匹配] | 忽略           | 1. 忽略该值或者类型，否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
-| ['a: 'b]                | 生命周期约束   | 用来说明两个生命周期的长短                                                           |
+| ['a: 'b]                        | 生命周期约束   | 用来说明两个生命周期的长短                                                           |
-| [{:?}] {:#?}            | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征                                        |
+| [{:?}] {:#?}                    | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征                                        |
-| A                       |                | AIntroduction                                                                        |
+| A                               |                | AIntroduction                                                                        |
 
 [?]: https://course.rs/basic/result-error/result.html#传播界的大明星-
 [()]: https://course.rs/basic/base-type/function.html#无返回值
@@ -40,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-来打印结构体的信息
+[1 忽略变量]: https://course.rs/basic/variable.html#使用下划线开头忽略未使用的变量
 [2 模式匹配]: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
 
 [back](#head)
@@ -273,6 +274,7 @@
 | [slice 切片]    | `&str`        | 允许你引用 `String` 中部分连续的元素序列，而不是引用整个 `String` <br>语法：`[开始索引..终止索引]`<br>字符串字面量是切片 |
 | [String 字符串] | `String` 类型 | Rust 中的字符串是 UTF-8 编码，也就是字符串中的字符所占的字节数是变化的(1 - 4)                                            |
 | [String 操作]   | `String` 方法 | 由于 `String` 是可变字符串，因此我们可以对它进行创建、增删操作                                                           |
+| [String 转义]   | `String` 方法 | 通过转义的方式 `\` 输出 ASCII 和 Unicode 字符                                                                            |
 | [struct 结构体] | 结构体        | 通过关键字 `struct` 定义<br>一个清晰明确的结构体 `名称`<br>几个有名字的结构体 `字段`<br>通过 `.` 访问字段                |
 | S               | KWS           | SIntroduction                                                                                                            |
 
@@ -281,6 +283,7 @@
 [slice 切片]: https://course.rs/basic/compound-type/string-slice.html#切片slice
 [string 字符串]: https://course.rs/basic/compound-type/string-slice.html#什么是字符串
 [string 操作]: https://course.rs/basic/compound-type/string-slice.html#操作字符串
+[string 转义]: https://course.rs/basic/compound-type/string-slice.html#字符串转义
 [struct 结构体]: https://course.rs/basic/compound-type/struct.html
 
 [back](#head)

src/logs/tracing-logger.md

@@ -2,8 +2,10 @@
 
 在 [tracing](https://docs.rs/crate/tracing/latest) 包出来前，Rust 的日志也就 `log` 有一战之力，但是 `log` 的功能相对来说还是鸡简单一些。在大名鼎鼎的 tokio 开发团队推出 `tracing` 后，我现在坚定的认为 `tracing` 就是未来！
 
+
 > 截至目前，rust编译器团队、GraphQL 都在使用 tracing，而且 tokio 在密谋一件大事：基于 tracing 开发一套终端交互式 debug 工具: [console](https://github.com/tokio-rs/console)！
 
+
 基于这种坚定的信仰，我们决定将公司之前使用的 `log` 包替换成 `tracing` ，但是有一个问题：后者提供的 JSON logger 总感觉不是那个味儿。这意味着，对于程序员来说，最快乐的时光又要到来了：定制自己的开发工具。
 
 好了，闲话少说，下面我们一起来看看该如何构建自己的 logger，以及深入了解 tracing 的一些原理，当然你也可以只选择来凑个热闹，总之，开始吧！

src/rust-weekly.md

@@ -3,66 +3,81 @@
 精选过去一周的文章、新闻、开源项目和 Rust 语言动态( 中文内容用 🇨🇳 进行标识 )，欢迎大家[订阅及查看往期回顾](https://github.com/studyrs/rust-weekly)。
 
 
-## 「Rust 语言周刊」 第 6 期 · 2022-04-02
+## 「Rust 语言周刊」 第 7 期 · 2022-04-08
+Rust 语言周刊精选过去一周的优秀文章、新闻、开源项目和 Rust 语言动态。
 
-<img src="https://pica.zhimg.com/80/v2-23889bd3869ac6736256ac51ae4975d3_1440w.jpg">
+本周刊由 StudyRust 社区倾情打造，其中的 [Zh] 中文资料由 Rustt 进行翻译，原始 Markdown 文档已全部开源，欢迎大家阅读和订阅。
-<h5 align="center">题图: Rust 嵌入式开发</h5>
 
-#### 精选文章
+> StudyRust 官网：https://studyrust.org , 公众号 studyrust
 
-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)
+<img src="https://pic1.zhimg.com/v2-23a24b00623e46297ea9146e648a1126_1440w.jpg?source=172ae18b">
+<h5 align="center">题图: 一本生锈的书</h5>
 
-未来几年的 Rust 和社区应该怎么发展，可以简单总结为：敢于要求更多。
+#### 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)
+1、[Zh] [Rust 1.60 发布](https://course.rs/appendix/rust-versions/1.60.html)
 
-本文展示了一些适用于嵌入式 Rust 的特性，总之, Rust 的高性能、高可靠和生产效率都非常适用于嵌入式系统。
+在新版中，我们可以查看 Cargo 构建时的详细耗时了，有助于分析和改善编译时间，还有就是条件编译和依赖引入了新的期待已久的功能。
 
-3、[dyn*: 尝试将 dyn 变成定长类型](https://smallcultfollowing.com/babysteps/blog/2022/03/29/dyn-can-we-make-dyn-sized/)
+1、[Zh] [Rust 2024 官方路线图公布](https://www.163.com/dy/article/H4CMGAF50511CUMI.html)
+这篇文章从比较宏观的角度讲解了 Rust 2024 的路线图。
 
-三人行必能干翻诸葛亮，这不，作者和两个朋友在一次深入讨论后，突然诞生了这个奇妙的想法，最后还提交给了 Rust Team。作者还认为，一旦成功，那 `dyn Trait` 将更加好用、易用。
+2、[Zh] [Rust 2024：敢于要求更多](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-03-28%5D%20Rust%202024：敢于要求更多.md)
 
-4、[自修改代码](https://matklad.github.io/2022/03/26/self-modifying-code.html)
+本文是从更细节的角度出发讲解 Rust 2024 的路线图，喜欢技术细节的同学不容错过。
 
-对于 JIT 类似的动态机器码修改技术，大家应该都比较熟悉了，但是 Rust 中并没有。因此，作者想要通过一个简单的方法来替代宏去生成源代码。
+3、[Rust 基金会激励计划](https://foundation.rust-lang.org/news/2022-03-31-cgp-is-open-announcement/)
 
-5、[异步解构器、异步泛型和完成式期约](https://sabrinajewson.org/blog/async-drop)
+基金会筹划已久的开源项目激励计划终于开始实施了，里面包含了基金会合作伙伴、开源项目等一系列举措，大家快去申请了！
 
-本文的主要目标是为 Rust 设计一个系统以支持异步解构器( asynchronous destructors )。长文预警！
+#### 开源项目
 
-6、[何时不应该使用 Rust](https://kerkour.com/why-not-rust)
+1、[一本生锈的书](https://github.com/studyrs/rusty-book)
 
-不出所料，文章内给出了快速原型设计的答案。短文预警！
+这本书主要关于如何打造一个 “有锈” 的 Rust 项目。
 
-7、[Rust 交叉编译](https://kerkour.com/rust-cross-compilation)
+2、[StarfishQL](https://www.sea-ql.org/SeaORM/blog/2022-04-04-introducing-starfish-ql/)
 
-黑帽 Rust 作者又出手了，这次为我们带来关于交叉编译的优质内容。
+一个图数据库和查询引擎，目前主要的目的是绘制和探索 crates.io 上的包依赖网络。
 
-8、[小而美的 Rust Docker 镜像](https://azzamsa.com/n/rust-docker/)
+3、[Coppers](https://github.com/ThijsRay/coppers)
 
-文章用 Rocket 框架写了一个 demo，然后将其打包成 Docker 镜像，最后的大小仅仅是 `8.38MB`，但... 算了，不剧透了，大家还是自己探索吧。
+一套测试工具，用于测量 Rust 项目的能耗情况。
 
-9、[Book] [High Assurance Rust](https://highassurance.rs)
+#### 精选文章
 
-由于我自己是开源书作者，因此对开源书有一种特别的偏爱。这本书主要关于如何开发高可靠、安全的软件服务，当然，书中还有一些计算机原理和架构设计的讲解。
+1、[虚弱之塔: 每个人都应该懂的内存模型](https://gankra.github.io/blah/tower-of-weakenings/)
 
-10、[Video] [Rust for Linux](https://www.youtube.com/watch?v=fVEeqo40IyQ)
+干货作者又出手了，这次为我们带来了内存模型的分析和改进。他甚至基于这种改进修改了 Rust 代码，并且应用在自己的部分项目上，crazy!
 
-本视频将讲解目前 Linux 的 kernel 中，Rust 将扮演什么角色以及未来规划。
+2、[Rust 的 Mutex 为何这样设计?](https://cliffle.com/blog/rust-mutexes/)
 
-#### 开源项目
+已经有不少人抱怨为何 Rust 的 Mutex 跟别的语言不一样，例如它可以持有数据。作者针对这些疑问给出了自己的分析，总之他站队 Rust 的设计。
+
+3、[Zh] [在 Rust 中使用 epoll 实现非阻塞 IO](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-03-29%5D%20在%20Rust%20中使用%20epoll%20实现基本的非阻塞%20IO.md)
+
+本文试图解释清楚 epoll 和非阻塞 IO 背后的原理
+
+4、[Zh] [用 Rust 写 Devops 工具](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-04-02%5D%20用%20Rust%20写%20DevOps%20工具.md)
+
+文章中会介绍几个 Rust 用在 DevOps 领域的案例，以及为什么使用 Rust。其中我们还会介绍一些在 AWS 上基于 Rust 的 DevOps 工具常用的库。
+
+5、[Zh] [Rust 背后不是公司](https://github.com/studyrs/Rustt/blob/main/Articles/%5B2022-04-01%5D%20Rust%20背后并不是公司.md)
+Rust 大佬带来的对 Rust 组织架构的分析。
 
-1、[生成你的 Github Profile](https://github.com/autarch/autarch)
+6、[使用 Rust 改善 Python S3 客户端的性能](https://joshua-robinson.medium.com/improving-python-s3-client-performance-with-rust-e9639359072f)
 
-灵感来自于作者在简历中看到别人的炫酷 Github 个人首页展示，还写了[一篇文章](https://blog.urth.org/2022/03/28/yet-another-github-profile-generator/)。
+Python 是数据科学的主力军语言，但是性能有的时候会成为平静下来。例如现在亚马逊 S3 存储非常火热，如果大家使用 S3 作为数据集的存储，那么 Pyhton 去读取这些数据可能就是一个很大的性能瓶颈。
 
+7、[Qiskit 使用 Rust 来获取更好的性能](https://medium.com/qiskit/new-weve-started-using-rust-in-qiskit-for-better-performance-a3676433ca8c)
 
-2、[fp-bindgen: 为全栈 WASM 插件生成相应的 binding](https://fiberplane.dev/blog/announcing-fp-bindgen/)
+Qiskit 是一家从事量子计算的公司，最近他们 在 Python 之外还引入了 Rust 语言，事实证明，这个举措带来了显著的性能提升。
 
-全栈 WASM 插件是可以同时用在客户端和服务端的插件，而 `fp-bindgen` 让插件的创作变得更加简单，不仅如此，还提供了工具可以让它们在服务器上运行( hosting )。
+8、[ScyllaDB 将数据库驱动使用异步 Rust 重新实现](https://thenewstack.io/why-were-porting-our-database-drivers-to-async-rust/)
 
-3、[BonsaiDB v0.4.0](https://bonsaidb.io/blog/bonsaidb-v0-4-0/)
+ScyllaDB 是这几年很火的开源分布式 KV 数据库，兼容 Cassandra 的 CQL 协议，性能非常非常高。这不，为了性能和安全性，他们又出手了，这次是使用 Rust 将客户端的驱动进行了重写( 使用 tokio )。
 
-`BonsaiDB` 的目标是打造一个使用者友好的数据库，拥有大量常用的数据结构。但是之前的版本只支持异步 API，这个缺陷在新版本中得到了解决。
+9、[在 2022 年使用 axum 和 yew 打造一个全栈 Rust web 服务](https://robert.kra.hn/posts/2022-04-03_rust-web-wasm/)
 
+在过去两年，WebAssembly 在 Rust 这里发展的非常快，而且构建和打包也变得更加简单。因此，是时候使用 Rust 写一套前后端服务了。
 

内容变更记录.md

@@ -1,6 +1,15 @@
 # ChangeLog
 记录一些值得注意的变更。
 
+## 2022-04-12
+
+- [优化字符串章节，增加字符串转义](https://course.rs/basic/compound-type/string-slice.html#字符串转义)
+
+## 2022-04-11
+
+- 增加 [OnceCell](https://course.rs/advance/global-variable.html#标准库中的-oncecell), 感谢 [Rustln](https://github.com/rustln) 提交的 PR
+
+
 ## 2022-04-08
 
 - 新增章节: [日志 - tracing 包](https://course.rs/logs/tracing.html)