為什么要有切片

除了引用，Rust 還有另外一種不持有所有權的數據類型：切片（slice），切片允許我們引用集合中某一段連續(xù)的元素序列，而不是整個集合。

考慮這樣一個小問題：編寫一個搜索函數，它接收字符串作為參數，并將字符串中的首個單詞作為結果返回。如果字符串中不存在空格，那么就意味著整個字符串是一個單詞，直接返回整個字符串作為結果即可。

讓我們來看一下這個函數的簽名應該如何設計：

fn?first_word(s:?&String)?->??

由于我們不需要獲得傳入值的所有權，所以這個函數采用了 &String 作為參數。但它應該返回些什么呢？我們還沒有介紹獲取部分字符串的方法，但是可以曲線救國，將首個單詞結尾處的索引返回給調用者。

fn?first_word(s:?&String)?->?usize?{
????let?bytes?=?s.as_bytes();
????for?(index,?&item)?in?bytes.iter().enumerate()?{
????????if?item?==?b'?'?{
????????????//?這里要使用?return?index;?不能只寫?index
????????????//?因為表達式作為返回值要出現在函數的最后面
????????????return?index
????????}
????}
????s.len()
}

fn?main()?{
????println!(
????????"{}",?
????????first_word(&String::from("hello?world"))
????);?//?5
}

這段代碼首先使用 as_bytes 方法將 String 轉換為字節(jié)數組（u8），因為我們的算法需要依次檢查 String 中的字節(jié)是否為空格。

接著通過 iter 方法創(chuàng)建了一個可以遍歷字節(jié)數組的迭代器，我們會在后續(xù)詳細討論迭代器，目前只需要知道 iter 方法會依次返回集合中的每一個元素即可。

而隨后的 enumerate 則將 iter 的每個輸出逐一封裝在元組中返回，元組的第一個元素是索引，第二個元素是指向集合中字節(jié)的引用（&u8），使用 enumerate 可以較為方便地獲得迭代索引。

既然 enumerate 方法返回的是一個元組，那么我們就可以使用模式匹配來解構它，就像 Rust 中其它使用元組的地方一樣。在 for 循環(huán)的遍歷語句中，我們指定了一個解構模式，其中 i 是元組中的索引部分，而 &item 則稍微有點難理解。

首先迭代出的元組里面的第二個元素是 &u8，如果我們使用 item 遍歷，那么得到的 item 就是 &u8，在比較的時候還需要解引用，即 *item == b' '。而使用 &item 遍歷，那么 &item 得到的也是 &u8，顯然 item 就是 u8，我們就不需要解引用了。

在 for 循環(huán)的代碼塊中，使用了字面量語法來搜索數組中代表著空格的字節(jié)，這段代碼會在搜索到空格時返回當前的位置索引，并在搜索失敗時返回傳入字符串的長度 s.len()。

現在我們初步實現了期望的功能，它能夠成功地搜索并返回字符串中第一個單詞結尾處的位置索引。但這里依然存在一個設計上的缺陷，我們將一個 usize 值作為索引獨立地返回給調用者，而這個值在脫離了傳入的 &String 的上下文之后便毫無意義。

fn?first_word(s:?&String)?->?usize?{
????let?bytes?=?s.as_bytes();
????for?(index,?&item)?in?bytes.iter().enumerate()?{
????????if?item?==?b'?'?{
????????????return?index;
????????}
????}
????s.len()
}

fn?main()?{
????let?mut?s?=?String::from("hello?world");
????let?index?=?first_word(&s);
????println!("{}",?index);?//?5
????//?s.clear()?之后會清空字符串，將?s?變成?""
????s.clear();
????println!("s?=?{}",?s);??//?s?=
????//?s?被清空了，index?還是?5，但顯然此時?index?已經沒有意義了
}

上面的程序在編譯器看來沒有任何問題，即便我們在調用 s.clear() 之后使用 index 變量也是沒有問題的。同時由于 index 變量本身與 s 沒有任何關聯，所以 index 的值始終都是5。但當我們再次使用 5 去從變量 s 中提取單詞時，一個 bug 就出現了：此時 s 中的內容在我們將 5 存入 index 之后發(fā)生了改變。

這種 API 的設計方式使我們需要隨時關注 word 的有效性，確保它與 s 中的數據是一致的，類似的工作往往相當煩瑣且易于出錯。這種情況對于另一個函數 second_word 而言更加明顯，這個函數被設計來搜索字符串中的第二個單詞，它的簽名也許會被設計為下面這樣：

fn?second_word(s:?&String)?->?(usize,?usize)

現在我們需要同時維護起始和結束兩個位置的索引，這兩個值基于數據的某個特定狀態(tài)計算而來，但卻沒有跟數據產生任何程度上的聯系。于是我們有了 3 個彼此不相關的變量需要被同步，這可不妙。但幸運的是，Rust 為這個問題提供了解決方案：字符串切片。

字符串切片

字符串切片是指 String 對象中某個連續(xù)部分的引用，它的使用方式如下所示：

fn?main()?{
????let?s?=?String::from("hello?world");
????let?s1?=?&s[0..5];
????let?s2?=?&s[6..11];
????println!("s1?=?{},?s2?=?{}",?s1,?s2);??
????//?s1?=?hello,?s2?=?world
}

這里的語法與創(chuàng)建指向整個 String 對象的引用有些相似，但不同的是，新語法在結尾的地方多出了一段 [0..5]。這段額外的聲明告訴編譯器我們正在創(chuàng)建一個 String 的切片引用，而不是對整個字符串本身的引用。

切片數據結構在內部存儲了指向起始位置的引用和一個描述切片長度的字段，所以在上面的示例中，s2 是一個指向變量 s 第 7 個字節(jié)并且長度為 5 的切片。

Rust的范圍語法 .. 有一個小小的語法糖：當你希望范圍從第一個元素（也就是索引值為 0 的元素）開始時，則可以省略兩個點號之前的值；同樣地，假如你的切片想要包含 String 中的最后一個字節(jié)，你也可以省略雙點號之后的值；你甚至可以同時省略首尾的兩個值，來創(chuàng)建一個指向整個字符串所有字節(jié)的切片。

字符串切片的邊界必須位于有效的 UTF-8 字符邊界內，嘗試從一個多字節(jié)字符的中間位置創(chuàng)建字符串切片會導致運行時錯誤。但為了將問題簡化，我們這里只使用 ASCII 字符集，至于 Unicode 后續(xù)討論。

基于所學到的這些知識，讓我們開始重構 first_word 函數吧！該函數可以返回一個切片作為結果。另外，字符串切片的類型寫作 &str。

fn?first_word(s:?&String)?->?&str?{
????let?bytes?=?s.as_bytes();
????for?(index,?&item)?in?bytes.iter().enumerate()?{
????????if?item?==?b'?'?{
????????????return?&s[..?index];
????????}
????}
????&s[..]
}

fn?main()?{
????let?s?=?String::from("hello?world");
????println!("{}",?first_word(&s));??//?hello
}

調用新的 first_word 函數會返回一個與底層數據緊密聯系的切片作為結果，它由指向起始位置的引用和描述元素長度的字段組成。當然，我們也可以用同樣的方式重構 second_word 函數。

由于編譯器會確保指向 String 的引用持續(xù)有效，所以我們新設計的接口變得更加健壯且直觀了。還記得之前故意構造出的錯誤嗎？那段代碼在搜索完成并保存索引后清空了字符串的內容，這使得我們存儲的索引不再有效。因此它在邏輯上明顯是有問題的，卻不會觸發(fā)任何編譯錯誤，這個問題只會在使用第一個單詞的索引去讀取空字符串時暴露出來，而切片的引入使我們可以在開發(fā)早期快速地發(fā)現此類錯誤。

fn?first_word(s:?&String)?->?&str?{
????let?bytes?=?s.as_bytes();
????for?(index,?&item)?in?bytes.iter().enumerate()?{
????????if?item?==?b'?'?{
????????????return?&s[..?index];
????????}
????}
????&s[..]
}

fn?main()?{
????let?mut?s?=?String::from("hello?world");
????let?word?=?first_word(&s);
????s.clear();
????println!("{}",?word);?
}

上述代碼執(zhí)行會報錯：

錯誤很明顯，s 已經作為不可變引用被借用了，因此不能再作為可變引用被借用。

那么問題來了，s 作為不可變引用借給誰了呢？顯然是 word，因為它是字符串切片，是指向字符串的不可變引用；然后又是誰想要借 s 的可變引用呢？顯然是 s.clear()，由于 clear 需要截斷當前的 String 實例，所以調用 clear 需要傳入一個可變引用。

因此最終編譯失敗，所以 Rust 不僅使我們的 API 更加易用，它還在編譯過程中幫助我們避免了此類錯誤。

字符串字面量就是切片

還記得我們講的字符串字面量嗎？它是直接存儲在了二進制程序中。在學習了切片之后，我們現在可以更恰當地理解字符串字面量了。

let?s?=?"hello?world";

在這里，變量 s 的類型其實就是 &str：它是一個指向二進制程序特定位置的切片。正是由于&str是一個不可變的引用，所以字符串字面量是不可變的。

字符串切片作為參數

既然我們可以分別創(chuàng)建字符串字面量和 String 的切片，那么就能夠進一步優(yōu)化 first_word 函數的接口，下面是它目前的簽名：

fn?first_word(s:?&String)?->?&str

比較有經驗的 Rust 開發(fā)者往往會采用下面的寫法，這種改進后的簽名使得函數可以同時處理 &String 與 &str：

fn?first_word(s:?&str)?->?&str

總結：當函數參數類型為 &String，那么只能傳 String 的引用，不可以傳切片；如果參數類型為 &str，那么既可以傳 String 的引用，也可以傳切片。說白了，在 String 類型的值前面加上一個 & 就表示 String 的引用（&String），而在引用的基礎之上，在后面再加上 [..]，那么就表示字符串切片（&str）。

let?s1?=?String::from("hello?world");
//?合法，&str?支持字符串引用
let?s2:?&str?=?&s1;??
//?合法，&str?支持字符串切片，因為本身就是字符串切片類型
let?s2:?&str?=?&s1[..];??
//?合法，字符串字面量本身就是一個不可變的字符串切片
let?s2:?&str?=?"hello?world";??
//?以上三者等價，因為?&str?既可以接收?&String，也可以接收?&str

let?s3:?&String?=?&s1;??//?合法
let?s3:?&String?=?&s1[..];??//?不合法
let?s3:?&String?=?"hello?world";??//?不合法
//?因為?&String?只能接收?&String，不能接收?&str

//?最后，字符串切片雖然能接收?String?的引用，但?String?是無法接收的
//?不合法，&str?只能接收?&str、&String，無法接收?String
let?s2:?&str?=?s1;??

因此我們在設計函數時，使用字符串切片來代替字符串引用會使我們的 API 更加通用，且不會損失任何功能。

其它類型的切片

從名字上就可以看出來，字符串切片是專門用于字符串的。但實際上，Rust 還有其他更加通用的切片類型，以下面的數組為例：

let?a?=?[1,?2,?3,?4,?5];?

就像我們想要引用字符串的某個部分一樣，你也可能會希望引用數組的某個部分。這時，我們可以這樣做：

let?a?=?[1,?2,?3,?4,?5];
let?slice?=?&a[1..3];

這里的切片類型是 &[i32]，它在內部存儲了一個指向起始元素的引用及長度，這與字符串切片的工作機制完全一樣。并且我們將在各種各樣的集合中接觸到此類切片，而在后續(xù)討論動態(tài)數組時再來介紹那些常用的集合。

以上就是深入了解Rust的切片使用的詳細內容，更多關于Rust切片的資料請關注腳本之家其它相關文章！

最新評論