返回文章列表
玄貓（BlackCat）

Rust 實戰：運用所有權與切片打造文字處理器

本文深入探討如何運用 Rust 語言建構一個實用的文字處理器。透過實作計算單詞、尋找首詞及反轉句子等功能，文章具體展示了 Rust 核心概念的應用，特別是所有權（Ownership）、借用（Borrowing）與字串切片（Slices）在實際程式設計中的重要性。此專案不僅是程式碼的堆砌，更是一個將抽象理論轉化為具體解決方案的實踐過程，有助於開發者深化對 Rust 記憶體安全機制的理解。

軟體工程 程式設計
Rust 所有權 借用 切片 字串處理

在軟體工程的進階實踐中，將抽象的程式語言理論應用於具體專案是深化理解的關鍵。本文以 Rust 語言為基礎，透過建構一個簡單的文字處理器，系統性地演繹其核心設計哲學。此專案不僅是功能實現，更是對 Rust 所有權系統、借用規則及生命週期概念的實戰演練。從處理用戶輸入、操作字串切片，到設計模組化函數，每一步都旨在突顯 Rust 如何在不犧牲效能的前提下保證記憶體安全。讀者將從中學習如何將 String 與 &str 之間的轉換、Option 型別的錯誤處理，以及迭代器的靈活運用整合於一個連貫的應用程式中，從而建立起從理論到實戰的穩固橋樑。

軟體工程師的進階修煉：從抽象化到實戰應用的全面提升

第三章：理解所有權與借用 (Understanding Ownership and Borrowing)

引用與借用 (References and Borrowing)

  • RefCell 類型提供內部可變性，即使 Rc 提供共享所有權，也允許修改 Rc 內的值。
  • 這種組合確保程式的多個部分可以安全地讀取和修改資料，而不會違反程式語言的所有權規則。

構建一個簡單的文字處理器 (Building a Simple Text Processor in Rust)

在這個專案中，我們將創建一個簡單的文字處理器，它從用戶那裡讀取一個句子並執行多個操作：

  • 計算輸入中的單詞數量。
  • 找到並顯示第一個單詞。
  • 反轉句子中的單詞。

這個專案將整合前面章節中討論的許多概念，例如所有權、借用、切片和用戶輸入處理。讓我們一步一步地走過程式碼，邊思考邊進行。

1. 設定主函數 (Setting Up the Main Function)

首先，我們需要設定主函數，它是程式的入口點。

fn main() {
// 程式碼將放在這裡
}

2. 讀取用戶輸入 (Reading User Input)

我們想從用戶那裡讀取一個句子。我們將使用 std::io 模組進行輸入。

use std::io;
fn main() {
println!("請輸入一個句子:");
let mut input = String::new();
io::stdin()
.read_line(&mut input)
.expect("讀取行失敗");
}

在這裡，我們：

  • 導入 io 模組。
  • 提示用戶輸入一個句子。
  • 創建一個名為 input 的可變 String 來儲存用戶的輸入。
  • 使用 io::stdin().read_line(&mut input) 讀取輸入，傳遞對 input 的可變引用。
  • 使用 expect 處理任何潛在錯誤。

玄貓需要一種從用戶那裡獲取輸入的方法，所以將使用 read_line 將一整行文字讀入一個可變 String。玄貓還需要處理輸入過程中可能發生的任何錯誤。

3. 修剪輸入 (Trimming the Input)

從輸入中刪除任何前導或尾隨空格是一個好主意。

let trimmed_input = input.trim();

trimmed_input 是一個字串切片 (&str)，它引用 input 的內容，沒有任何額外的空格。

用戶可能會不小心在輸入的開頭或結尾包含空格。透過修剪，玄貓確保程式正確處理文字。

4. 計算單詞 (Counting Words)

我們需要計算輸入中的單詞數量。玄貓將創建一個 count_words 函數。

fn count_words(s: &str) -> usize {
s.split_whitespace().count()
}

在 main 函數中，玄貓將呼叫此函數：

// 計算單詞數量
let word_count = count_words(trimmed_input);
println!("單詞數量: {}", word_count);
  • count_words 函數接受一個字串切片 &str 並返回一個表示單詞數量的 usize。
  • 它使用 split_whitespace() 將字串分割成一個單詞迭代器，由空格分隔。
  • count() 方法計算迭代器中有多少個項目。

為了計算單詞，玄貓可以透過空格分割輸入文字。

5. 尋找第一個單詞 (Finding the First Word)

接下來，玄貓想提取輸入的第一個單詞。玄貓將編寫一個 get_first_word 函數。

fn get_first_word(s: &str) -> Option<&str> {
s.split_whitespace().next()
}

在 main 函數中，玄貓將呼叫此函數：

// 尋找第一個單詞
if let Some(first_word) = get_first_word(trimmed_input) {
println!("第一個單詞: {}", first_word);
} else {
println!("沒有找到單詞。");
}
  • get_first_word 函數返回一個 Option<&str>。如果至少有一個單詞，它將是 Some(&str)，如果輸入為空，則為 None。
  • 在 main 函數中，玄貓使用 if let 檢查 get_first_word 是否返回 Some，然後印出第一個單詞。
  • 使用 Option 允許玄貓處理輸入可能為空的情況。透過 split_whitespace().next()，玄貓可以輕鬆獲得第一個單詞而無需額外解析。

6. 反轉句子 (Reversing the Sentence)

玄貓想反轉句子中的單詞。玄貓將創建一個 reverse_sentence 函數。

fn reverse_sentence(s: &str) -> String {
let words: Vec<&str> = s.split_whitespace().collect();
let reversed_words: Vec<&str> = words.into_iter().rev().collect();
reversed_words.join(" ")
}

在 main 函數中，玄貓將呼叫此函數：

// 反轉句子
let reversed = reverse_sentence(trimmed_input);
println!("反轉後的句子: {}", reversed);
  • reverse_sentence 函數接受一個字串切片並返回一個新的 String。
  • 它將輸入分割成單詞並將它們收集到一個 Vec<&str> 中。

玄貓認為，這個文字處理器專案是一個極佳的實踐案例，它將程式語言的核心概念，如所有權、借用和切片，以實用且連貫的方式整合起來。從用戶輸入的處理到字串操作，每一步都體現了程式語言在記憶體安全和效能方面的優勢。

@startuml
!define DISABLE_LINK
!define PLANTUML_FORMAT svg
!theme _none_

skinparam dpi auto
skinparam shadowing false
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 100

package "程式語言文字處理器專案" {
node "專案目標與概念" as ProjectGoals {
component "讀取用戶輸入句子" as ReadSentence
component "計算單詞數量" as CountWords
component "尋找並顯示第一個單詞" as FindFirstWord
component "反轉句子中的單詞" as ReverseSentence
component "整合所有權、借用、切片、輸入處理" as IntegrateConcepts
}

node "程式結構與輸入處理" as ProgramStructureInput {
component "主函數 `fn main()`" as MainFunction
component "導入 `std::io` 模組" as ImportIO
component "提示用戶輸入" as PromptUser
component "創建可變 `String` 儲存輸入" as MutableStringInput
component "使用 `io::stdin().read_line()` 讀取" as ReadLine
component "處理錯誤 `expect(\"讀取行失敗\")`" as HandleErrors
component "修剪輸入 `input.trim()`" as TrimInput
component "`trimmed_input` 為字串切片 (`&str`)" as TrimmedInputIsSlice
}

node "單詞操作函數" as WordOperationFunctions {
component "計算單詞函數 `fn count_words(s: &str) -> usize`" as CountWordsFunc
component "使用 `s.split_whitespace().count()`" as SplitCount
component "尋找第一個單詞函數 `fn get_first_word(s: &str) -> Option<&str>`" as GetFirstWordFunc
component "使用 `s.split_whitespace().next()`" as SplitNext
component "處理空輸入 (返回 `Option`)" as HandleEmptyInputOption
component "反轉句子函數 `fn reverse_sentence(s: &str) -> String`" as ReverseSentenceFunc
component "分割單詞到 `Vec<&str>`" as SplitToVec
component "反轉 `Vec` 中的單詞" as ReverseVecWords
component "使用 `join(\" \")` 組合回 `String`" as JoinToString
}

ProjectGoals --> ReadSentence
ProjectGoals --> CountWords
ProjectGoals --> FindFirstWord
ProjectGoals --> ReverseSentence
ProjectGoals --> IntegrateConcepts

ProgramStructureInput --> MainFunction
ProgramStructureInput --> ImportIO
ProgramStructureInput --> PromptUser
ProgramStructureInput --> MutableStringInput
ProgramStructureInput --> ReadLine
ProgramStructureInput --> HandleErrors
ProgramStructureInput --> TrimInput
ProgramStructureInput --> TrimmedInputIsSlice

WordOperationFunctions --> CountWordsFunc
WordOperationFunctions --> SplitCount
WordOperationFunctions --> GetFirstWordFunc
WordOperationFunctions --> SplitNext
WordOperationFunctions --> HandleEmptyInputOption
WordOperationFunctions --> ReverseSentenceFunc
WordOperationFunctions --> SplitToVec
WordOperationFunctions --> ReverseVecWords
WordOperationFunctions --> JoinToString

ProjectGoals -[hidden]-> ProgramStructureInput
ProgramStructureInput -[hidden]-> WordOperationFunctions
}

@enduml

看圖說話：

此圖示詳細描繪了程式語言文字處理器專案的架構與核心功能。在專案目標與概念部分，它概述了專案的四大主要任務：讀取用戶輸入句子、計算單詞數量、尋找並顯示第一個單詞以及反轉句子中的單詞，並強調了整合所有權、借用、切片和輸入處理等程式語言核心概念的重要性。程式結構與輸入處理部分則詳細展示了從主函數 fn main() 開始，如何導入 std::io 模組，提示用戶輸入，創建可變 String 儲存輸入，使用**io::stdin().read_line() 讀取**，並處理錯誤。特別提到修剪輸入 input.trim() 後，trimmed_input 是一個字串切片 (&str)。最後，單詞操作函數部分則定義了三個核心函數：count_words 函數利用**s.split_whitespace().count()** 計算單詞；get_first_word 函數透過**s.split_whitespace().next()** 尋找第一個單詞並處理空輸入（返回 Option）；而**reverse_sentence 函數則通過分割單詞到 Vec<&str>，反轉 Vec 中的單詞，再使用 join(" ") 組合回 String** 來實現句子反轉。整個流程清晰地展示了一個實用的程式語言應用如何被構建。

結論：從理論到直覺的工程師修煉之路

評估此發展路徑的長期效益後，這個看似基礎的文字處理器專案，實則揭示了軟體工程師從理論知識邁向實戰能力的關鍵躍遷。它不僅是語法功能的堆疊，更是對程式語言核心哲學——所有權與借用——的深度實踐。傳統學習常止於概念理解，但此專案迫使開發者在處理用戶輸入、字串切片及資料轉換的每個環節，都必須直面記憶體安全與效能的權衡。從 read_line 傳遞可變引用，到 get_first_word 返回 Option<&str> 以優雅處理空值，這些設計選擇將抽象的編譯期檢查，轉化為具體的、穩固的工程直覺。

這種從「知道規則」到「善用規則」的轉變，正是區分資深與中階工程師的核心指標。在未來系統級應用、高併發服務與嵌入式開發等領域，能夠本能地寫出兼具安全與效率程式碼的能力，將成為不可或缺的競爭優勢。

玄貓認為，此專案不僅是技術練習，更是將程式語言哲學內化為工程思維的關鍵修煉。對於追求技術卓越的軟體工程師而言，完成這類整合性實作，是從「會寫」到「精通」的必經淬鍊過程。