borrowing_exerci = "0.3.53"

Author: cnruby

docs/zh-first-volumn/src/hello-borrowing/borrowing-for-loop.md

@@ -24,7 +24,6 @@
 {{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_arr.rs:feature-err }}
 ```
 
-
 　　在编译该程序以后，编译器给出有用的信息提示，如下所示：
 
 ```bash

docs/zh-first-volumn/src/hello-borrowing/images/hello_borrowing-18-mut_ref_deref.png

@@ -1,3 +1,146 @@
 # 应用篋：循环for语句可变借用实例
 
-https://www.google.com/search?q=rust+mutable+borrow+in+loop&oq=rust+mut+bor&aqs=chrome.3.69i57j0l5.23911j0j7&sourceid=chrome&ie=UTF-8
+
+## 学习内容
+- 了解和学习循环for语句可变借用实例
+
+## 篇目
+
+- [方法`into_iter()`与关键词`mut`的组合结构](#方法into_iter与关键词mut的组合结构)
+- [方法`iter_mut()`实例](#方法iter_mut实例)
+- [题外话](#题外话)
+- [方法`next()`实例](#方法next实例)
+- [方法`enumerate()`实例](#方法enumerate实例)
+- [参考资料](#参考资料)
+
+
+iter() iterates over the items by reference
+into_iter() iterates over the items, moving them into the new scope
+iter_mut() iterates over the items, giving a mutable reference to each item
+
+
+## 方法`into_iter()`与关键词`mut`的组合结构
+
+　　对于具有迭代器`Iterator`的对象而言，方法`into_iter()`是完全依赖于其对象类型，且遍历其所有的元素本身。下面通过实例再回顾一下这种方法。
+
+　　如下面程序，对象`instance`的类型是`Vec<u8>`，这样其元素是原始类型`u8`，那么方法就遍历其所有原始类型`u8`的元素。
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_into_iter.rs:feature-okay }}
+```
+
+　　其实，上面程序从表面上，方法`into_iter()`，既看不能让人看到其遍历的元素类型，也看不能让人知道其已经消费了对象`instance`。
+
+　　对于第一个问题，为了简单快速了解其元素类型，可以使用上面程序注释掉的宏方法`println!()`，要是编译没有错误，就说明对象`item`是引用类型，否则就是非引用类型。
+
+　　对于第二个问题，只要在上面程序基础上，在其最后增加一行宏方法`println!()`代码，如下所示。只要编译该程序，就会出现借用编译错误。说明方法`into_iter()`已经把对象`instance`消费掉了。
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_into_iter.rs:feature-error_01 }}
+```
+
+　　为了使得对象`instance`在调用方法`into_iter()`以后，且修改其元素，而对象`instance`依然存在，需要借用可变对象`instance`。
+
+　　需要指出的是，即使对象`instance`是可变的，上面程序的方法元素本身也是不可变对象。
+
+　　对于方法`into_iter()`，要是对象类型是`&Vec<u8>`，其元素是引用类型`&u8`，那么方法就遍历其所有引用类型`&u8`的元素。
+
+　　下面程序可变对象`instance`的类型是`&mut Vec<u8>`，其元素是可变引用类型`&mut u8`，那么方法就遍历其所有可变引用类型`&mut u8`的元素。
+
+　　下面程序是这里重点解释的结构。三个部分缺一不可：对象`instance`本身是可变的；其引用本身也是可变的；使用引用作为方法`into_iter()`的对象。这样可以实现对象`instance`内容的修改。
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_into_iter.rs:feature-cp }}
+```
+
+　　上面程序里，引用对象`ref_instance`的类型是一种默认情况，即绑定对象`ref_instance`时，其类型写与不写是一样的意思。但是下面程序的引用对象`ref_instance`的类型可以不是默认的，而是人为绑定的，这是程序第二段代码的第一行代码。当然程序第二段代码的第二行也是一种默认绑定方式。
+
+　　对象`instance`的类型是`&mut [u8]`，其元素是引用类型`&mut u8`，那么方法就遍历其所有引用类型`&mut u8`的元素。这种情况可以把`&Vec<u8>`和`＆[u8]`看作为类似于`&String`和`＆str`。
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_into_iter.rs:feature-okey }}
+```
+
+## 方法`iter_mut()`实例
+
+> 方法`iter_mut()` = 方法`into_iter()`与关键词`mut`的组合结构
+
+　　从上面这行文字可以了解到，接下来说明方法`iter_mut()`其实就是上面程序代码的简化。
+
+　　通过下面程序使用方法`iter_mut()`，可以了解到它涉及到下面几方面内容：
+
+- 方法`iter_mut()`遍历其元素都是引用；
+- 方法`iter_mut()`遍历其元素都是可变引用；
+- 在调用方法`iter_mut()`以后，对象`instance`依然是存在的；
+- 方法`iter_mut()`隐藏了一个可变借用对象；
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_iter_mut.rs:feature-ok }}
+```
+
+## 题外话
+
+### 方法`enumerate()`实例
+
+　　常常希望通过数组的顺序号访问数组。第一个程序说明了这种想法的解决方案：
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_enumerate.rs:feature-cp }}
+```
+
+　　实现这种想法的比较标准方法是使用标准库方法`enumerate()`。这个方法不仅遍历了数组的顺序号。而且还遍历其所有元素：
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_enumerate.rs:feature-okey }}
+```
+
+　　第三种是最广泛使用的实现，它摒弃了循环语句：
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_enumerate.rs:feature-okay }}
+```
+
+### 方法`next()`实例
+
+　　通过下面程序解释使用方法`next()`的技巧：
+
+> 可行结构：可变对象＋可变迭代器(iter_mut)＋方法`next`
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_next.rs:feature-ok }}
+```
+
+> 不可行结构：可变对象＋迭代器(iter_mut)＋方法`next`
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_next.rs:feature-error_01 }}
+```
+
+> 不可行结构：（可变）对象＋可变迭代器(into_iter)＋方法`next`
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/for_next.rs:feature-error_02 }}
+```
+
+## 参考资料
+- [rust-for-loop](http://xion.io/post/code/rust-for-loop.html)
+- [understanding-rust-loops](https://blog.codeship.com/understanding-rust-loops/)
+- [fighting-the-borrow-checker-in-a-loop](https://users.rust-lang.org/t/fighting-the-borrow-checker-in-a-loop/22975)
+- [rust-by-example/flow_control](https://doc.rust-lang.org/rust-by-example/flow_control/for.html)
+- [whats-the-difference-between-for-x-in-b-and-for-x-in-b-into-iter](https://users.rust-lang.org/t/whats-the-difference-between-for-x-in-b-and-for-x-in-b-into-iter/14739)
+- [how-can-i-do-a-mutable-borrow-in-a-for-loop](https://stackoverflow.com/questions/39622783/how-can-i-do-a-mutable-borrow-in-a-for-loop)
+- [pointers-in-rust-a-guide](https://words.steveklabnik.com/pointers-in-rust-a-guide)
+- [rust-ref](https://jvns.ca/blog/2017/11/27/rust-ref/)
+- [search?q=rust+mutable+borrow+in+loop](https://www.google.com/search?q=rust+mutable+borrow+in+loop)
+- [what-is-the-difference-between-iter-and-into-iter](https://stackoverflow.com/questions/34733811/what-is-the-difference-between-iter-and-into-iter)
+- [a-journey-into-iterators](https://hoverbear.org/blog/a-journey-into-iterators/)
+- [yarit-yet-another-rust-iterators-tutorial](https://dev.to/dandyvica/yarit-yet-another-rust-iterators-tutorial-46dk)
+- [effectively-using-iterators-in-rust](https://hermanradtke.com/2015/06/22/effectively-using-iterators-in-rust.html)
+- 
+
+
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/for_loop/mut_string.rs:feature-okey }}
+```
+
+![image](../../hello-borrowing/images/hello_borrowing-12_vec_for_loop.png)

docs/zh-first-volumn/src/hello-borrowing/images/hello_borrowing-18-mut_ref_deref.sketchpad

@@ -5,7 +5,6 @@
 ## 学习内容
 - 了解和学习绑定固定引用和可变引用的可变对象借用实例
 
-
 ## 篇目
 
 - [可变对象及其可变引用关系](#可变对象及其可变引用关系)
@@ -97,35 +96,32 @@ let mut mut_ref_immut :&str = &instance;
 
 ## 绑定可变引用的可变对象
 
-
 > let mut mut_and_mut_ref = &mut mut_instance;
 
-```rust
-{{ #include ../../../../hello-borrowing/bin-hello/examples/mut_immut/mut_string.rs:feature-okey }}
-```
-
+　　与前面了解到的绑定可变引用的固定对象与绑定固定引用的可变对象实例类似，这种如上Rust语句的对象`mut_and_mut_ref`，无论是所引用对象`mut_instance`值，还是对象`mut_and_mut_ref`本身值都是可变的。
 
+　　下面是如何使用绑定可变引用的可变对象具体实例：
 
-```
-// https://internals.rust-lang.org/t/allow-mut-value-not-just-mut-reference/7424/2
-let mut a = &mut x;
+```rust
+{{ #include ../../../../hello-borrowing/bin-hello/examples/mut_immut/mut_string.rs:feature-okey }}
 ```
 
-You can also do let mut a = &mut x; which would mean you could later change a to be a mutable reference to another variable.
-A mut after let means the variable can be changed. This is not equivalent to a mut at any place right of the =.
+　　在这里之所以使用可变对象属性，是因为在第一次调用方法`one()`以后，方法将对象`mut_ref`消费掉了，尽管对象`mut_ref`本身还是存在的，但其内容已经不在了，要是直接再次调用方法`two()`，就会出现错误。这也说明了对象`mut_ref`的值是可变的。
 
+　　要是不存在对象`mut_ref`第二次的赋值，就会出现下面借用错误。
 
-https://hermanradtke.com/2015/06/09/strategies-for-solving-cannot-move-out-of-borrowing-errors-in-rust.html
 
 
-borrow-clone.rs
+　　在这里之所以使用需要绑定可变引用属性，是因为调用方法的参数是可变引用。方法参数是可变引用，说明该引用将会被修改。从方法功能可以看到，参数是被修改了。
 
+　　通过上面了解到绑定可变引用的可变对象，不仅对象`mut_ref`本身内容是可修改的，即，之后可以将其更改为另一个对象或者其本身的可变引用，而且其值的对象`mut_instance`内容也是可修改的，即，之后可以将其更改为任何字符串文字内容。
 
-Can you spot the difference? Now, on line 4, we call the other function with a clone of the value held by the hello variable. Obviously this is not the most efficient way to write your program, and it can be risky if you don't know the size of the values which are going to be getting cloned. Also, if your functions mutate the value in some way then this is not a good solution:
+　　最后非常简单地阐述类型`Box<T>`的作用，类型`Box<T>`可以将任何类型`T`打包起来，方便其打包类型`T`进行传输或者处理等，比如，要是一组不同类型都打包成类型`Box<T>`以后，就可以作为一个数组一起处理，另外这是一种引用数据类型。
 
-您看得出来差别吗？ 现在，在第4行，我们用hello变量保存的值的克隆调用另一个函数。 显然，这不是编写程序的最有效方法，如果您不知道将要克隆的值的大小，则可能会有风险。 另外，如果您的函数以某种方式更改了值，那么这不是一个好的解决方案：
+　　可以把类型`Box<T>`与`T`理解为类型`String`与`str`的类似关系，前者类型`String`存在可以大量操作其内容的功能，而后者主要的内容储存功能，两种各自具有不同的功能。当然类型`Box<T>`主要的解压功能，而后者是数据结构功能。
 
 ## 题外话
+
 ### 连接字符串的正确方法
 
 ```rust
@@ -142,11 +138,6 @@ println!("result = {}", result);
 ```
 
 
-- [what-is-right-ways-to-concat-strings](https://users.rust-lang.org/t/what-is-right-ways-to-concat-strings/3780/1)
-- [best-way-to-do-string-concatenation-in-2019-status-quo](https://users.rust-lang.org/t/best-way-to-do-string-concatenation-in-2019-status-quo/24004)
-- [how-do-i-concatenate-strings](https://stackoverflow.com/questions/30154541/how-do-i-concatenate-strings)
-- 
-
 ## 最主要参考资料
 - [rust-ownership](https://hellocode.dev/rust-ownership)
 - [passing-a-string-by-reference-and-manipulate-the-string](https://stackoverflow.com/questions/26151324/passing-a-string-by-reference-and-manipulate-the-string)
@@ -160,4 +151,11 @@ println!("result = {}", result);
 - [strategies-for-solving-cannot-move-out-of-borrowing-errors-in-rust](https://hermanradtke.com/2015/06/09/strategies-for-solving-cannot-move-out-of-borrowing-errors-in-rust.html)
 - [best-way-to-do-string-concatenation-in-2019-status-quo](https://users.rust-lang.org/t/best-way-to-do-string-concatenation-in-2019-status-quo/24004/4)
 - [what-is-right-ways-to-concat-strings](https://users.rust-lang.org/t/what-is-right-ways-to-concat-strings/3780)
-- 
+- [allow-mut-value-not-just-mut-reference](https://internals.rust-lang.org/t/allow-mut-value-not-just-mut-reference/7424/2)
+- [strategies-for-solving-cannot-move-out-of-borrowing-errors-in-rust](https://hermanradtke.com/2015/06/09/strategies-for-solving-cannot-move-out-of-borrowing-errors-in-rust.html)
+
+## 参考资料：题外话
+
+- [what-is-right-ways-to-concat-strings](https://users.rust-lang.org/t/what-is-right-ways-to-concat-strings/3780/1)
+- [best-way-to-do-string-concatenation-in-2019-status-quo](https://users.rust-lang.org/t/best-way-to-do-string-concatenation-in-2019-status-quo/24004)
+- [how-do-i-concatenate-strings](https://stackoverflow.com/questions/30154541/how-do-i-concatenate-strings)

docs/zh-first-volumn/src/hello-mut-borrowing/borrowing-for-loop-mut.md

@@ -171,7 +171,7 @@ <h2><a class="header" href="#固定数组的借用错误实例" id="固定数组
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_arr/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_arr.rs
     // #[cfg(feature = &quot;err_01&quot;)]
 
     let instance = [1u8, 2, 3];
@@ -201,7 +201,7 @@ <h2><a class="header" href="#固定数组的借用机制实例" id="固定数组
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_arr/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_arr.rs
     // #[cfg(feature = &quot;ok&quot;)]
 
     let instance = [1u8, 2, 3];
@@ -257,7 +257,7 @@ <h2><a class="header" href="#可变数组的简单借用错误实例" id="可变
 # #![allow(unused_variables)]
 #fn main() {
 pub fn adjoin() {
-    // File: ./bin-hello/examples/for_loop/for_vec/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec.rs
     // #[cfg(feature = &quot;cp&quot;)]
 
     let instance = vec![1, 2, 3];
@@ -283,7 +283,7 @@ <h2><a class="header" href="#可变数组的简单借用错误实例" id="可变
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_vec/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec.rs
     // #[cfg(feature = &quot;err_02&quot;)]
 
     let instance = vec![1, 2, 3];
@@ -304,7 +304,7 @@ <h2><a class="header" href="#可变数组的借用机制实例" id="可变数组
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_vec/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec.rs
     // #[cfg(feature = &quot;ok&quot;)]
 
     let instance = vec![1u8, 2, 3];
@@ -335,7 +335,7 @@ <h2><a class="header" href="#迭代方法iter和into_iter区别" id="迭代方
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_vec_iter/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec_iter.rs
     // #[cfg(feature = &quot;err_03&quot;)]
 
     let instance = vec![1, 2, 3];
@@ -361,7 +361,7 @@ <h2><a class="header" href="#迭代方法iter和into_iter区别" id="迭代方
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_vec_iter/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec_iter.rs
     // #[cfg(feature = &quot;cp&quot;)]
 
     let instance = vec![1u8, 2, 3];
@@ -397,7 +397,7 @@ <h2><a class="header" href="#可变数组的迭代借用机制实例" id="可变
 <pre><pre class="playpen"><code class="language-rust">
 # #![allow(unused_variables)]
 #fn main() {
-    // File: ./bin-hello/examples/for_loop/for_vec_iter/mod.rs
+    // File: ./bin-hello/examples/for_loop/for_vec_iter.rs
     // #[cfg(feature = &quot;ok&quot;)]
 
     let instance = vec![1u8, 2, 3];