add practice for each chapter

src/SUMMARY.md

@@ -194,7 +194,6 @@
     - [日志记录 todo](practice/logs.md)
     - [可观测性监控 todo](practice/observability.md)
     - [面试经验 doing](practice/interview.md)
-<!-- - [如何实现一个链表 todo]() -->
   
 - [Rust性能剖析 todo](profiling/intro.md)  
   - [深入内存 todo](profiling/memory/intro.md)

src/basic/base-type/char-bool.md

@@ -66,3 +66,8 @@ fn main() {
 例如常见的 `println!()` 的返回值也是单元类型 `()`。
 
 再比如，你可以用 `()` 作为 `map` 的值，表示我们不关注具体的值，只关注 `key`。 这种用法和 Go 语言的 ***struct{}*** 类似，可以作为一个值用来占位，但是完全**不占用**任何内存。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/basic-types/char-bool-unit.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/base-type/function.md

@@ -178,3 +178,7 @@ fn forever() -> ! {
   };
 }
 ```
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/basic-types/functions.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/base-type/numbers.md

@@ -291,6 +291,10 @@ use num::complex::Complex;
 数值类型的讲解已经基本结束，接下来，来看看字符和布尔类型。
 
 
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/basic-types/numbers.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。
+
 
 
  

src/basic/base-type/statement-expression.md

@@ -83,3 +83,8 @@ fn main() {
 
 该语句块是表达式的原因是：它的最后一行是表达式，返回了 `x + 1` 的值，注意 `x + 1` 不能以分号结尾，否则就会从表达式变成语句， **表达式不能包含分号**。这一点非常重要，一旦你在表达式后加上分号，它就会变成一条语句，再也**不会**返回一个值，请牢记！
 
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/basic-types/statements-expressions.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。
+

src/basic/compound-type/array.md

@@ -154,3 +154,8 @@ fn main() {
 
 
 至此，关于数据类型部分，我们已经全部学完了，对于 Rust 学习而言，我们也迈出了坚定的第一步，后面将开始更高级特性的学习。未来如果大家有疑惑需要检索知识，一样可以继续回顾过往的章节，因为本书不仅仅是一门 Rust 的教程，还是一本厚重的 Rust 工具书。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/compound-types/array.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/compound-type/enum.md

@@ -272,3 +272,8 @@ let none = plus_one(None);
 ```
 
 `plus_one` 通过 `match` 来处理不同 `Option` 的情况。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/compound-types/enum.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

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

@@ -379,3 +379,10 @@ for b in "中国人".bytes() {
 > 其实，在 C++ 中，也有这种概念: *Resource Acquisition Is Initialization (RAII)*。如果你使用过 RAII 模式的话应该对 Rust 的 `drop` 函数并不陌生
 
 这个模式对编写 Rust 代码的方式有着深远的影响，在后面章节我们会进行更深入的介绍。
+
+
+## 课后练习
+
+> Rust By Practice，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。
+> - [字符串](https://zh.practice.rs/compound-types/string.html)
+> - [切片](https://zh.practice.rs/compound-types/slice.html)

src/basic/compound-type/struct.md

@@ -390,3 +390,9 @@ $ cargo run
 ```
 
 可以看到，我们想要的 debug 信息几乎都有了：代码所在的文件名、行号、表达式以及表达式的值，简直完美！
+
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/compound-types/struct.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/compound-type/tuple.md

@@ -67,3 +67,9 @@ fn calculate_length(s: String) -> (String, usize) {
 在其他语言中，可以用结构体来声明一个三维空间中的点，例如 `Point(10, 20, 30)`，虽然使用 Rust 元组也可以做到：`(10, 20, 30)`，但是这样写有个非常重大的缺陷：
 
 **不具备任何清晰的含义**，在下一章节中，会提到一种与元组类似的结构体，`元组结构体`，可以解决这个问题。
+
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/compound-types/tuple.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/flow-control.md

@@ -334,3 +334,8 @@ fn main() {
 - **break 可以单独使用，也可以带一个返回值**，有些类似 `return`
 - **loop 是一个表达式**，因此可以返回一个值
 
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/flow-control.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/match-pattern/all-patterns.md

@@ -607,3 +607,8 @@ num @ (1 | 2)
 
 
 至此，模式匹配的内容已经全部完结，复杂但是详尽，想要一次性全部记住属实不易，因此读者可以先留一个印象，等未来需要时，再来翻阅寻找具体的模式实现方式。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/pattern-match/patterns.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

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

@@ -336,3 +336,8 @@ fn main() {
 ```
 
 需要注意的是，**`match` 中的变量覆盖其实不是那么的容易看出**，因此要小心！
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/pattern-match/match-iflet.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/method.md

@@ -262,3 +262,8 @@ m.call();
 ```
 
 除了结构体和枚举，我们还能为特征(trait)实现方法，这将在下一章进行讲解，在此之前，先来看看泛型。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/method.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/ownership/borrowing.md

@@ -301,3 +301,8 @@ fn no_dangle() -> String {
 
 - 同一时刻，你只能拥有要么一个可变引用, 要么任意多个不可变引用
 - 引用必须总是有效的
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/ownership/borrowing.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/ownership/ownership.md

@@ -318,3 +318,7 @@ fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用
 
 所有权很强大，避免了内存的不安全性，但是也带来了一个新麻烦： **总是把一个值传来传去来使用它**。 传入一个函数，很可能还要从该函数传出去，结果就是语言表达变得非常啰嗦，幸运的是，Rust 提供了新功能解决这个问题。
 
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/ownership/ownership.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。

src/basic/trait/generic.md

@@ -431,3 +431,10 @@ fn main() {
 ```
 
 我们可以使用泛型来编写不重复的代码，而 Rust 将会为每一个实例编译其特定类型的代码。这意味着在使用泛型时没有运行时开销；当代码运行，它的执行效率就跟好像手写每个具体定义的重复代码一样。这个单态化过程正是 Rust 泛型在运行时极其高效的原因。
+
+
+## 课后练习
+
+> Rust By Practice，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。
+> - [泛型](https://zh.practice.rs/generics-traits/generics.html)
+> - [const 泛型](https://zh.practice.rs/generics-traits/const-generics.html)

src/basic/variable.md

@@ -221,3 +221,8 @@ error: aborting due to previous error
 显然，Rust 对类型的要求很严格，不允许将整数类型 `usize` 赋值给字符串类型。`usize` 是一种 CPU 相关的整数类型，在[数值类型](./base-type/numbers#整数类型)中有详细介绍。
 
 万事开头难，到目前为止，都进展很顺利，那下面开始，咱们正式进入 Rust 的类型世界，看看有哪些挑战在前面等着大家。
+
+
+## 课后练习
+
+> [Rust By Practice](https://zh.practice.rs/variables.html)，支持代码在线编辑和运行，并提供详细的[习题解答](https://github.com/sunface/rust-by-practice)。