Refined Ch04.

projects/slices/src/main.rs

@@ -1,10 +1,20 @@
 fn main() {
-    let s = String::from("hello");
+    let a = [1, 2, 3, 4, 5];
 
-    let len = s.len();
+    let slice = &a[1..3];
 
-    let slice_1 = &s[3..len];
+    assert_eq! (slice, &[2, 3]);
-    let slice_2 = &s[3..];
+}
-
+
-    assert_eq! (slice_1, slice_2);
+
+fn first_word(s: &String) -> &str {
+    let bytes = s.as_bytes();
+
+    for (i, &item) in bytes.iter().enumerate() {
+        if item == b' ' {
+            return &s[0..i];
+        }
+    }
+
+    &s[..]
 }

src/ownership/the_slice_type.md

@@ -129,7 +129,7 @@ fn second_word(s: &String) -> (usize, usize) {
 下图 4-6 以图表的形式，展示了这一点。
 
 
-![指向一个 `String` 数据局部的字符串切片](images/Ch04_06.svg)
+![指向一个 `String` 数据局部的字符串切片](../images/Ch04_06.svg)
 
 *图 4-6：指向某个 `String` 的字符串切片*
 
@@ -168,10 +168,11 @@ fn second_word(s: &String) -> (usize, usize) {
     let slice = &s[..];
 ```
 
-> **注意**：这些字符串切片的范围索引值，必须出现于有效的 UTF-8 字符边界处。若在 UTF-8 多字节字符中间，尝试创建字符串切片，那么程序就会以错误退出。这里只是为介绍字符串切片目的，而假定本小节中只使用 ASCII 字符；在第 8 章的 [“以 `String` 类型值存储 UTF-8 编码的文本”](Ch08_Common_Collections.md#使用-string-存储-utf-8-编码的文本) 小节，有着对 UTF-8 字符串的更全面讨论。
+> **注意**：字符串切片的范围索引，必须出现在有效的 UTF-8 字符边界处。如果咱们试图在某个多字节字符的中间创建字符串片段，咱们的程序将报错退出。为介绍字符串切片目的，我们在本节中假设仅有 ASCII 编码；有关 UTF-8 处理的更全面讨论，请参阅第 8 章的 [使用字符串存储 UTF-8 编码文本](../common_collections/strings.md) 小节。
 
 
-对这全部字符串切片的情况了然在胸，那么下面就来将 `first_word` 重写为返回切片。表示 “字符串切片” 的类型，写做 `&str`：
+有了这些信息，我们来将 `first_word` 重写为返回一个切片。表示 “字符串切片” 的类型，被写作 `&str`：
+
 
 文件名：`src/main.rs`
 
@@ -189,54 +190,58 @@ fn first_word(s: &String) -> &str {
 }
 ```
 
-这里是以前面清单 4-7 中所做的同样方式，即查找首次出现的空格，而获取到该单词结束处的索引。在找到空格时，就运用该字符串的开头，与那个空格的索引，作为字符串切片开始与结束索引，而返回一个字符串切片。
 
-现在当调用 `first_word` 函数时，取回的便是与所用 `String` 数据联系起来单个值。这个值是由到切片起点的引用，与切片中元素个数所组成。
+我们以与清单 4-7 中，相同的方式获取到该单词结尾的索引，即查找第一次出现的空格。当我们找到一个空格时，我们使用该字符串的开头，与这个空格的索引，作为开始和结束索引，返回一个字符串切片。
+
+现在，当我们调用 `first_word` 时，就会返回一个与所采用数据相关的值。该值由到切片起点的引用，和切片中元素的数量组成。
+
+对于 `second_word` 函数来说，返回切片也是可行的：
 
-这样返回切片，对于 `second_word` 函数，也是有效的：
 
 ```rust
 fn second_word(s: &String) -> &str {
 ```
 
-由于编译器将确保到那个 `String` 数据中引用保持有效，因此现在就有了一个简单的、相比之前那个不那么容易搞混的 API 了。还记得在清单 4-8 中那个程序里的错误吧，即那个在已经获取到首个单词结束位置的索引，而随后清除了那个字符串，因此得到的索引就不在有效的问题。那段代码虽然逻辑上不正确，但也不会立即给出什么错误来。若继续尝试使用空字符串上的首个单词结束索引，这些问题仍会出现。切片就令到这个代码错误不可能了，并实现了更快发现代码问题。使用切片版本的 `first_word` 函数，就会抛出一个编译时错误：
+现在，我们有了一个简单明了的 API，而且更难出错，因为编译器会确保对那个 `String` 的引用保持有效。还记得清单 4-8 中程序的错误吗？当时我们得到了第一个单词末尾的索引，但随后又清除了那个字符串，因此咱们索引就无效来了。那段代码在逻辑上是错误的，但并没有立即给出任何错误。如果我们继续尝试对某个清空的字符串，使用第一个单词的索引，那么该问题就会在稍后出现。而切片则不会出现这种错误，并能让我们更早地知道，咱们代码出现了问题。使用切片版本的 `first_word` 会抛出一个编译时报错：
+
 
 文件名：`src/main.rs`
 
 ```rust
 fn main() {
-    let mut s = String::from("The quick brown fox jumps over the lazy dog.");
+    let mut s = String::from("hello world");
 
     let word = first_word(&s);
 
-    s.clear();
+    s.clear(); // error!
 
-    println! ("首个单词为：{}", word);
+    println!("the first word is: {}", word);
 }
 ```
 
-下面就是那个编译器错误消息：
+
+下面是那个编译器报错：
 
 ```console
-$ cargo run                                                                      ✔
+$ cargo run
-   Compiling ownership_demo v0.1.0 (/home/peng/rust-lang/projects/ownership_demo)
+   Compiling slices v0.1.0 (C:\tools\msys64\home\Lenny.Peng\rust-lang-zh_CN\projects\slices)
 error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
- --> src/main.rs:6:5
+ --> src\main.rs:6:5
   |
 4 |     let word = first_word(&s);
   |                           -- immutable borrow occurs here
 5 |
-6 |     s.clear();
+6 |     s.clear(); // error!
   |     ^^^^^^^^^ mutable borrow occurs here
 7 |
-8 |     println! ("首个单词为：{}", word);
+8 |     println!("the first word is: {}", word);
   |                                       ---- immutable borrow later used here
 
 For more information about this error, try `rustc --explain E0502`.
-error: could not compile `ownership_demo` due to previous error
+error: could not compile `slices` (bin "slices") due to previous error
 ```
 
-回顾借用规则，在有着到某数据的不可变引用时，就不能同时有可变引用。由于 `clear` 方法需要清空那个 `String` 值，那么就需要得到一个可变引用。而在 `clear` 方法调用之后的 `println!`，用到了变量 `word` 里的引用，那么这个不可变引用于那个时刻，就必将仍是活跃的。Rust 不允许 `clear` 中的可变引用，与 `word` 中的不可变引用同时存在，进而编译失败。可以看出，Rust 不光令到这个 `first_word` 的 API 更易于使用，他还在运行时就消除了这一整类错误！
+回顾一下借用规则，如果我们有个不可变的引用，我们就不能同时取得一个可变的引用。因为 `clear` 需要截断这个 `String`，所以他需要得到一个可变引用。`clear` 调用后的那个 `println!`，使用了 `word` 中的引用，因此这个不可变引用，在此时必须仍然有效。Rust 不允许 `clear` 中的可变引用，和 `word` 中的不可变引用同时存在，因此编译会失败。Rust 不仅让我们的 API 更易于使用，还消除了编译时的一整类报错！
 
 
 ### 作为切片的字符串字面值
@@ -244,13 +249,15 @@ error: could not compile `ownership_demo` due to previous error
 **String Literals as Slices**
 
 
-还记得前面讲到过，那些硬编码的、存储在二进制可执行文件内部的字符串字面值吧。现在了解了切片，那么就可以很好理解字符串字面值了：
+回想一下，我们曾讲到过的存储在二进制文件中的字符串字面值。现在我们知道了分片，我们就能正确理解字符串字面值了：
+
 
 ```rust
 let s = "Hello, world!";
 ```
 
-这里的变量 `s` 的类型，即为 `&str`：他是个指向到二进制文件特殊点位的一个切片。这也是为何字符串字面值为不可变的原因；`&str` 类型属于不可变引用。
+
+这里 `s` 的类型，就是 `&str`：他是一个指向二进制中特定点的切片。这也是字符串字面值不可变的原因；`&str` 是个不可变引用。
 
 
 ### 作为参数的字符串切片
@@ -258,23 +265,28 @@ let s = "Hello, world!";
 **String Slices as Parameters**
 
 
-了解了咱们可在函数中，取字符串字面值的切片及 `String` 值，就引出了对 `first_word` 函数的又一项改进，而下面就是函数 `first_word` 的签名：
+明白咱们可以取字符串字面值和 `String` 值的切片后，我们就可以对 `first_word` 进行另一项改进，那就是他的签名：
+
 
 ```rust
 fn first_word(s: &String) -> &str {
 ```
 
-更老道的 Rust 公民将把这个函数签名，写着像下面清单 4-9 中所展示的那样，这是因为下面这样写，就实现了在 `&String` 与 `&str` 两种类型值上，可使用同一个函数：
+
+更有经验的 Rustacean，会写下下面清单 4-9 中的签名，因为他允许我们，对 `&String` 值和 `&str` 值，使用同一个函数。
+
 
 ```rust
 fn first_word(s: &str) -> &str {
 ```
 
-*清单 4-9：通过对 `s` 参数的类型使用字符串切片，对 `first_word` 函数进行改进*
+*清单 4-9：通过对 `s` 参数的类型使用字符串切片，改进这个 `first_word` 函数*
 
-在咱们有着某个字符串切片时，那么就可以直接传递那个字符串切片。而在咱们有着一个 `String` 时，则可传递该 `String` 的切片，或到这个 `String` 的引用。这种灵活性，是利用了 *强制引用解除，deref coercions* 特性，在第 15 章的 [函数与方法下的隐式强制解引用](Ch05_Smart_Pointers.md#函数与方法下的隐式解引用强制转换) 小节，将讲到的一种特性。
 
-这样定义出取字符串切片，而非到 `String` 值引用做参数的函数，令到这个 API 在不丢失任何功能的情况下，变得更为通用和有用：
+如果我们有个字符串切片，我们可以直接传递他。如果我们有个 `String`，我们可以这个 `String` 切片，或到这个 `String` 的某个引用。这种灵活性，利用了我们将在第 15 章 [函数和方法中的隐式解引用强制转换](../smart_pointers/deref-t.md#函数与方法下的隐式解引用强制转换) 小节中,介绍的 *解引用强制转换* 特性。
+
+定义一个取字符串切片，而非到某个 `String` 的引用的函数，使得我们的 API 更为通用和实用，而不会丢失任何功能：
+
 
 文件名：`src/main.rs`
 
@@ -282,47 +294,42 @@ fn first_word(s: &str) -> &str {
 fn main() {
     let s = String::from("The quick brown fox jumps over the lazy dog.");
 
-    // 函数 first_word 在 String 值的切片上有效，不管是部分还是全部的切片
+    // `first_word` 会在 String 的切片上工作，不管是部分还是整个 String
     let word = first_word(&s[0..6]);
-    println! ("{}", word);
-
     let word = first_word(&s[..]);
-    println! ("{}", word);
 
-    // 函数 first_word 还在 String 变量的引用上有效，而 String 变量的引用
+    // `first_word` 还对 String 的引用有效，这与 String 的整个切片等价
-    // 与 String 值的整个切片是等价的
     let word = first_word(&s);
-    println! ("{}", word);
 
     let s_string_literal = "hello word";
 
-    // 函数 first_word 在字符串字面值上有效，不论是部分还是整体
+    // `first_word` 在字符串字面值上有效，不论部分还是整体
     let word = first_word(&s_string_literal[0..6]);
-    println! ("{}", word);
-
     let word = first_word(&s_string_literal[..]);
-    println! ("{}", word);
 
-    // 由于字符串字面值已经 是 字符串切片，因此无需切片语法，这
+    // 由于字符串字面值已经 *是* 字符串切片，
-    // 也是有效的!
+    // 因此无需切片语法，这也会工作。
     let word = first_word(s_string_literal);
-
-    println! ("{}", word);
 }
 ```
 
+
 ## 其他切片
 
-或许已经想到，字符串切片是特定于字符串的。然而还有更多通用切片类型呢。请看下面这个数组：
+**Other Slices**
+
+
+如同咱们可能想象的那样，字符串切片是专门针对字符串的。但还有一种更通用的切片类型。请看这个数组：
+
 
 ```rust
-let a = [1, 2, 3, 4, 5];
+    let a = [1, 2, 3, 4, 5];
 ```
 
-就跟要引用字符串的部分一样，也可能要引用数组的部分。那么就将像下面这样，来完成对数组一部分的引用：
+正如我们可能要引用字符串的一部分，我们也可能想引用数组的一部分。我们可以这样做：
+
 
 ```rust
-
     let a = [1, 2, 3, 4, 5];
 
     let slice = &a[1..3];
@@ -330,11 +337,13 @@ let a = [1, 2, 3, 4, 5];
     assert_eq! (slice, &[2, 3]);
 ```
 
-这个切片变量 `slice` 的类型为 `&[i32]`。数组切片的原理与字符串切片一样，都是经由存储到首个元素的引用，和切片长度实现的。今后将对所有类别的其他集合，运用到这种切片。在第 8 章讲到各种矢量时，就会对这些集合加以讨论。
+
+这个切片的类型为 `&[i32]`。其工作方式与字符串切片相同，都是存储了到第一个元素的引用和长度。在其他各种集合中，咱们都将用到这种切片。我们将在第 8 章讨论矢量时，详细讨论这些集合。
 
 
 # 本章小结
 
-所有权、借用及切片等概念，在编译时确保了 Rust 程序中的内存安全。Rust 语言所给到的对内存运用的掌控方式，与别的系统编程语言相同，但会让数据的所有者，在其超出作用域时，自动清理掉其数据，这就意味着咱们不必编写并调试额外代码，来实现这种控制。
 
-所有权对 Rust 程序的许多其他部分都有影响，因此在本书其余部分，都将更进一步的涉及到这些所有权的概念。接下来就要移步第 5 章，而在结构体 `struct` 中，如何将小块数据组装起来。
+所有权、借用和切片的概念，确保了 Rust 程序在编译时的内存安全。Rust 给到了咱们，与其他系统编程语言同样方式的，对咱们内存使用的掌控，但在数据的所有者超出作用域时，会让数据的所有者，自动清理该数据，这意味着咱们不必编写和调试额外代码，来获得这种控制。
+
+所有权会影响 Rust 许多其他部分的工作方式，因此我们将在本书的其余部分，进一步讨论这些概念。我们来继续阅读第 5 章，看看如何在 `struct` 中，对数据块进行分组。