本系列文章是Jon Gjengset發布的CRust of Rust系列視頻的學習筆記，CRust of Rust是一系列持續更新的Rust中級教程。

在這篇文章中，我們將研究一個需要顯式注釋多個生命期的例子。我們還將討論不同字符串類型之間的一些差異，以及在自定義的trait上引入泛型。這個例子是根據給定的字符串和分隔符對字符串進行拆分。

創建一個新項目：

cargo new --lib strsplit

 1#[derive(Debug)]
 2pubstructStrSplit<'a>{
 3remainder:&'astr,
 4delimiter:&'astr,
 5}
 6
 7#[allow(dead_code)]
 8impl<'a>StrSplit<'a>{
 9pubfnnew(haystack:&'astr,delimiter:&'astr)->Self{
10Self{
11remainder:haystack,
12delimiter,
13}
14}
15}
16
17impl<'a>IteratorforStrSplit<'a>{
18typeItem=&'astr;
19
20fnnext(&mutself)->Option{
21ifletSome(next_delim)=self.remainder.find(self.delimiter){
22letuntil_remainder=&self.remainder[..next_delim];
23self.remainder=&self.remainder[next_delim+self.delimiter.len()..];
24Some(until_remainder)
25}elseifself.remainder.is_empty(){
26None
27}else{
28letrest=self.remainder;
29//為什么空字符串可以賦值給self.remainder???
30self.remainder="";
31Some(rest)
32}
33}
34}
35
36#[test]
37fnit_works(){
38lethaystack="abcde";
39letletters:Vec<_>=StrSplit::new(haystack,"").collect();
40assert_eq!(letters,vec!["a","b","c","d","e"]);
41}

StrSplit 與成員 remainder，delimiter 擁有相同的生命周期

使用fn new()方法構建的StrSplit與傳入的參數haystack，delimiter 擁有相同的生命周期

在實現Iterator trait時，迭代的結果也要與StrSplit擁有相同的生命周期，是因為要在StrSplit的成員remainder上做迭代。

在第30行，為什么空字符串可以賦值給self.remainder？這是因為self.remainder的生命周期是&'a str，空字符串的生命周期是&'static str，static的生命周期一直到程序結束。 修復Bug 這里有一個bug，添加如下測試方法：

1#[test]
2fntail(){
3lethaystack="abcd";
4letletters:Vec<_>=StrSplit::new(haystack,"").collect();
5assert_eq!(letters,vec!["a","b","c","d",""]);
6}

running 2 tests
test str_split_1::it_works ... ok
test str_split_1::tail ... FAILED

 1/**
 2*StrSplit與成員remainder，delimiter擁有相同的生命周期
 3*/
 4#[derive(Debug)]
 5pubstructStrSplit<'a>{
 6//使用Option
 7remainder:Option<&'a?str>,
 8delimiter:&'astr,
 9}
10
11#[allow(dead_code)]
12impl<'a>StrSplit<'a>{
13/**
14*新構建的StrSplit與傳入的參數haystack，delimiter擁有相同的生命周期
15*/
16pubfnnew(haystack:&'astr,delimiter:&'astr)->Self{
17Self{
18remainder:Some(haystack),
19delimiter,
20}
21}
22}
23
24impl<'a>IteratorforStrSplit<'a>{
25//迭代的結果也要與StrSplit擁有相同的生命周期，是因為要在StrSplit的成員remainder上做迭代。
26typeItem=&'astr;
27
28fnnext(&mutself)->Option{
29//這里為什么用Some(refmutremainder)，而不用Some(&mutrefmainder)???
30ifletSome(refmutremainder)=self.remainder{
31ifletSome(next_delim)=remainder.find(self.delimiter){
32letuntil_remainder=&remainder[..next_delim];
33*remainder=&remainder[next_delim+self.delimiter.len()..];
34Some(until_remainder)
35}else{
36self.remainder.take()
37}
38}else{
39None
40}
41}
42}
43
44#[test]
45fnit_works(){
46lethaystack="abcde";
47letletters:Vec<_>=StrSplit::new(haystack,"").collect();
48assert_eq!(letters,vec!["a","b","c","d","e"]);
49}
50
51#[test]
52fntail(){
53lethaystack="abcd";
54letletters:Vec<_>=StrSplit::new(haystack,"").collect();
55assert_eq!(letters,vec!["a","b","c","d",""]);
56}

running 2 tests
test str_split_2::tail ... ok
test str_split_2::it_works ... ok

 1impl<'a>IteratorforStrSplit<'a>{
 2//迭代的結果也要與StrSplit擁有相同的生命周期，是因為要在StrSplit的成員remainder上做迭代。
 3typeItem=&'astr;
 4
 5fnnext(&mutself)->Option{
 6//為什么不可以這么寫？？？
 7letremainder=&mutself.remainder?;
 8ifletSome(next_delim)=remainder.find(self.delimiter){
 9letuntil_remainder=&remainder[..next_delim];
10*remainder=&remainder[next_delim+self.delimiter.len()..];
11Some(until_remainder)
12}else{
13self.remainder.take()
14}
15}
16}
17

在迭代器的next方法里嘗試換一種寫法，編譯器檢查通過，但是執行測試不通過。也就是上面代碼的第7行，為什么不可以這么寫？

self.remainder是Option<&'a str>類型，這里的泛型是引用。所以在執行unwrap()，expect()或?時，會將Option里的引用Copy一份出來賦值給remainder，然后在這個新的remainder上作可變引用，而self.remainder沒有任何變化。

我們可以使用Option的as_mut()方法，因為它返回的是Option<&mut T>：

1fnnext(&mutself)->Option{
2//為什么這么寫不可以？？？
3//letremainder=&mutself.remainder?;
4
5letremainder=self.remainder.as_mut()?;
6......
7}

得到了一個self.remainder的可變引用，因此測試通過。

在下一篇文章中，我們通過更多的例子來繼續學習Rust的生命周期。

審核編輯：湯梓紅