Rust 程式設計入門：基礎語法、結構與進階應用

Rust 作為一門現代系統程式語言，兼具效能和安全性。其所有權系統和借用規則有效地防止了記憶體安全問題，同時又不犧牲效能。本文將從 Rust 的基礎語法開始，逐步深入至更進階的程式設計概念。首先，我們會介紹 Rust 的基本資料型別、函式定義、控制流程，以及如何使用迭代和數學運算。接著，會說明 Rust 程式碼的組織結構，包括模組、crate 和 Cargo 工具的使用。更進一步，將探討 Rust 中的複合資料型別，如結構體和列舉，以及如何利用方法和特徵來組織程式碼。最後，將會介紹 Rust 的錯誤處理機制和一些進階技巧，例如新型別模式的應用。

圖表翻譯

  flowchart TD
    A[開始] --> B[解析引數]
    B --> C[建立正規表示式]
    C --> D[讀取輸入]
    D --> E[處理文字行]
    E --> F[搜尋模式]
    F --> G[列印匹配行]

圖表翻譯

此圖表描述了程式的流程：

開始：程式啟動。
解析引數：解析命令列引數，取得使用者輸入的模式和檔案或標準輸入。
建立正規表示式：根據使用者提供的模式建立正規表示式。
讀取輸入：根據使用者提供的輸入，決定是讀取標準輸入還是檔案。
處理文字行：遍歷每一行文字，並進行搜尋。
搜尋模式：使用正規表示式搜尋文字行。
列印匹配行：如果搜尋到匹配的行，則列印預出該行。

Rust程式設計基礎

Rust是一種強大的程式設計語言，提供了多種功能以支援程式設計，包括原始型別、函式、迭代和數學運算等。以下是Rust的一些基礎知識。

原始型別

Rust支援多種原始型別，例如整數和浮點數。這些型別是程式設計的基礎，可以用來表示數值、布林值等。

函式

Rust的函式是強型別的，需要指定引數和傳回值的型別。這可以幫助程式設計師避免型別相關的錯誤。

迭代和數學運算

Rust的迭代和數學運算功能依賴於特徵（traits）。例如，for迴圈是std::iter::IntoIterator特徵的簡寫。

列表型別

Rust提供了多種列表型別，每種都有其特定的用途。例如，Vec<T>是最常用的列表型別。

Rust程式結構

Rust程式的結構包括以下幾個部分：

主函式

每個Rust程式都有一個主函式（main），這是程式的入口點。

Cargo.toml檔案

每個Rust crate都有一個Cargo.toml檔案，該檔案指定了crate的資訊。

Cargo工具

Cargo工具可以編譯程式碼並下載其依賴項。

Rustup工具

Rustup工具提供了多種編譯器工具鏈和語言檔案的存取許可權。

複合資料型別

複合資料型別是Rust程式設計的基礎，包括結構體（struct）和列舉（enum）等。這些型別可以組合其他型別以建立更有用的型別。

結構體

結構體是一種複合資料型別，可以包含多個欄位。例如，2D點（x，y）可以由兩個數字x和y組成。

列舉

列舉是一種特殊的結構體，可以定義一組具名的值。

方法和錯誤處理

Rust提供了方法（method）和錯誤處理（error handling）機制，以支援程式設計師定義和實作共同行為。

方法

方法是結構體或列舉上的函式，可以用來定義和實作共同行為。

錯誤處理

Rust提供了多種錯誤處理機制，包括Result和Option等，可以用來處理程式執行中的錯誤。

特徵

特徵（trait）是Rust的一種重要功能，可以定義和實作共同行為。特徵可以用來定義一組方法和相關聯的型別。

內容解密：

上述內容介紹了Rust程式設計的基礎知識，包括原始型別、函式、迭代和數學運算等。同時，也介紹了Rust程式的結構，包括主函式、Cargo.toml檔案、Cargo工具和Rustup工具等。另外，還介紹了複合資料型別，包括結構體和列舉等，並且討論了方法和錯誤處理機制，以及特徵的定義和實作。

// 定義一個2D點的結構體
struct Point {
    x: f64,
    y: f64,
}

// 實作Point結構體上的方法
impl Point {
    fn new(x: f64, y: f64) -> Point {
        Point { x, y }
    }

    fn distance(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    // 建立一個2D點
    let point = Point::new(3.0, 4.0);

    // 計算點與原點的距離
    let distance = point.distance();

    println!("距離：{}", distance);
}

圖表翻譯：

此圖示為Rust程式設計的基礎知識架構圖，包括原始型別、函式、迭代和數學運算等。同時，也展示了Rust程式的結構，包括主函式、Cargo.toml檔案、Cargo工具和Rustup工具等。另外，還展示了複合資料型別，包括結構體和列舉等，並且討論了方法和錯誤處理機制，以及特徵的定義和實作。

  graph LR
    A[Rust程式設計] --> B[原始型別]
    A --> C[函式]
    A --> D[迭代和數學運算]
    A --> E[Rust程式結構]
    E --> F[主函式]
    E --> G[Cargo.toml檔案]
    E --> H[Cargo工具]
    E --> I[Rustup工具]
    A --> J[複合資料型別]
    J --> K[結構體]
    J --> L[列舉]
    A --> M[方法和錯誤處理]
    M --> N[方法]
    M --> O[錯誤處理]
    A --> P[特徵]

使用 Cargo 建立專案檔案

在 Rust 中，Cargo 是一個強大的工具，能夠幫助我們建立和管理專案。除了建立專案結構和管理依賴項外，Cargo 還能夠幫助我們建立專案的檔案。

使用 Cargo 建立檔案

要使用 Cargo 建立檔案，我們可以使用 cargo doc 命令。這個命令會自動為我們的專案生成檔案，並且會包含所有的模組、函式、結構體等。

cargo doc

這個命令會在 target/doc 目錄下生成檔案。

自定義檔案

如果我們想要自定義檔案的內容，我們可以使用 Markdown 語法在檔案中新增註解。例如：

/// 這是一個模組的註解
mod my_module {
    /// 這是一個函式的註解
    pub fn my_function() {
        //...
    }
}

這樣，當我們執行 cargo doc 命令時，會自動將這些註解封裝含在檔案中。

檔案結構

Cargo 生成的檔案會按照以下結構組織：

模組（Modules）
函式（Functions）
結構體（Structs）
列舉（Enums）
特徵（Traits）

每個部分都會包含相關的註解和程式碼片段。

使用 impl Blocks 新增方法

在 Rust 中，我們可以使用 impl blocks 新增方法到型別中。例如：

struct MyStruct {
    //...
}

impl MyStruct {
    fn my_method(&self) {
        //...
    }
}

這樣，當我們執行 cargo doc 命令時，會自動將這些方法包含在檔案中。

特徵（Traits）

Rust 的特徵（Traits）是定義介面的一種方式。例如：

trait MyTrait {
    fn my_method(&self);
}

struct MyStruct {
    //...
}

impl MyTrait for MyStruct {
    fn my_method(&self) {
        //...
    }
}

這樣，當我們執行 cargo doc 命令時，會自動將這些特徵包含在檔案中。

使用型別別名來暫時實作功能

在開發過程中，為了避免編譯器警告而暫時實作某些功能，可以使用型別別名（type alias）來達成。這種方法可以讓編譯器不會因為某些功能尚未完全實作而產生警告。

範例程式碼

以下是使用型別別名來暫時實作 File 型別的範例：

type File = String;

fn open(f: &mut File) {
    // 暫時實作 open 函式
}

fn close(f: &mut File) {
    // 暫時實作 close 函式
}

fn read(f: &mut File, save_to: &mut Vec<u8>) ->! {
    // 暫時實作 read 函式
    unimplemented!()
}

fn main() {
    let mut f1 = File::from("f1.txt");
    open(&mut f1);
    // read(f1, vec![]);
    close(&mut f1);
}

在這個範例中，我們使用 type File = String; 來定義一個型別別名 File，它暫時代表著 String 型別。這樣可以讓編譯器不會因為 File 型別尚未完全實作而產生警告。

優點

使用型別別名來暫時實作功能有以下優點：

可以暫時避免編譯器警告
可以讓程式碼更容易閱讀和維護
可以讓開發人員更容易專注於實作功能，而不是被編譯器警告幹擾

Rust 中的特殊傳回型別

在 Rust 中，有幾種特殊的傳回型別可能會讓新手程式設計師感到困惑。這些型別通常由符號而不是單片語成，因此在搜尋引擎中搜尋它們可能會比較困難。

單位型別（Unit Type）

單位型別，表示為 (), 是一個零長度的元組。它用於表示一個函式不傳回任何值。那些沒有明確指定傳回型別的函式會隱式地傳回 (). 同樣，帶有分號 ; 結尾的表示式也會傳回 ()。

例如，以下程式碼中的 report 函式隱式地傳回單位型別：

use std::fmt::Debug;

fn report<T: Debug>(item: T) {
    println!("{:?}", item);
}

而以下程式碼則顯式地傳回單位型別：

fn clear(text: &mut String) -> () {
    *text = String::from("");
}

單位型別經常出現在錯誤訊息中。忘記函式的最後一個表示式不應該以分號結尾是一個常見的錯誤。

Never 型別

Never 型別，表示為 !, 表示一個函式永遠不會傳回，特別是當它保證會當機時。例如：

fn dead_end() ->! {
    panic!("you have reached a dead end");
}

在這個例子中，dead_end 函式被宣告為永遠不會傳回，因為它會引發一個 panic。

實驗和 API 設計

在設計 API 時，使用普通函式來實驗和測試是很常見的。例如，我們可以從以下程式碼開始：

// listing 3.1
fn open(file: &str) -> bool {
    //...
}

fn close(file: &str) -> bool {
    //...
}

fn read(file: &str) -> String {
    //...
}

但是，這個實作有很多問題。例如，我們沒有建立一個持久的物件來代表檔案，我們也沒有實作 read 函式的失敗處理。

讓我們一步一步地解決這些問題。首先，我們可以建立一個 File 結構體來代表檔案：

struct File {
    name: String,
    //...
}

然後，我們可以將 open 和 close 函式改為方法：

impl File {
    fn open(&self) -> bool {
        //...
    }

    fn close(&self) -> bool {
        //...
    }
}

接下來，我們可以實作 read 函式，並處理失敗的情況：

impl File {
    fn read(&self) -> Result<String, std::io::Error> {
        //...
    }
}

在這個例子中，我們使用 Result 型別來處理 read 函式的失敗情況。

在本文中，我們討論了 Rust 中的特殊傳回型別，包括單位型別和 Never 型別。我們還演示瞭如何使用普通函式來實驗和測試 API，並如何一步一步地解決問題。最後，我們實作了一個 File 結構體和相關方法來代表檔案和處理檔案操作。

結構體的應用：模擬檔案

在程式設計中，我們經常需要建立複合型別來代表實際世界中的物體。Rust 的 struct 就是用於建立這種複合型別的。根據你的程式設計背景，你可能更熟悉「物件」或「記錄」這些術語。

首先，我們需要確設定檔案至少有兩個屬性：名稱和資料。以下是如何定義這種結構體：

#[derive(Debug)]
struct File {
    name: String,
    data: Vec<u8>,
}

在這個定義中，File 結構體有兩個欄位：name 和 data。name 是一個字串，代表檔案的名稱；data 是一個 u8 值的向量，代表檔案的內容。

現在，我們可以建立一個 File 例項並存取其欄位：

fn main() {
    let f1 = File {
        name: String::from("f1.txt"),
        data: Vec::new(),
    };

    println!("File {{ name: {:?}, data: {:?} }}", f1.name, f1.data);
    println!("{} is {} bytes long", f1.name, f1.data.len());
}

這段程式碼建立了一個名為 f1.txt、內容為空的檔案，並將其詳細資訊列印到控制檯。

內容解密：

#[derive(Debug)] 屬性自動為 File 結構體實作了 Debug 特徵，使其可以使用 {:?} 格式-specifier 進行除錯列印。
struct File 定義了一個新的結構體型別，包含 name 和 data 兩個欄位。
let f1 = File {... } 建立了一個新的 File 例項，並初始化其欄位。
println! 宏用於列印 File 例項的詳細資訊，包括其名稱和大小。

圖表翻譯：

  flowchart TD
    A[建立 File 結構體] --> B[定義 name 和 data 欄位]
    B --> C[建立 File 例項]
    C --> D[初始化 name 和 data 欄位]
    D --> E[列印 File 例項詳細資訊]

這個流程圖展示了建立和使用 File 結構體的步驟，從定義結構體到建立例項和列印其詳細資訊。

Rust 中的無限迴圈和 Never 型別

在 Rust 中，無限迴圈可以使用 loop 關鍵字來實作。下面的例子展示了一個無限迴圈的函式 forever，它永遠不會傳回：

fn forever() ->! {
    loop {
        //...
    }
}

這種無限迴圈會阻止函式傳回，因為它永遠不會結束。Rust 的 Never 型別（表示為 !）用於表示一個函式永遠不會傳回。當你定義一個傳回 Never 的函式時，你是在告訴 Rust 這個函式永遠不會正常傳回。

定義檔案結構體

下面的例子定義了一個結構體 File 來代表檔案：

struct File {
    name: String,
    data: Vec<u8>,
}

這個結構體有兩個欄位：name 和 data，分別代表檔案的名稱和內容。

建立檔案例項

你可以使用下面的方式建立一個 File 例項：

let f1 = File {
    name: String::from("example.txt"),
    data: vec![],
};

這裡，String::from 用於從字串字面量建立一個擁有權的字串，vec! 宏用於建立一個空的向量。

存取結構體欄位

你可以使用點運算子 (.) 來存取結構體的欄位：

let f1_name = &f1.name;
let f1_length = &f1.data.len();

這裡，f1_name 是 f1 的 name 欄位的參照，f1_length 是 f1 的 data 欄位的長度。

列印檔案資訊

你可以使用 println! 宏來列印檔案的資訊：

println!("{:?}", f1);
println!("{} is {} bytes long", f1_name, f1_length);

這裡，第一個 println! 陳述式使用 {:?} 格式化器來列印 f1 的 debug 表示形式。第二個 println! 陳述式使用 {} 格式化器來列印檔案的名稱和長度。

使用 Never 型別

當你定義一個傳回 Never 的函式時，你需要確保這個函式永遠不會正常傳回。否則，Rust 編譯器會報錯。

fn forever() ->! {
    loop {
        //...
    }
}

這個函式永遠不會傳回，因為它陷入了一個無限迴圈。

使用 Rust 的 struct 定義檔案結構

在 Rust 中，struct 是用來定義自訂資料結構的關鍵字。以下是定義一個 File struct 的範例：

struct File {
    name: String,
    data: Vec<u8>,
}

這個 File struct 有兩個欄位：name 和 data。name 是一個 String，而 data 是一個 Vec<u8>，也就是一個 unsigned 8 位元整數的向量。

建立 `File` 例項

要建立一個 File 例項，可以使用字面值語法：

let f1 = File {
    name: String::from("example.txt"),
    data: Vec::new(),
};

在這個範例中，我們建立了一個新的 File 例項，並使用 String::from() 方法建立了一個新的 String 例項作為 name 欄位的值。同時，我們使用 Vec::new() 方法建立了一個新的空向量作為 data 欄位的值。

存取 `File` 例項的欄位

要存取 File 例項的欄位，可以使用點號語法：

let f1_name = &f1.name;
let f1_length = &f1.data.len();

在這個範例中，我們存取了 f1 例項的 name 和 data 欄位，並將它們的值賦予了 f1_name 和 f1_length 變數。

新型別模式（Newtype Pattern）

有時候，你可能想要建立一個新的型別，但又不想建立一個完全新的資料結構。這時候，你可以使用新型別模式（Newtype Pattern）。新型別模式是指將一個核心型別包裝在一個單欄位的 struct 中。以下是範例：

struct Hostname(String);

let hostname = Hostname(String::from("example.com"));

在這個範例中，我們定義了一個新的 Hostname struct，它只有一個欄位，即 String。然後，我們建立了一個新的 Hostname 例項，並將一個 String 例項作為它的值。

這種模式可以幫助你區分不同的型別，例如網路主機名稱和普通字串。

結構體與新型別模式

在 Rust 中，結構體（struct）是一種用於定義自訂資料型別的方法。它允許我們將多個欄位組合成一個單一的資料單元。另一方面，新型別模式（newtype pattern）是一種使用 tuple struct 來包裝現有的型別，並為其賦予新的名稱和意義的技巧。

結構體

首先，我們來看看結構體的定義和使用。以下是一個簡單的範例：

#[derive(Debug)]
struct File {
    name: String,
    data: Vec<u8>,
}

fn main() {
    let file = File {
        name: String::from("example.txt"),
        data: vec![114, 117, 115, 116, 33],
    };
    println!("{:?}", file);
}

在這個範例中，我們定義了一個 File 結構體，它有兩個欄位：name 和 data。然後，在 main 函式中，我們建立了一個 File 例項，並使用 {:?} 格式化器列印預出它的內容。

新型別模式

新型別模式是一種使用 tuple struct 來包裝現有的型別，並為其賦予新的名稱和意義的技巧。以下是一個簡單的範例：

struct Hostname(String);

fn connect(host: Hostname) {
    println!("connected to {}", host.0);
}

fn main() {
    let ordinary_string = String::from("localhost");
    let host = Hostname(ordinary_string.clone());
    connect(ordinary_string);
}

在這個範例中，我們定義了一個 Hostname 新型別，它包裝了一個 String 例項。然後，在 connect 函式中，我們使用 Hostname 例項作為引數，並列印預出它的內容。

但是，如果我們試圖將 ordinary_string 直接傳遞給 connect 函式，編譯器會報錯，因為 ordinary_string 的型別是 String，而 connect 函式期望的是 Hostname。這就是新型別模式的作用：它允許我們為現有的型別賦予新的名稱和意義，並使得編譯器能夠區分不同的型別。

圖表翻譯：

  graph LR
    A[結構體] -->|定義|> B[File]
    B -->|例項化|> C[File 例項]
    C -->|列印|> D[{:?} 格式化器]
    D -->|輸出|> E[File 內容]
    
    F[新型別模式] -->|定義|> G[Hostname]
    G -->|包裝|> H[String]
    H -->|例項化|> I[Hostname 例項]
    I -->|傳遞|> J[connect 函式]
    J -->|列印|> K[連線訊息]

內容解密：

在這個範例中，我們使用結構體和新型別模式來定義自訂資料型別。結構體允許我們將多個欄位組合成一個單一的資料單元，而新型別模式允許我們為現有的型別賦予新的名稱和意義。這兩種技巧都可以幫助我們提高程式碼的可讀性和安全性。

使用新型別模式強化程式

在 Rust 中，使用新型別模式（newtype pattern）可以強化程式的安全性和可維護性。這個模式涉及建立一個新的型別來包裝現有的型別，從而提供額外的安全性和語義意義。

新型別模式的優點

使用新型別模式可以幫助我們避免錯誤的使用方式。例如，假設我們有兩個不同的型別，Hostname 和 String，如果我們直接使用 String 來代表主機名稱，可能會導致錯誤的使用方式。然而，如果我們建立一個新的型別 Hostname 來包裝 String，就可以確保只有合法的主機名稱才能被使用。

從技術架構視角來看，Rust 的程式結構、資料型別和所有權系統為程式設計師提供了強大的工具。透過原始型別、複合型別、方法、特徵和泛型等機制，Rust 實作了型別安全和記憶體安全，同時保有高效能。然而，Rust 的學習曲線較陡峭，需要程式設計師深入理解其所有權和借用規則。Rust 的錯誤處理機制雖然嚴謹，但在某些情況下可能略顯繁瑣。展望未來，隨著社群的發展和工具鏈的完善，Rust 的開發體驗將持續提升，其在系統程式設計、嵌入式開發和 WebAssembly 等領域的應用也將更加廣泛。對於追求效能和安全的專案，Rust 是一個值得投入學習和應用的程式語言。玄貓認為，Rust 的嚴謹性和安全性使其在構建可靠的軟體系統方面具有顯著優勢，值得長期關注。

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。

Rust 程式設計入門：基礎語法、結構與進階應用

圖表翻譯

圖表翻譯

Rust程式設計基礎

原始型別

函式

迭代和數學運算

列表型別

Rust程式結構

主函式

Cargo.toml檔案

Cargo工具

Rustup工具

複合資料型別

結構體

列舉

方法和錯誤處理

方法

錯誤處理

特徵

內容解密：

圖表翻譯：

使用 Cargo 建立專案檔案

使用 Cargo 建立檔案

自定義檔案

檔案結構

使用 impl Blocks 新增方法

特徵（Traits）

使用型別別名來暫時實作功能

範例程式碼

優點

Rust 中的特殊傳回型別

單位型別（Unit Type）

Never 型別

實驗和 API 設計

結構體的應用：模擬檔案

內容解密：

圖表翻譯：

Rust 中的無限迴圈和 Never 型別

定義檔案結構體

建立檔案例項

存取結構體欄位

列印檔案資訊

使用 Never 型別

使用 Rust 的 struct 定義檔案結構

建立 File 例項

存取 File 例項的欄位

新型別模式（Newtype Pattern）

結構體與新型別模式

結構體

新型別模式

圖表翻譯：

內容解密：

使用新型別模式強化程式

新型別模式的優點

玄貓

建立 `File` 例項

存取 `File` 例項的欄位