Slices
ch04-03-slices.md
commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56
另一个没有所有权的数据类型是 slice。slice 允许你引用集合中一段连续的元素序列，而不用引用整个集合。
这里有一个小的编程问题：编写一个获取一个字符串并返回它在其中找到的第一个单词的函数。如果函数没有在字符串中找到一个空格，就意味着整个字符串是一个单词，所以整个字符串都应该返回。
让我们看看这个函数的签名：
fn first_word(s: &String) -> ?
first_word这个函数有一个参数&String。因为我们不需要所有权，所以这没有问题。不过应该返回什么呢？我们并没有一个真正获取部分字符串的办法。不过，我们可以返回单词结尾的索引。让我们试试如列表 4-10 所示的代码：
Filename: src/main.rs
fn first_word(s: &String) -> usize {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return i;
}
}
s.len()
}
Listing 4-10: The first_word function that returns a
byte index value into the String parameter
让我们将代码分解成小块。因为需要一个元素一个元素的检查String中的值是否是空格，需要用as_bytes方法将String转化为字节数组：
let bytes = s.as_bytes();
接下来，使用iter方法在字节数据上创建一个迭代器：
for (i, &item) in bytes.iter().enumerate() {
第十三章将讨论迭代器的更多细节。现在，只需知道iter方法返回集合中的每一个元素，而enumerate包装iter的结果并返回一个元组，其中每一个元素是元组的一部分。返回元组的第一个元素是索引，第二个元素是集合中元素的引用。这比我们自己计算索引要方便一些。
因为enumerate方法返回一个元组，我们可以使用模式来解构它，就像 Rust 中其他地方一样。所以在for循环中，我们指定了一个模式，其中i是元组中的索引而&item是单个字节。因为从.iter().enumerate()中获取了集合元素的引用，我们在模式中使用了&。
我们通过字节的字面值来寻找代表空格的字节。如果找到了，返回它的位置。否则，使用s.len()返回字符串的长度：
if item == b' ' {
return i;
}
}
s.len()
现在有了一个找到字符串中第一个单词结尾索引的方法了，不过这有一个问题。我们返回了单单一个usize，不过它只在&String的上下文中才是一个有意义的数字。换句话说，因为它是一个与String像分离的值，无法保证将来它仍然有效。考虑一下列表 4-11 中使用了列表 4-10 first_word函数的程序：
Filename: src/main.rs
# fn first_word(s: &String) -> usize {
# let bytes = s.as_bytes();
#
# for (i, &item) in bytes.iter().enumerate() {
# if item == b' ' {
# return i;
# }
# }
#
# s.len()
# }
#
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s); // word will get the value 5.
s.clear(); // This empties the String, making it equal to "".
// word still has the value 5 here, but there's no more string that
// we could meaningfully use the value 5 with. word is now totally invalid!
}
Listing 4-11: Storing the result from calling the
first_word function then changing the String contents
这个程序编译时没有任何错误，而且在调用s.clear()之后使用word也不会出错。这时word与s状态就没有联系了，所以word仍然包含值5。可以尝试用值5来提取变量s的第一个单词，不过这是有 bug 的，因为在我们将5保存到word之后s的内容已经改变。
不得不担心word的索引与s中的数据不再同步是乏味且容易出错的！如果编写一个second_word函数的话管理索引将更加容易出问题。它的签名看起来像这样：
fn second_word(s: &String) -> (usize, usize) {
现在我们跟踪了一个开始索引和一个结尾索引，同时有了更多从数据的某个特定状态计算而来的值，他们也完全没有与这个状态相关联。现在有了三个飘忽不定的不相关变量都需要被同步。
幸运的是，Rust 为这个问题提供了一个解决方案：字符串 slice。
字符串 slice
字符串 slice（string slice）是String中一部分值的引用，它看起来像这样：
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
这类似于获取整个String的引用不过带有额外的[0..5]部分。不同于整个String的引用，这是一个包含String内部的一个位置和所需元素数量的引用。
我们使用一个 range [starting_index..ending_index]来创建 slice，不过 slice 的数据结构实际上储存了开始位置和 slice 的长度。所以就let world = &s[6..11];来说，world将是一个包含指向s第 6 个字节的指针和长度值 5 的 slice。
图 4-12 展示了一个图例
Figure 4-12: String slice referring to part of a
String
对于 Rust 的.. range 语法，如果想要从第一个索引（0）开始，可以不写两个点号之前的值。换句话说，如下两个语句是相同的：
let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2];
由此类推，如果 slice 包含String的最后一个字节，也可以舍弃尾部的数字。这意味着如下也是相同的：
let s = String::from("hello");
let len = s.len();
let slice = &s[0..len];
let slice = &s[..];
在记住所有这些知识后，让我们重写first_word来返回一个 slice。“字符串 slice”的签名写作&str：
Filename: src/main.rs
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[..]
}
我们使用跟列表 4-10 相同的方式获取单词结尾的索引，通过寻找第一个出现的空格。当我们找到一个空格，我们返回一个索引，它使用字符串的开始和空格的索引来作为开始和结束的索引。
现在当调用first_word时，会返回一个单独的与底层数据相联系的值。这个值由一个 slice 开始位置的引用和 slice 中元素的数量组成。
second_word函数也可以改为返回一个 slice：
fn second_word(s: &String) -> &str {
现在我们有了一个不易混杂的直观的 API 了，因为编译器会确保指向String的引用保持有效。还记得列表 4-11 程序中，那个当我们获取第一个单词结尾的索引不过接着就清除了字符串所以索引就无效了的 bug 吗？那些代码逻辑上时不正确的，不过却没有任何直观的错误。问题会在之后尝试对空字符串使用第一个单词的索引时出现。slice 就不可能出现这种 bug 并让我们更早的知道出问题了。使用 slice 版本的first_word会抛出一个编译时错误：
Filename: src/main.rs
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s);
s.clear(); // Error!
}
这里是编译错误：
17:6 error: cannot borrow `s` as mutable because it is also borrowed as
immutable [E0502]
s.clear(); // Error!
^
15:29 note: previous borrow of `s` occurs here; the immutable borrow prevents
subsequent moves or mutable borrows of `s` until the borrow ends
let word = first_word(&s);
^
18:2 note: previous borrow ends here
fn main() {
}
^
回忆一下借用规则，当拥有某值的不可变引用时。不能再获取一个可变引用。因为clear需要清空String，它尝试获取一个可变引用，它失败了。Rust 不仅使得我们的 API 简单易用，也在编译时就消除了一整个错误类型！
字符串字面值就是 slice
还记得我们讲到过字符串字面值被储存在二进制文件中吗。现在知道 slice 了，我们就可以正确的理解字符串字面值了：
let s = "Hello, world!";
这里s的类型是&str：它是一个指向二进制程序特定位置的 slice。这也就是为什么字符串字面值是不可变的；&str是一个不可变引用。
字符串 slice 作为参数
在知道了能够获取字面值和String的 slice 后引起了另一个对first_word的改进，这是它的签名：
fn first_word(s: &String) -> &str {
相反一个更有经验的 Rustacean 会写下如下这一行，因为它使得可以对String和&str使用相同的函数：
fn first_word(s: &str) -> &str {
如果有一个字符串 slice，可以直接传递它。如果有一个String，则可以传递整个String的 slice。定义一个获取字符串 slice 而不是字符串引用的函数使得我们的 API 更加通用并且不会丢失任何功能：
Filename: src/main.rs
# fn first_word(s: &str) -> &str {
# let bytes = s.as_bytes();
#
# for (i, &item) in bytes.iter().enumerate() {
# if item == b' ' {
# return &s[0..i];
# }
# }
#
# &s[..]
# }
fn main() {
let my_string = String::from("hello world");
// first_word works on slices of `String`s
let word = first_word(&my_string[..]);
let my_string_literal = "hello world";
// first_word works on slices of string literals
let word = first_word(&my_string_literal[..]);
// since string literals *are* string slices already,
// this works too, without the slice syntax!
let word = first_word(my_string_literal);
}
其他 slice
字符串 slice，正如你想象的那样，是针对字符串的。不过也有更通用的 slice 类型。考虑一下这个数组：
let a = [1, 2, 3, 4, 5];
就跟我们想要获取字符串的一部分那样，我们也会想要引用数组的一部分，而我们可以这样做：
let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
这个 slice 的类型是&[i32]。它跟以跟字符串 slice 一样的方式工作，通过储存第一个元素的引用和一个长度。你可以对其他所有类型的集合使用这类 slice。第八章讲到 vector 时会详细讨论这些集合。
总结
所有权、借用和 slice 这些概念是 Rust 何以在编译时保障内存安全的关键所在。Rust 像其他系统编程语言那样给予你对内存使用的控制，但拥有数据所有者在离开作用域后自动清除其数据的功能意味着你无须额外编写和调试相关的控制代码。
所有权系统影响了 Rust 中其他很多部分如何工作，所以我们会继续讲到这些概念，贯穿本书的余下内容。让我们开始下一个章节，来看看如何将多份数据组合进一个struct中。