Rust 結構體與方法實作檔案資料讀寫

– 13 分鐘閱讀

Rust 提供了強大的檔案操作功能，透過結合結構體和方法，可以更有效地管理和操作檔案資料。檔案結構體通常包含檔案名稱和資料兩個欄位，而方法則用於執行讀寫等操作。以下程式碼範例展示瞭如何定義檔案結構體、實作讀寫方法，以及進行實際的檔案操作。

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

impl File {
    fn new(name: &str) -> File {
        File {
            name: String::from(name),
            data: Vec::new(),
        }
    }

    fn new_with_data(name: &str, data: Vec<u8>) -> File {
        File {
            name: String::from(name),
            data,
        }
    }


    fn read(&self, save_to: &mut Vec<u8>) -> usize {
        let mut tmp = self.data.clone();
        let read_length = tmp.len();
        save_to.reserve(read_length);
        save_to.append(&mut tmp);
        read_length
    }

        fn write(&mut self, data: &Vec<u8>) -> usize {
            self.data = data.clone();
            self.data.len()
        }


}

fn main() {
        let mut f = File::new_with_data("test.txt", vec![123]);
        let mut buffer = Vec::new();
        let len = f.read(&mut buffer);
        println!("{} is {} bytes long", f.name, len);
        println!("File content: {:?}", buffer);


        let new_data = "Hello, world!".as_bytes().to_vec();
        let written_len = f.write(&new_data);
        println!("{} is {} bytes long after write", f.name, written_len);


        let mut buffer2 = Vec::new();
        let len2 = f.read(&mut buffer2);
        println!("File content after write: {:?}", String::from_utf8_lossy(&buffer2));
}

實作新型別模式

以下是使用 struct 來實作新型別模式的例子：

struct Hostname(String);

fn connect(hostname: Hostname) {
    //...
}

在這個例子中，我們建立了一個新的型別 Hostname 來包裝 String。這樣就可以確保只有 Hostname 型別的值才能被傳遞給 connect 函式。

使用新型別模式的好處

使用新型別模式可以幫助我們：

  • 避免錯誤的使用方式
  • 提供額外的安全性和語義意義
  • 改善程式的可維護性和可讀性

然而，使用新型別模式也有一些缺點，例如需要額外的程式碼和複雜度。因此，需要仔細評估是否需要使用新型別模式。

內容解密：

在上面的例子中，我們建立了一個新的型別 Hostname 來包裝 String。這樣就可以確保只有 Hostname 型別的值才能被傳遞給 connect 函式。這個模式可以幫助我們避免錯誤的使用方式，並提供額外的安全性和語義意義。

圖表翻譯：

  flowchart TD
    A[建立新型別] --> B[包裝現有的型別]
    B --> C[提供額外的安全性和語義意義]
    C --> D[避免錯誤的使用方式]
    D --> E[改善程式的可維護性和可讀性]

這個圖表展示了使用新型別模式的流程。首先，建立一個新的型別來包裝現有的型別。然後，提供額外的安全性和語義意義。接下來，避免錯誤的使用方式。最後，改善程式的可維護性和可讀性。

檔案模型結構

在 Rust 中，使用 struct 來定義檔案模型是一種常見的做法。下面是一個簡單的例子：

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

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

檔案操作函式

為了對檔案進行操作，我們可以定義一些函式。例如，開啟和關閉檔案的函式可以如下所示：

fn open(f: &mut File) -> bool {
    // 在這裡實作開啟檔案的邏輯
    true
}

fn close(f: &mut File) -> bool {
    // 在這裡實作關閉檔案的邏輯
    true
}

讀取檔案內容

如果我們想要讀取檔案的內容，可以定義一個函式如下：

fn read(f: &File, save_to: &mut Vec<u8>) -> usize {
    // 在這裡實作讀取檔案內容的邏輯
    // 並將內容儲存到 save_to 中
    0 // 傳回讀取的位元組數
}

內容解密：

上述的 read 函式接收一個 &File 和一個可變的 Vec<u8> 參照作為引數。它的目的是從檔案中讀取內容，並將這些內容儲存到 save_to 中。函式傳回的是讀取的位元組數，表示成功讀取了多少個位元組。

圖表翻譯：

  flowchart TD
    A[開始] --> B[開啟檔案]
    B --> C[讀取檔案內容]
    C --> D[儲存內容]
    D --> E[關閉檔案]
    E --> F[結束]

圖表翻譯：

此流程圖描述了檔案操作的基本過程。首先開啟檔案，然後讀取其內容，接著儲存這些內容，最後關閉檔案。每一步驟都對應著上述函式中的邏輯。

Rust 中的檔案操作與資料儲存

在 Rust 中，檔案操作是一個基本且重要的功能。以下是如何在 Rust 中定義一個結構體來代表檔案，並實作檔案資料的儲存和讀取。

定義檔案結構體

首先，我們定義一個 File 結構體來代表檔案。這個結構體包含兩個欄位：name 和 data，分別代表檔案名稱和檔案資料。

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

實作檔案資料儲存

接下來，我們實作一個方法來儲存檔案資料。這個方法會將檔案資料儲存到一個向量中。

impl File {
    fn save_to(&self, save_to: &mut Vec<u8>) -> usize {
        let mut tmp = self.data.clone();
        let read_length = tmp.len();
        save_to.reserve(read_length);
        save_to.append(&mut tmp);
        read_length
    }
}

主函式

在 main 函式中，我們建立一個 File 例項，並呼叫 save_to 方法來儲存檔案資料。

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

    let mut buffer: Vec<u8> = vec![];
    f2.save_to(&mut buffer);
}

Mermaid 圖表

以下是使用 Mermaid 圖表來視覺化檔案操作流程：

  flowchart TD
    A[建立 File 例項] --> B[呼叫 save_to 方法]
    B --> C[儲存檔案資料]
    C --> D[傳回儲存長度]

圖表翻譯

這個圖表展示了檔案操作的流程。首先，建立一個 File 例項。接下來，呼叫 save_to 方法來儲存檔案資料。最後，傳回儲存長度。

內容解密

在 save_to 方法中，我們首先建立一個臨時向量 tmp 來儲存檔案資料。然後，取得檔案資料的長度 read_length。接下來，為 save_to 向量預留足夠的空間來儲存檔案資料。最後，將檔案資料追加到 save_to 向量中，並傳回儲存長度。

let mut tmp = self.data.clone();
let read_length = tmp.len();
save_to.reserve(read_length);
save_to.append(&mut tmp);
read_length

這個過程確保了檔案資料被正確地儲存和讀取。

檔案操作與讀寫實作

在上述程式碼中，我們看到了一個簡單的檔案操作過程，包括開啟檔案、讀取檔案內容、關閉檔案，並將檔案內容輸出到螢幕上。然而，這段程式碼仍然存在一些問題，例如 open() 和 close() 的傳回值為 bool，而且我們的函式並不是作為方法來實作的。

目前實作的功能

  1. 檔案結構體：我們已經定義了一個 File 結構體，這使得我們可以將檔案相關的資料和方法封裝在一起。
  2. 讀取功能：我們實作了 read() 函式，雖然它的效率不是最優的，但它能夠完成基本的檔案讀取任務。

待解決的問題

  1. open() 和 close() 的傳回值：目前，這兩個函式傳回 bool 值，表示操作是否成功。然而，在實際應用中，我們可能需要更豐富的傳回資訊，例如錯誤程式碼或錯誤訊息。
  2. 方法實作：我們的函式並不是作為 File 結構體的方法來實作的。這意味著我們不能直接在 File 例項上呼叫這些函式，而是需要透過函式指標或其他間接方式來存取它們。

未來改進方向

為了進一步改進這段程式碼，我們可以考慮以下幾點：

  1. 改進 open() 和 close() 的傳回值：我們可以定義一個自訂的錯誤型別，包含更多有用的資訊，以便於錯誤處理和除錯。
  2. 實作方法：我們可以將 read()、open() 和 close() 函式作為 File 結構體的方法來實作，這樣可以提高程式碼的組織性和可讀性。
  3. 最佳化讀取效率：我們可以探索更高效的檔案讀取演算法，例如使用緩衝區或非同步 I/O，以提高整體效能。

以下是一個簡單的示例，展示如何將 read() 函式作為 File 結構體的方法來實作：

struct File {
    name: String,
    //... 其他欄位
}

impl File {
    fn read(&self, buffer: &mut Vec<u8>) -> usize {
        // 實作讀取邏輯
    }
}

這樣，我們就可以直接在 File 例項上呼叫 read() 方法，例如：

let mut file = File { name: "example.txt".to_string(), /*... */ };
let mut buffer = Vec::new();
let bytes_read = file.read(&mut buffer);

這種方法不僅提高了程式碼的可讀性，也使得檔案操作更加直觀和方便。

結構體與方法的實作

在 Rust 中，結構體（struct）是一種用於定義複合資料的基本單元。與其他語言不同，Rust 沒有類別（class）這個概念，但結構體可以透過實作方法（method）來達到類別似於類別的功能。

實作方法

Rust 的方法是透過 impl 塊來定義的。這個塊是物理上與結構體和列舉（enum）塊分開的。下面的例子展示瞭如何定義一個結構體和它的方法：

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

impl File {
    fn new(name: String) -> File {
        File {
            name,
            content: Vec::new(),
        }
    }

    fn read(&self) -> String {
        String::from_utf8_lossy(&self.content).into_owned()
    }
}

在這個例子中，我們定義了一個 File 結構體，它有兩個欄位：name 和 content。然後，我們透過 impl 塊實作了兩個方法：new 和 read。new 方法用於建立一個新的 File 例項，而 read 方法用於讀取檔案的內容。

物件建立

在 Rust 中，建立物件可以透過結構體字面量或 new 方法來完成。使用 new 方法可以使程式碼更簡潔和易於維護。例如：

let file = File::new("example.txt".to_string());

這個例子建立了一個新的 File 例項，並將其命名為 “example.txt”。

方法與函式

Rust 的方法和函式之間有一些理論上的差異，但在實際應用中，這些差異往往不是那麼重要。方法是與某個物件相關聯的函式，它們可以透過點運算子來呼叫。例如：

let file = File::new("example.txt".to_string());
println!("{}", file.read());

這個例子呼叫了 file 物件的 read 方法，並將其傳回值列印到控制檯上。

類別與結構體

雖然 Rust 沒有類別這個概念，但結構體可以透過實作方法來達到類別似於類別的功能。然而，結構體和類別之間還是有一些差異。例如，結構體不支援繼承，而類別則支援繼承。因此，結構體和類別之間的選擇取決於具體的情況和需求。

圖表翻譯：

  classDiagram
    class File {
        - name: String
        - content: Vec~u8~
        + new(name: String) File
        + read() String
    }

這個圖表展示了 File 結構體的結構和方法。

結構體和列舉

在 Rust 中，結構體（struct）和列舉（enum）是兩種基本的資料型態。結構體用於定義複合資料型態，而列舉則用於定義一組具有名稱的值。

結構體

結構體是 Rust 中的一種複合資料型態，允許您定義具有多個欄位的資料型態。您可以使用 struct 關鍵字來定義一個結構體。例如：

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

在這個例子中，我們定義了一個名為 File 的結構體，它具有兩個欄位：name 和 data。

方法

在 Rust 中，您可以使用 impl 關鍵字來定義結構體的方法。方法是指可以在結構體例項上呼叫的函式。例如：

impl File {
    fn new(name: String, data: Vec<u8>) -> File {
        File { name, data }
    }
}

在這個例子中，我們定義了一個名為 new 的方法，它可以用來建立一個新的 File 例項。

資料和方法的分離

在 Rust 中，資料和方法是分離的。這意味著您需要使用 impl 關鍵字來定義結構體的方法，而不是直接在結構體定義中定義方法。這種設計可以使您的程式碼更加模組化和易於維護。

例如，以下是錯誤的做法：

struct File {
    name: String,
    data: Vec<u8>,
    fn new(name: String, data: Vec<u8>) -> File {
        File { name, data }
    }
}

而以下是正確的做法：

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

impl File {
    fn new(name: String, data: Vec<u8>) -> File {
        File { name, data }
    }
}

實踐

讓我們透過一個實際的例子來演示如何使用 impl 關鍵字來定義結構體的方法。假設我們想要建立一個名為 File 的結構體，它具有 name 和 data 兩個欄位，並且具有 new 方法來建立新的 File 例項。

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

impl File {
    fn new(name: String, data: Vec<u8>) -> File {
        File { name, data }
    }
}

在這個例子中，我們使用 impl 關鍵字來定義 File 結構體的 new 方法。這個方法可以用來建立新的 File 例項，並將其名稱和資料設定為指定的值。

內容解密：

在上面的例子中，我們使用 impl 關鍵字來定義 File 結構體的 new 方法。這個方法可以用來建立新的 File 例項，並將其名稱和資料設定為指定的值。注意，new 方法傳回一個新的 File 例項，而不是修改現有的例項。

圖表翻譯：

以下是上述程式碼的 Mermaid 圖表：

  classDiagram
    class File {
        - name: String
        - data: Vec~u8~
        + new(name: String, data: Vec~u8~) File
    }

這個圖表顯示了 File 結構體的欄位和方法。注意，new 方法傳回一個新的 File 例項，而不是修改現有的例項。

建立檔案結構

在 Rust 中，建立檔案結構可以使用結構體（struct）來定義。以下是定義一個 File 結構體的範例：

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

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

實作 new 方法

為了建立新的 File 例項，我們可以實作 new 方法：

impl File {
    fn new(name: &str) -> File {
        File {
            name: String::from(name),
            data: Vec::new(),
        }
    }
}

這個方法接收一個 &str 引數 name，並傳回一個新的 File 例項。其中，name 欄位被初始化為傳入的 name 引數，data 欄位被初始化為一個空的向量。

使用 File 結構體

現在，我們可以使用 File 結構體來建立新的檔案例項：

fn main() {
    let f3 = File::new("f3.txt");
    let f3_name = &f3.name;
    let f3_length = f3.data.len();
    println!("{:?}", f3);
    println!("{} is {} bytes long", f3_name, f3_length);
}

在這個範例中，我們建立了一個新的 File 例項，命名為 “f3.txt”。然後，我們取得檔案的名稱和內容長度，並印出相關資訊。

內容解密：

在上面的程式碼中，我們定義了一個 File 結構體，包含兩個欄位：name 和 data。我們實作了 new 方法來建立新的 File 例項。然後，在 main 函式中，我們建立了一個新的 File 例項，並取得其名稱和內容長度。最後，我們印出相關資訊。

圖表翻譯：

  classDiagram
    class File {
        - name: String
        - data: Vec~u8~
        + new(name: &str) File
    }
    File..> String : name
    File..> Vec~u8~ : data

這個圖表顯示了 File 結構體的欄位和方法。其中，name 和 data 是欄位，new 是方法。

結合新知識：定義檔案結構

在瞭解了 Rust 的結構體和方法之後，我們可以將這些知識應用到檔案結構的定義上。以下是結合了新知識的範例程式碼（見 ch3/ch3-defining-files-neatly.rs）：

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

impl File {
    fn new(name: &str, data: Vec<u8>) -> File {
        File {
            name: String::from(name),
            data,
        }
    }
}

fn main() {
    let file = File::new("2.txt", vec![114, 117, 115, 116, 33]);
    println!("File {{ name: {}, data: {:?} }}", file.name, file.data);
    println!("{} is {} bytes long", file.name, file.data.len());
}

這個程式碼定義了一個 File 結構體，並實作了 new 方法來建立新的 File 例項。main 函式示範瞭如何使用 File::new 方法建立一個新的 File 例項，並列印預出其名稱和資料。

比較 Rust 的字面語法和 new 方法

下表比較了使用 Rust 的字面語法和 new 方法建立物件的差異：

目前使用使用 File::new
File { name: String::from("f1.txt"), data: Vec::new() }File::new("f1.txt", vec![])
File { name: String::from("f2.txt"), data: vec![114, 117, 115, 116, 33] }File::new("f2.txt", vec![114, 117, 115, 116, 33])

使用 impl 區塊新增方法

在 Rust 中，我們可以使用 impl 區塊新增方法到結構體中。例如：

impl File {
    fn new(name: &str, data: Vec<u8>) -> File {
        //...
    }
}

這個 impl 區塊定義了 File 結構體的 new 方法。

私有欄位和模組系統

在 Rust 中，欄位預設是私有的，這意味著它們只能在同一個模組中存取。模組系統將在後面的章節中討論。

圖表翻譯：

  flowchart TD
    A[定義結構體] --> B[實作 new 方法]
    B --> C[建立新的 File 例項]
    C --> D[列印預出檔案名稱和資料]

這個流程圖示範瞭如何定義結構體、實作 new 方法、建立新的 File 例項，並列印預出檔案名稱和資料。

建立檔案結構

在開始實作檔案系統之前，我們需要定義檔案的結構。檔案可以被視為一個包含名稱和資料的單位。以下是使用Rust語言定義檔案結構的示例：

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

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

實作檔案建構函式

為了方便建立新的檔案，我們可以實作一個建構函式。這個函式可以根據給定的名稱建立一個新的檔案，並初始化其內容為空。

impl File {
    fn new(name: &str) -> File {
        File {
            name: String::from(name),
            data: Vec::new(),
        }
    }
}

這個new函式接受一個字串引數name，並傳回一個新的File例項。檔案的名稱被設定為給定的name，而內容被初始化為一個空的向量。

實作帶有初始資料的檔案建構函式

除了建立空檔案外，我們還可能需要建立包含初始資料的檔案。為此，我們可以定義另一個建構函式，接受檔案名稱和初始資料作為引數。

fn new_with_data(name: &str, data: Vec<u8>) -> File {
    File {
        name: String::from(name),
        data,
    }
}

這個new_with_data函式接受兩個引數：name和data，分別代表檔案的名稱和初始內容。它傳回一個新的File例項，名稱設定為給定的name，內容設定為給定的data。

內容解密：

上述程式碼定義了一個名為File的結構體，用於表示檔案。它包含兩個欄位：name和data，分別代表檔案的名稱和內容。接著，我們實作了兩個建構函式：new和new_with_data，用於建立新的檔案例項。這些函式提供了一種方便的方式來初始化檔案，並根據需要設定其名稱和內容。

圖表翻譯：

  classDiagram
    class File {
        - name: String
        - data: Vec~u8~
        + new(name: &str) File
        + new_with_data(name: &str, data: Vec~u8~) File
    }

這個類別圖描述了File結構體及其方法。它展示了檔案的屬性（名稱和內容）以及用於建立新檔案例項的建構函式。

檔案結構與讀寫實作

檔案結構定義

在實作檔案的讀寫功能之前，我們需要定義檔案的結構。檔案結構可以簡單地理解為一個包含檔案名稱和檔案資料的單位。以下是檔案結構的定義：

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

實作檔案寫入功能

檔案寫入功能可以透過以下方法實作：

impl File {
    fn new(name: String, data: &Vec<u8>) -> File {
        let mut f = File {
            name,
            data: Vec::new(),
        };
        f.data = data.clone();
        f
    }
}

這個方法建立了一個新的檔案，並將提供的資料複製到檔案中。

實作檔案讀取功能

檔案讀取功能可以透過以下方法實作：

impl File {
    fn read(&self, save_to: &mut Vec<u8>) -> usize {
        let mut tmp = self.data.clone();
        let read_length = tmp.len();
        save_to.reserve(read_length);
        save_to.append(&mut tmp);
        read_length
    }
}

這個方法從檔案中讀取資料，並將其儲存到提供的向量中。傳回值是讀取的資料長度。

使用範例

以下是使用檔案結構和方法的範例：

fn main() {
    let file_name = "example.txt".to_string();
    let file_data = "Hello, World!".as_bytes().to_vec();
    
    let mut file = File::new(file_name, &file_data);
    
    let mut read_data = Vec::new();
    let read_length = file.read(&mut read_data);
    
    println!("Read {} bytes: {:?}", read_length, read_data);
}

這個範例建立了一個新的檔案，寫入資料，然後讀取資料並列印預出來。

內容解密：

  • File 結構體定義了檔案的基本屬性：名稱和資料。
  • new 方法建立了一個新的檔案，並初始化其名稱和資料。
  • read 方法從檔案中讀取資料，並將其儲存到提供的向量中。
  • 範例程式碼展示瞭如何使用 File 結構體和其方法來建立、寫入和讀取檔案。

圖表翻譯：

  classDiagram
    class File {
        - name: String
        - data: Vec<u8>
        + new(name: String, data: Vec<u8>) File
        + read(save_to: Vec<u8>) usize
    }

這個圖表展示了 File 結構體的屬性和方法。

Rust 檔案操作與資料讀寫

從程式碼實作到應用場景的全面檢視顯示，Rust 的新型別模式結合結構體與方法，為檔案操作和資料儲存提供了安全且有效率的解決方案。透過 impl 區塊，我們可以將函式與特定結構體關聯，實作物件導向程式設計的封裝特性，提升程式碼的可讀性和可維護性。仔細分析 File 結構體的 new、read、save_to 等方法，可以發現 Rust 強調資料所有權和借用機制，有效避免了資料競爭和其他記憶體安全問題，這對於系統程式設計至關重要。然而，Rust 的學習曲線較陡峭，需要開發者深入理解其所有權系統和生命週期概念。綜合評估後，Rust 的嚴謹性和效能優勢使其在檔案系統和資料函式庫等底層系統開發中極具潛力，值得關注效能和安全的開發者深入研究。隨著社群和工具鏈的持續發展，我們預見 Rust 的應用範圍將持續擴大，並在更多領域展現其獨特價值。

玄貓

玄貓

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