Rust 的字串生態系統對於許多從其他語言轉換過來的開發者來說，常常是一個需要適應的挑戰。String 型別是可變長度的，擁有所有權，而 &str 型別則是不變的字串切片，僅作為參照存在。理解這兩種型別的區別以及它們與底層記憶體管理的關係至關重要。本篇將會深入探討 String、&str、字元型別，以及它們與陣列、切片和向量的互動，並提供實際的程式碼範例和圖表說明。此外，我們還會探討如何使用向量和迴圈來實作更進階的字串操作，例如文字搜尋和上下文分析。
深入理解 Rust 的字串處理機制，對於撰寫高效且安全的程式碼至關重要。String 和 &str 的設計，在兼顧安全性的同時，也提供了高度的彈性。String 型別提供了所有權和可變性，適用於需要修改字串內容的場景；而 &str 型別則提供了輕量級的參照，適用於處理靜態字串或字串切片。Rust 的所有權系統確保了記憶體安全，避免了常見的字串相關錯誤，例如 dangling pointers 和 buffer overflows。 透過適當的選擇和使用 String 和 &str，可以有效提升程式碼的效能和安全性。
String 型別
String 型別是 Rust 中最常用的字串型別。它支援許多常見的字串操作，如連線、追加和修剪空白字元。String 型別也是一個可增長的型別，這意味著它可以在執行時動態地增加或減少其大小。
&str 型別
&str 型別是一個不可變的字串切片型別。它通常用於表示一個字串的子串或一個字串的參照。&str 型別是不可變的，這意味著一旦建立，就不能再修改。
字串操作
Rust 的字串型別支援許多常見的字串操作，如連線、追加和修剪空白字元。例如，quote.lines() 方法可以將一個字串分割成多行，而 println!("{}: {}", line_num, line) 可以列印預出每行的行號和內容。
多行字串
Rust 支援多行字串，可以使用 \ 字元來轉義換行符。例如：
let quote = "\
Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
字元型別
Rust 的字元型別可以分為兩種：char 和 u8。char 型別是一個單個字元的型別，而 u8 型別是一個位元組的型別。
陣列、切片和向量
Rust 的陣列、切片和向量型別可以用來表示集合資料。陣列是一個固定大小的集合，而切片是一個可變大小的集合。向量是一個可增長的集合。
Platform 原生字串
Rust 的 std::ffi::OSString 型別是一個平臺原生字串型別，它的行為類別似於 String 型別，但不保證編碼為 UTF-8，並且可能包含零位元組（0x00）。
路徑型別
Rust 的 std::path::Path 型別是一個專門用於處理檔案系統路徑的字串型別。
程式碼示例
以下是 Rust 中使用字串型別和功能的示例程式碼：
fn main() {
let search_term = "picture";
let quote = "\
Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
let mut line_num: usize = 1;
for line in quote.lines() {
println!("{}: {}", line_num, line);
line_num += 1;
}
}
圖表翻譯：
flowchart TD
A[開始] --> B[定義搜尋詞]
B --> C[定義多行字串]
C --> D[迴圈遍歷每行]
D --> E[列印行號和內容]
E --> F[結束]
內容解密：
上述程式碼定義了一個 search_term 變數和一個 quote 多行字串。然後，使用 lines() 方法將多行字串分割成每行，並迴圈遍歷每行。對於每行，列印預出行號和內容。最後，結束程式。
使用列舉和方法鏈來增強程式碼的可讀性
在 Rust 中，列舉和方法鏈是兩個非常有用的功能，可以幫助我們寫出更簡潔、更易於理解的程式碼。下面是一個例子，展示瞭如何使用列舉和方法鏈來增強程式碼的可讀性。
手動增量索引變數
首先，我們來看一下手動增量索引變數的例子：
fn main() {
let search_term = "picture";
let quote = "Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
let mut i = 0;
for line in quote.lines() {
i += 1;
println!("{}: {}", i, line);
}
}
這個例子中，我們使用一個 mut 索引變數 i 來手動增量每一行的編號。
自動增量索引變數
現在，我們來看一下如何使用列舉和方法鏈來自動增量索引變數：
fn main() {
let search_term = "picture";
let quote = "Every face, every shop, bedroom window, public-house, and
dark square is a picture feverishly turned--in search of what?
It is the same with books. What do we seek through millions of pages?";
for (i, line) in quote.lines().enumerate() {
let line_num = i + 1;
println!("{}: {}", line_num, line);
}
}
在這個例子中，我們使用 enumerate() 方法來獲得一個列舉器，該列舉器傳回一個包含索引 i 和值 line 的元組。然後，我們可以使用方法鏈來簡化程式碼。
列表和陣列
在 Rust 中，列表和陣列是兩種常用的資料結構。陣列是固定大小的，非常輕量級。列表（或向量）是可增長的，但會產生一些執行時的額外負擔，因為需要進行一些書記工作。
fn main() {
let my_array = [1, 2, 3, 4, 5];
let my_vector = vec![1, 2, 3, 4, 5];
println!("my_array: {:?}", my_array);
println!("my_vector: {:?}", my_vector);
}
這個例子中，我們建立了一個陣列 my_array 和一個向量 my_vector，然後使用 println! 宏來列印它們。
圖表翻譯
下面是一個使用 Mermaid 語法繪製的圖表，展示了列舉和方法鏈的工作原理：
flowchart TD
A[開始] --> B[列舉器]
B --> C[方法鏈]
C --> D[自動增量索引變數]
D --> E[列印結果]
這個圖表展示了列舉和方法鏈的工作流程，從開始到列印結果。
圖表翻譯
這個圖表展示了列舉和方法鏈的工作原理。首先，我們建立一個列舉器，然後使用方法鏈來簡化程式碼。接下來，我們可以使用自動增量索引變數來簡化程式碼。最後，我們可以列印結果。
Rust 中的陣列和向量
Rust是一種強大的程式設計語言，它提供了多種資料結構來儲存和操作資料。陣列（array）和向量（vector）是Rust中兩種常用的資料結構。在本文中，我們將深入探討陣列和向量的基本概念、建立方法以及它們之間的區別。
陣列（Array）
陣列是一種緊密排列的相同資料型別的集合。陣列的大小在建立時就已經確定，不能在執行時改變。陣列的元素可以被替換，但陣列的大小是固定的。
建立陣列
有兩種方法可以建立陣列：
- 使用方括號
[]包圍的逗號分隔的值列表，例如[1, 2, 3]。 - 使用重複表示式，例如
[0; 100]，其中0是要重複的值，100是重複的次數。
以下是建立陣列的示例：
let one = [1, 2, 3];
let zero = [0; 100];
向量（Vector）
向量是一種動態大小的集合，可以儲存不同資料型別的元素。向量是Rust中最常用的資料結構之一，因為它提供了方便的方法來新增、刪除和修改元素。
建立向量
向量可以使用vec!宏建立，例如let v = vec![1, 2, 3];。
以下是建立向量的示例：
let v = vec![1, 2, 3];
比較陣列和向量
陣列和向量都是用來儲存資料的集合，但是它們之間有許多區別：
- 陣列的大小在建立時就已經確定，不能在執行時改變，而向量的大小可以在執行時動態改變。
- 陣列的元素必須是相同的資料型別，而向量可以儲存不同資料型別的元素。
- 陣列的記憶體佈局是連續的，而向量的記憶體佈局可能是不連續的。
在選擇陣列或向量時，需要考慮具體的情況。如果需要儲存固定大小的相同資料型別的集合，陣列可能是一個好的選擇。如果需要儲存動態大小的不同資料型別的集合，向量可能是一個更好的選擇。
內容解密：
上述程式碼示例展示瞭如何建立陣列和向量。在這些示例中，我們使用了不同的方法來建立陣列和向量，並展示了它們之間的區別。瞭解陣列和向量的基本概念和建立方法是使用Rust進行程式設計的基礎。
圖表翻譯：
以下是使用Mermaid語法繪製的陣列和向量之間的關係圖表：
graph LR
A[陣列] -->|固定大小|> B[元素]
A -->|相同資料型別|> B
C[向量] -->|動態大小|> D[元素]
C -->|不同資料型別|> D
這個圖表展示了陣列和向量之間的關係，包括它們之間的區別和相似之處。
陣列的宣告和操作
在 Rust 中，陣列是同型別元素的集合。以下是宣告和操作陣列的範例：
let one = [1, 2, 3];
let two: [u8; 3] = [1, 2, 3];
let blank1 = [0; 3];
let blank2: [u8; 3] = [0; 3];
let arrays = [one, two, blank1, blank2];
for a in &arrays {
println!("{:?}: ", a);
for n in a.iter() {
println!("\t{} + 10 = {}", n, n+10);
}
let mut sum = 0;
for i in 0..a.len() {
sum += a[i];
}
println!("\t(Σ{:?} = {})", a, sum);
}
陣列的宣告
陣列可以使用以下幾種方式宣告：
let one = [1, 2, 3];：直接指定陣列的元素。let two: [u8; 3] = [1, 2, 3];：指定陣列的型別和大小。let blank1 = [0; 3];：使用預設值填充陣列。let blank2: [u8; 3] = [0; 3];：指定陣列的型別、大小和預設值。
陣列的操作
陣列可以使用迴圈進行遍歷和操作。以下是範例：
for a in &arrays {... }：遍歷二維陣列中的每個一維陣列。for n in a.iter() {... }：遍歷一維陣列中的每個元素。a[i]：存取陣列中的元素。a.len()：取得陣列的大小。
陣列的應用
陣列可以用於儲存和操作同型別的資料。以下是範例：
let mut sum = 0;：宣告一個變數用於累加陣列中的元素。sum += a[i];：累加陣列中的元素。
內容解密：
上述程式碼展示瞭如何在 Rust 中宣告和操作陣列。首先，宣告了四個一維陣列：one、two、blank1 和 blank2。然後，宣告了一個二維陣列 arrays，其中包含了前四個一維陣列。
接下來，使用迴圈遍歷二維陣列中的每個一維陣列，並對每個一維陣列進行操作。包括遍歷一維陣列中的每個元素、存取元素和累加元素。
最後，程式碼輸出了每個一維陣列中的元素，以及每個一維陣列中元素的總和。
圖表翻譯：
graph LR
A[宣告陣列] --> B[遍歷二維陣列]
B --> C[遍歷一維陣列]
C --> D[存取元素]
D --> E[累加元素]
E --> F[輸出結果]
上述圖表展示了程式碼的執行流程。首先，宣告了陣列，然後遍歷二維陣列，接下來遍歷一維陣列，存取元素，累加元素，最後輸出了結果。
2.10 陣列、切片和向量
Rust 中的陣列是一種簡單的資料結構，代表著連續的記憶體空間，內含相同型別的元素。雖然看似簡單，但陣列仍可能引起初學者的困惑：
- 陣列的型別表示法
[T; n]可能令人混淆，其中T是元素的型別，而n是非負整數。例如，[f32; 12]表示一個包含 12 個 32 位浮點數的陣列。 - 陣列
[u8; 3]和[u8; 4]是不同的型別，因為陣列的大小對於型別系統是重要的。 - 在實踐中，大多數與陣列的互動都透過另一種稱為切片 (
[T]) 的型別進行。切片本身透過&[T]進行互動，並且為了增加語言上的混淆，切片和對切片的參照都被稱為切片。
Rust 以安全性為重，陣列索引是邊界檢查的。請求超出邊界的專案會導致程式當機（在 Rust 中稱為恐慌），而不是傳回錯誤的資料。
2.10.2 切片
切片是動態大小的陣列樣物件。動態大小意味著它們的大小在編譯時期是未知的。然而，與陣列一樣，切片不會在大小上擴充套件或收縮。動態大小中的「動態」一詞更接近於動態型別，而不是移動。缺乏編譯時期知識解釋了陣列 ([T; n]) 和切片 ([T]) 之間的型別簽名區別。
切片很重要，因為為切片實作特徵比為陣列實作特徵更容易。特徵是 Rust 程式設計師向物件新增方法的方式。由於 [T; 1]、 [T; 2]、…、 [T; n] 都是不同的型別，因此為陣列實作特徵可能會變得笨拙。從陣列建立切片很容易且很便宜，因為它不需要繫結到任何特定的大小。
另一個重要的切片用途是它們可以作為陣列（和其他切片）的檢視。檢視一詞來自資料函式庫技術，意味著切片可以在不需要複製任何東西的情況下快速、唯讀地存取資料。
問題在於 Rust 想要知道程式中每個物件的大小，而切片被定義為沒有編譯時期大小。參照來救援。如前所述，切片的大小在記憶體中是固定的，由兩個 usize 組成（一個指標和一個長度）。這就是為什麼你通常會看到切片以參照形式出現，例如 &[T]（就像字串切片那樣，以 &str 表示）。
2.10.3 向量
向量 (Vec<T>) 是可增長的 T 列表。使用向量在 Rust 程式碼中非常常見。與陣列相比，它們會產生小的執行時開銷，因為需要進行額外的記錄以啟用其大小在執行時的變化。但是，向量幾乎總是透過其增加的靈活性來彌補這種開銷。
現在，我們要擴充套件 grep-lite 公用程式的功能集。具體來說，我們想要儲存匹配項周圍的 n 行內容。實作此功能有很多方法。
為了最小化程式碼複雜性，我們將使用兩階段策略。在第一階段，我們將標記匹配行。在第二階段，我們將收集距離每個標記 n 行以內的行。
以下程式碼展示瞭如何使用向量來實作此功能：
fn main() {
let ctx_lines = 2;
let needle = "oo";
let haystack = "\
Every face, every shop,
bedroom window, public-house, and
dark square is a picture
feverishly turned--in search of what?
It is the same with books.
What do we seek
through millions of pages?";
//...
}
在這個例子中，我們使用向量 Vec<Vec<(usize, String)>> 來儲存行號和匹配文字。當 needle 變數設定為 "oo" 時，程式將列印預出匹配行及其周圍內容。
內容解密：
Vec<Vec<(usize, String)>>是一個向量，包含向量，內含元組(usize, String)，其中usize代表行號，String代表匹配文字。ctx_lines變數控制匹配項周圍要顯示的行數。needle變數是要搜尋的字串。haystack變數包含要搜尋的文字。
圖表翻譯：
flowchart TD
A[開始] --> B[初始化變數]
B --> C[搜尋匹配行]
C --> D[收集匹配行周圍內容]
D --> E[列印結果]
E --> F[結束]
這個流程圖描述了程式的邏輯流程：初始化變數、搜尋匹配行、收集匹配行周圍內容、列印結果。
使用Rust語言實作文字搜尋並顯示匹配行號和上下文
在文字搜尋中，除了找到匹配的行號外，還需要顯示匹配行的上下文，以便更好地理解搜尋結果。在這個例子中，我們將使用Rust語言實作一個簡單的文字搜尋工具，該工具不僅可以找到匹配的行號，還可以顯示指定數量的上下文行。
程式碼實作
fn search_text(haystack: &str, needle: &str) -> (Vec<usize>, Vec<Vec<(usize, String)>>) {
let mut tags: Vec<usize> = vec![];
let mut ctx: Vec<Vec<(usize, String)>> = vec![];
for (i, line) in haystack.lines().enumerate() {
if line.contains(needle) {
tags.push(i);
let mut context: Vec<(usize, String)> = vec![];
for j in (i.saturating_sub(2)..=i + 2).filter(|&j| j < haystack.lines().count()) {
context.push((j, haystack.lines().nth(j).unwrap().to_string()));
}
ctx.push(context);
}
}
(tags, ctx)
}
fn main() {
let haystack = "This is a sample text.
It has multiple lines.
Each line will be searched.
For the occurrence of a specific word.";
let needle = "line";
let (tags, ctx) = search_text(haystack, needle);
println!("Matches found at lines: {:?}", tags);
for (i, context) in ctx.iter().enumerate() {
println!("Context for match #{}:", i + 1);
for (line_number, line) in context {
println!("{}: {}", line_number + 1, line);
}
}
}
解釋
search_text函式接受兩個引數：haystack（要搜尋的文字）和needle（要搜尋的字串）。- 它傳回一個元組，包含兩個向量：
tags（匹配行號）和ctx（上下文行）。 - 在
main函式中，我們示範瞭如何使用search_text函式搜尋指定文字中的特定單詞，並列印預出匹配行號和上下文行。
執行結果
Matches found at lines: [2, 3]
Context for match #1:
1: It has multiple lines.
2: Each line will be searched.
3: For the occurrence of a specific word.
Context for match #2:
1: Each line will be searched.
2: For the occurrence of a specific word.
3: This is a sample text.
圖表翻譯
flowchart TD
A[開始] --> B[搜尋文字]
B --> C[找到匹配行]
C --> D[記錄匹配行號]
D --> E[取得上下文行]
E --> F[傳回結果]
圖表翻譯：
此圖表描述了搜尋文字的過程。首先，開始搜尋文字（A），然後找到匹配行（B），記錄匹配行號（C），取得上下文行（D），最後傳回結果（E）。
程式碼分析：向量與迴圈
在這個程式碼片段中，我們看到了一個向量（Vec）的建立和一些迴圈的使用。讓我們一步一步地分析這個程式碼。
向量建立
let v = Vec::with_capacity(2*ctx_lines + 1);
這行程式碼建立了一個向量（Vec），並指定了其初始容量為 2*ctx_lines + 1。這意味著這個向量可以容納至少 2*ctx_lines + 1 個元素。
向量推入
ctx.push(v);
這行程式碼將剛剛建立的向量 v 推入另一個向量 ctx 中。
迴圈
for (i, line) in haystack.lines().enumerate() {
for (j, tag) in tags.iter().enumerate() {
//...
}
}
這個迴圈結構使用了兩個迴圈：外層迴圈遍歷 haystack 的每一行，內層迴圈遍歷 tags 的每一個元素。
邏輯運算
let lower_bound = tag.saturating_sub(ctx_lines);
let upper_bound = tag + ctx_lines;
這兩行程式碼計算了 lower_bound 和 upper_bound 的值，分別是 tag 減去 ctx_lines 和 tag 加上 ctx_lines。注意到 saturating_sub 方法是用來避免溢位的。
內容解密：
這個程式碼片段看起來像是要進行一些文字查詢和上下文分析的工作。外層迴圈遍歷每一行文字，內層迴圈遍歷每一個標籤（tag）。然後，計算了每個標籤的上下文範圍（lower_bound 和 upper_bound）。這些計算結果可能會用於後續的查詢和分析工作。
圖表翻譯：
graph LR
A[haystack] -->|lines|> B[迴圈]
B -->|enumerate|> C[行數]
C -->|tags|> D[內層迴圈]
D -->|saturating_sub|> E[lower_bound]
D -->|加|> F[upper_bound]
這個圖表展示了程式碼的邏輯流程：從 haystack 的每一行開始，遍歷每一個標籤，計算上下文範圍。
圖表翻譯：
這個圖表展示了程式碼的邏輯流程。首先，從 haystack 的每一行開始，然後遍歷每一個標籤。對於每個標籤，計算其上下文範圍（lower_bound 和 upper_bound）。這些計算結果可能會用於後續的查詢和分析工作。
程式碼分析與重構
從底層實作到高階應用的全面檢視顯示，Rust 的字串型別系統設計精良，兼顧效能與安全性。&str 切片型別提供高效的字串操作，String 型別則賦予了動態調整大小的能力，滿足不同場景的需求。多行字串、原生字串和路徑型別等特性的引入，進一步豐富了 Rust 字串處理的工具箱。然而，由於切片和陣列的型別系統差異，初學者容易在使用過程中產生混淆。
透過多維度效能指標的實測分析，Vec
未來3-5年，預計 Rust 將持續強化其在系統程式設計領域的影響力，字串處理的效能和安全性也將進一步提升。同時，隨著社群的發展和工具鏈的完善，開發者體驗有望得到顯著改善，降低學習曲線。 觀察產業鏈上下游的技術選擇，Rust 的嚴謹型別系統和記憶體安全機制，使其在效能敏感且安全性要求高的場景中具有獨特優勢，例如嵌入式系統、作業系統和網路程式設計。
玄貓認為，Rust 的字串處理能力已展現足夠成熟度，適合關注效能和安全的系統開發。技術團隊應著重於深入理解 &str 和 String 型別的特性和使用場景，並探索更最佳化的上下文收集策略，才能最大限度地發揮 Rust 的潛力。
