Rust 序列化與反序列化及檔案處理實務技巧

Rust 提供了多種序列化函式庫，例如 bincode、serde、serde_cbor 和 serde_json，各有其效能和跨平臺支援的特性，開發者需要根據專案需求選擇合適的方案。序列化時，需先使用 serde_derive 巨集標記結構體，才能將資料序列化成不同格式。檔案處理方面，Rust 的 std::fs 和 std::io 模組提供了豐富的功能，可以方便地讀取和寫入檔案。OpenOptions 結構體允許更精細地控制檔案開啟模式，例如讀取、寫入、建立和追加。使用 BufReader 可以有效地讀取檔案內容，並搭配 chunks 方法將檔案分割成固定大小的區塊進行處理。此外，文章也示範瞭如何利用迴圈和格式化輸出，將檔案內容以十六進位制格式顯示，並逐步建構一個類別似 Hexdump 功能的工具，方便檢視檔案的二進位制內容。

序列化函式庫的選擇

Rust 中有多個序列化函式庫可供選擇，包括 bincode、serde、serde_cbor 和 serde_json。每個函式庫都有其自己的優點和缺點，根據具體需求選擇合適的函式庫非常重要。

定義可序列化的結構

要將資料結構序列化，首先需要定義一個可序列化的結構。以下是定義一個 City 結構的示例：

use serde_derive::Serialize;

#[derive(Serialize)]
struct City {
    name: String,
    population: usize,
    latitude: f64,
    longitude: f64,
}

在這個示例中，City 結構被標記為可序列化的，使用 #[derive(Serialize)] 屬性。

序列化為不同格式

現在，我們可以使用不同的序列化函式庫將 City 結構序列化為不同格式。例如：

use bincode::serialize as to_bincode;
use serde_cbor::to_vec as to_cbor;
use serde_json::to_string as to_json;

let city = City {
    name: "Taipei".to_string(),
    population: 2733000,
    latitude: 25.0333,
    longitude: 121.6333,
};

let bincode = to_bincode(&city).unwrap();
let cbor = to_cbor(&city).unwrap();
let json = to_json(&city).unwrap();

在這個示例中，我們使用 bincode、serde_cbor 和 serde_json 序列化 City 結構為不同的格式。

內容解密：

在上面的示例中，我們使用了 bincode、serde_cbor 和 serde_json 序列化 City 結構為不同的格式。每個函式庫都有其自己的優點和缺點，根據具體需求選擇合適的函式庫非常重要。例如，bincode 序列化速度快，但不支援跨語言；serde_cbor 序列化速度慢，但支援跨語言；serde_json 序列化速度中等，但支援跨語言和人類可讀。

圖表翻譯：

  graph LR
    A[City 結構] -->|序列化|> B[Bincode]
    A -->|序列化|> C[CBOR]
    A -->|序列化|> D[JSON]
    B -->|儲存|> E[檔案]
    C -->|傳輸|> F[網路]
    D -->|顯示|> G[人類可讀]

在這個圖表中，我們展示了 City 結構被序列化為不同的格式，並儲存或傳輸到不同的目的地。

內容解密：

這個程式碼片段展示瞭如何使用 Rust 語言將一個 City 結構體例項序列化為不同的格式，包括 JSON、CBOR 和 Bincode。以下是每個部分的詳細解釋：

定義 City 結構體：程式碼開始時定義了一個 City 結構體，它包含四個欄位：name、population、latitude 和 longitude。這些欄位分別代表城市的名稱、人口數、緯度和經度。
建立 City 例項：接下來，建立了一個名為 calabar 的 City 例項，並初始化其欄位。例如，城市名稱設為 “Calabar”，人口數為 470,000，緯度為 4.95，經度為 8.33。
序列化為 JSON：使用 to_json 函式將 calabar 例項序列化為 JSON 格式。這個函式傳回一個 Result，其中包含序列化後的 JSON 資料。透過 unwrap 方法處理可能的錯誤，得到序列化後的 JSON 字串，並儲存在 as_json 變數中。
序列化為 CBOR：同樣地，使用 to_cbor 函式將 calabar 例項序列化為 CBOR 格式，並儲存在 as_cbor 變數中。
序列化為 Bincode：使用 to_bincode 函式將 calabar 例項序列化為 Bincode 格式，並儲存在 as_bincode 變數中。
列印序列化結果：最後，程式碼列印預出每種格式的序列化結果。對於 JSON，直接列印 as_json 的內容。對於 CBOR 和 Bincode，由於它們是二進位制格式，因此使用 {:?} 來列印其十六進製表示。
JSON 作為 UTF-8：特別地，程式碼還展示瞭如何將 JSON 資料作為 UTF-8 編碼的位元組串進行列印。這是透過 String::from_utf8_lossy 函式實作的，這個函式從位元組串建立一個字串，忽略任何無法解釋的位元組。

這個程式碼片段展示了 Rust 中序列化和反序列化的基本概念，以及如何使用不同的函式庫（如 serde_json、serde_cbor 和 bincode）來處理不同的資料格式。

序列化與反序列化技術的應用

在軟體開發中，序列化（Serialization）和反序列化（Deserialization）是兩個非常重要的概念。序列化是指將資料結構或物件轉換成可以儲存或傳輸的格式，而反序列化則是指將序列化後的資料轉換回原始的資料結構或物件。

Rust 中的序列化與反序列化

Rust 是一種現代的程式設計語言，它提供了強大的序列化和反序列化功能。以下是 Rust 中序列化和反序列化的範例：

use serde::{Serialize, Deserialize};
use serde_json;

#[derive(Serialize, Deserialize)]
struct City {
    name: String,
    population: u32,
}

fn main() {
    let city = City {
        name: "Taipei".to_string(),
        population: 2730000,
    };

    // 序列化為 JSON
    let json = serde_json::to_string(&city).unwrap();
    println!("JSON: {}", json);

    // 序列化為 CBOR
    let cbor = serde_cbor::to_vec(&city).unwrap();
    println!("CBOR (as UTF-8): {:?}", String::from_utf8_lossy(&cbor));

    // 序列化為 Bincode
    let bincode = bincode::serialize(&city).unwrap();
    println!("Bincode (as UTF-8): {:?}", String::from_utf8_lossy(&bincode));
}

在這個範例中，我們定義了一個 City 結構體，並使用 serde 函式庫來序列化和反序列化它。我們使用 serde_json、serde_cbor 和 bincode 函式庫來序列化 City 結構體為 JSON、CBOR 和 Bincode 格式。

序列化與反序列化的應用

序列化和反序列化技術有很多應用，例如：

資料儲存：序列化可以用來將資料儲存到檔案或資料函式庫中。
網路傳輸：序列化可以用來將資料傳輸到網路上。
跨語言通訊：序列化可以用來將資料從一個程式設計語言轉換到另一個語言。

實作 Hexdump 的複製品

Hexdump 是一個方便的工具，用於檢視檔案的內容。它將檔案的內容以十六進位制數字對的形式輸出。下表展示了 Hexdump 的輸出範例。

實作 fview

我們將實作一個名為 fview 的 Hexdump 複製品。除非您熟悉十六進製表示法，否則 fview 的輸出可能會有些難以理解。如果您有檢視類別似輸出的經驗，您可能會注意到沒有超過 0x7e (127) 的位元組。此外，少數位元組小於 0x21 (33)，除了 0x0a (10) 代表換行符號 (\n)。這些位元組模式是純文字輸入源的標誌。

fview 的原始碼

以下是 fview 的原始碼，它使用字串常數作為輸入並產生上述表格中的輸出。這個範例展示了多行字串常數的使用以及 std::io::prelude 的匯入，以啟用 &[u8] 型別作為檔案的讀取。

use std::io::prelude::*;

const BYTES_PER_LINE: usize = 16;

const INPUT: &'static [u8] = br#"
fn main() {
    println!("Hello, world!");
}"#;

fn main() -> std::io::Result<()> {
    //...
}

fview 的輸出

fview 的輸出如下所示：

[0x00000000] 0a 66 6e 20 6d 61 69 6e 28 29 20 7b 0a 20 20 20
[0x00000010] 20 70 72 69 6e 74 6c 6e 21 28 22 48 65 6c 6c 6f
[0x00000020] 2c 20 77 6f 72 6c 64 21 22 29 3b 0a 7d

std::io::prelude 的匯入

std::io::prelude 提供了一種方便的方式來匯入常用的 I/O 特徵，例如 Read 和 Write。雖然可以手動匯入這些特徵，但由於它們非常常用，因此標準函式庫提供了這種方便的方法來保持程式碼緊湊。

多行字串常數

多行字串常數可以使用 raw 字串常數（以 br## 開頭）來避免對雙引號進行轉義。

fview 的實作

fview 的實作涉及到對輸入的處理和十六進位制數字對的輸出。以下是 fview 的完整實作：

use std::io::prelude::*;

const BYTES_PER_LINE: usize = 16;

fn main() -> std::io::Result<()> {
    let input = br#"
fn main() {
    println!("Hello, world!");
}"#;

    let mut offset = 0;
    while offset < input.len() {
        print!("{:08x} ", offset);
        for i in 0..BYTES_PER_LINE {
            if offset + i >= input.len() {
                break;
            }
            print!("{:02x} ", input[offset + i]);
        }
        println!();
        offset += BYTES_PER_LINE;
    }

    Ok(())
}

這個實作使用了一個迴圈來處理輸入的每一行，並使用 print! 宏來輸出十六進位制數字對。每一行的開頭都會輸出偏移量，然後是十六進位制數字對。

讀取檔案內容並以十六進位制格式顯示

在這個範例中，我們將檔案的內容讀取到一個向量（Vec<u8>）中，然後以十六進位制格式將其印出。

程式碼

use std::fs::File;
use std::io::{Read, Result};

const BYTES_PER_LINE: usize = 16;

fn main() -> Result<()> {
    let mut file = File::open("example.txt")?;
    let mut buffer: Vec<u8> = vec!();
    file.read_to_end(&mut buffer)?;

    let mut position_in_input = 0;
    for line in buffer.chunks(BYTES_PER_LINE) {
        print!("[0x{:08x}] ", position_in_input);
        for byte in line {
            print!("{:02x} ", byte);
        }
        println!();
        position_in_input += BYTES_PER_LINE;
    }

    Ok(())
}

內容解密：

我們首先開啟一個檔案，並將其內容讀取到一個向量（Vec<u8>）中。
我們使用 chunks 方法將向量分割成大小為 BYTES_PER_LINE 的塊。
對於每個塊，我們印出其在檔案中的位置（以十六進位制格式表示）。
接著，我們印出每個 byte 的十六進位制值。
最後，我們印出一個換行符號，以便於閱讀。

圖表翻譯：

  flowchart TD
    A[開啟檔案] --> B[讀取檔案內容]
    B --> C[分割內容為塊]
    C --> D[印出塊位置和內容]
    D --> E[印出換行符號]

這個流程圖顯示了我們的程式執行流程：開啟檔案，讀取內容，分割內容為塊，印出每個塊的位置和內容，最後印出換行符號。

擴充套件 fview 的功能以讀取真實檔案

現在，我們來延伸 fview 的功能，以便它可以讀取真實的檔案。以下的程式碼片段展示了一個基本的十六進位制 dump 工具（hexdump），它示範瞭如何在 Rust 中開啟檔案並遍歷其內容。你可以在 ch7/ch7-fview/src/main.rs 中找到這個原始碼。

基本的 hexdump 工具

首先，我們需要引入必要的模組，包括檔案系統 (std::fs::File) 和輸入/輸出功能 (std::io::prelude::*):

use std::fs::File;
use std::io::prelude::*;
use std::env;

接下來，我們定義了一個常數 BYTES_PER_LINE，用於指定每行顯示的 byte 數量：

const BYTES_PER_LINE: usize = 16;

主要函式

在 main 函式中，我們首先從命令列引數中取得檔案名稱：

let arg1 = env::args().nth(1);
let fname = arg1.expect("usage: fview FILENAME");

然後，我們嘗試開啟指定的檔案：

let mut f = File::open(&fname).expect("Unable to open file.");

為了追蹤檔案中的位置，我們初始化了一個 pos 變數：

let mut pos = 0;

另外，我們定義了一個緩衝區 (buffer)，用於存放每次讀取的 byte 資料：

let mut buffer = [0; BYTES_PER_LINE];

讀取檔案內容

現在，我們使用一個迴圈來讀取檔案的內容，每次讀取 BYTES_PER_LINE 個 byte：

while let Ok(_) = f.read_exact(&mut buffer) {
    // 處理讀取到的 byte
}

在迴圈內部，我們首先印出目前的檔案位置（以十六進製表示）：

print!("[0x{:08x}] ", pos);

接下來，我們遍歷緩衝區中的每個 byte，並對其進行處理：

for byte in &buffer {
    match *byte {
        // 處理 byte 的邏輯
    }
}

處理 byte

對於每個 byte，我們可以根據需要進行不同的處理。例如，對於十六進位制 dump 工具，我們可能想要印出 byte 的十六進製表示：

print!("{:02x} ", byte);

完整程式碼

以下是完整的程式碼片段：

use std::fs::File;
use std::io::prelude::*;
use std::env;

const BYTES_PER_LINE: usize = 16;

fn main() {
    let arg1 = env::args().nth(1);
    let fname = arg1.expect("usage: fview FILENAME");

    let mut f = File::open(&fname).expect("Unable to open file.");
    let mut pos = 0;
    let mut buffer = [0; BYTES_PER_LINE];

    while let Ok(_) = f.read_exact(&mut buffer) {
        print!("[0x{:08x}] ", pos);
        for byte in &buffer {
            print!("{:02x} ", byte);
        }
        println!();
        pos += BYTES_PER_LINE;
    }
}

圖表翻譯：

  flowchart TD
    A[開始] --> B[開啟檔案]
    B --> C[讀取檔案內容]
    C --> D[處理 byte]
    D --> E[印出結果]
    E --> F[結束]

這個程式碼片段展示瞭如何在 Rust 中開啟檔案、讀取其內容，並對每個 byte 進行處理。這是一個基本的十六進位制 dump 工具的實作，示範了 Rust 中的檔案操作和 byte 處理。

讀取檔案內容並以十六進位制格式顯示

在 Rust 中，開啟檔案並讀取其內容是一個基本的操作。以下是如何實作這個功能的範例程式碼：

use std::fs::File;
use std::io::{Read, BufReader};

const BYTES_PER_LINE: usize = 16;

fn main() {
    // 開啟檔案
    let file = File::open("example.txt").unwrap();
    let mut reader = BufReader::new(file);

    // 讀取檔案內容
    let mut buffer = [0; BYTES_PER_LINE];
    let mut pos = 0;
    while let Ok(n) = reader.read(&mut buffer) {
        // 處理讀取到的內容
        for (i, byte) in buffer.iter().take(n).enumerate() {
            match *byte {
                0x00 => print!(". "),
                0xff => print!("## "),
                _ => print!("{:02x} ", byte),
            }
        }
        println!();
        pos += BYTES_PER_LINE;
    }
}

程式碼解釋

我們使用 File::open 函式開啟檔案，並使用 BufReader 來讀取檔案內容。
我們定義了一個 buffer 來存放讀取到的內容，並設定其大小為 BYTES_PER_LINE。
我們使用 read 方法讀取檔案內容，並將其存放到 buffer 中。
我們使用 match 陳述式來處理讀取到的內容，根據 byte 的值進行不同的處理。
如果 byte 的值為 0x00，我們印出一個點 (.)；如果 byte 的值為 0xff，我們印出一個井字 (##）；否則，我們印出 byte 的十六進位制值。
我們使用 println! 宏來印出換行符號。
我們更新 pos 變數來記錄目前的位置。

執行結果

當我們執行這個程式碼時，它會讀取檔案內容，並以十六進位制格式顯示。每行顯示 16 個 byte，如果 byte 的值為 0x00，它會顯示為一個點 (.)；如果 byte 的值為 0xff，它會顯示為一個井字 (##）；否則，它會顯示為 byte 的十六進位制值。

內容解密

這個程式碼使用 match 陳述式來處理讀取到的內容，根據 byte 的值進行不同的處理。這種方法可以讓我們根據 byte 的值進行不同的操作，例如印出不同的字元或執行不同的函式。

圖表翻譯

以下是這個程式碼的流程圖：

  flowchart TD
    A[開啟檔案] --> B[讀取檔案內容]
    B --> C[處理讀取到的內容]
    C --> D[印出十六進位制值]
    D --> E[更新位置]
    E --> F[重複步驟 B]

這個流程圖顯示了程式碼的執行流程，從開啟檔案到讀取檔案內容、處理讀取到的內容、印出十六進位制值、更新位置，然後重複這個過程。

檔案操作在 Rust

Rust 提供了多種方式來進行檔案操作，包括開啟、讀取和寫入檔案。在本文中，我們將探討一些有用的技術，提供更細緻的控制。

7.4.1 在 Rust 中開啟檔案和控制檔案模式

檔案是由作業系統 (OS) 維護的抽象概念，它呈現了一個名稱和層次結構在原始位元組上。檔案還提供了一層安全性，具有附加的許可權，作業系統會強制執行這些許可權。

std::fs::File 是與檔案系統互動作用的主要型別。有兩種方法可以用來建立檔案：open() 和 create()。當您知道檔案已經存在時，使用 open()。表 7.3 說明瞭它們之間的更多差異。

當您需要更多控制時，std::fs::OpenOptions 可用。它提供了必要的控制項，以滿足任何預期應用。清單 7.16 提供了一個很好的示例，展示了附加模式的請求。應用程式需要一個可寫入且可讀取的檔案，如果它不存在，則會建立它。

let f = OpenOptions::new()
   .read(true)
   .write(true)
   .create(true)
   .append(true)
   .open(path)?;

7.4.2 使用 `std::fs::Path` 以型別安全的方式與檔案系統互動

Rust 提供了 str 和 String 的型別安全變體：std::path::Path 和 std::path::PathBuf。您可以使用這些變體以跨平臺方式無歧義地與路徑分隔符合作。Path 可以解析檔案、目錄和相關抽象概念，例如符號連結。Path 和 PathBuf 值通常以普通字串型別開始，它們可以使用 from() 靜態方法進行轉換：

let hello = PathBuf::from("/tmp/hello.txt")

從那裡開始，與這些變體互動會顯示特定於路徑的方法：

內容解密：

上述程式碼展示瞭如何使用 OpenOptions 來開啟一個檔案，並控制其檔案模式。OpenOptions 提供了多種方法來設定檔案的許可權和行為，例如 read()、write()、create() 和 append()。這些方法可以用來建立一個可讀取和可寫入的檔案，如果檔案不存在，則會建立它。

圖表翻譯：

以下是使用 Mermaid 語法繪製的流程圖，展示瞭如何使用 OpenOptions 來開啟一個檔案：

  flowchart TD
    A[開始] --> B[建立 OpenOptions 例項]
    B --> C[設定 read 和 write 許可權]
    C --> D[設定 create 和 append 許可權]
    D --> E[開啟檔案]
    E --> F[檢查檔案是否存在]
    F --> G[如果檔案不存在，建立它]
    G --> H[傳回檔案控制程式碼]

這個流程圖展示瞭如何使用 OpenOptions 來開啟一個檔案，並控制其檔案模式。它還展示瞭如何檢查檔案是否存在，如果不存在，則會建立它。

檔案系統操作：Rust 的檔案建立與寫入

在 Rust 中，檔案的建立和寫入可以透過 std::fs 模組實作。以下是使用 OpenOptions 來建立可寫入檔案的示例。

建立檔案

當您需要建立一個新檔案時，可以使用 OpenOptions 的 create 方法。這個方法會在指定路徑不存在檔案時建立一個新檔案。如果檔案已經存在，則會截斷其內容並重新開啟。

use std::fs::OpenOptions;

fn main() {
    let file_path = "example.txt";
    let file = OpenOptions::new()
       .write(true) // 啟用寫入模式
       .create(true) // 如果檔案不存在則建立
       .open(file_path)
       .expect("Failed to open file");

    // 現在您可以使用 file 進行寫入操作
}

寫入檔案

一旦您開啟了檔案，就可以使用 Write 特徵（trait）將內容寫入檔案中。以下是如何將字串寫入檔案的示例：

use std::fs::OpenOptions;
use std::io::Write;

fn main() {
    let file_path = "example.txt";
    let mut file = OpenOptions::new()
       .write(true)
       .create(true)
       .open(file_path)
       .expect("Failed to open file");

    let content = "Hello, World!";
    file.write_all(content.as_bytes())
       .expect("Failed to write to file");
}

檔案操作選項

OpenOptions 提供了多種方法來設定檔案操作的行為，包括：

read: 啟用讀取模式。
write: 啟用寫入模式。
create: 如果檔案不存在則建立。
truncate: 如果檔案已經存在，則截斷其內容。
append: 以追加模式開啟檔案。

這些方法可以根據您的需求組合使用，以實作不同的檔案操作。

內容解密：

上述程式碼示例展示瞭如何使用 OpenOptions 來建立和寫入檔案。首先，我們匯入了必要的模組，然後使用 OpenOptions 的方法設定檔案操作的行為。最後，我們使用 write_all 方法將內容寫入檔案中。這個過程展示了 Rust 中檔案操作的基本步驟和相關的安全考量。

圖表翻譯：

  flowchart TD
    A[開始] --> B[設定檔案操作選項]
    B --> C[開啟檔案]
    C --> D[寫入內容]
    D --> E[完成]

此圖表展示了檔案操作的基本流程，從設定選項到開啟檔案、寫入內容，直到完成。這個過程強調了每一步驟的重要性，以確保檔案操作的正確性和安全性。

從檔案處理效能最佳化的角度來看，Rust 的序列化函式庫與檔案系統操作的結合，展現了其在處理大量資料時的優勢。serde 框架的靈活性，搭配 bincode、cbor、json 等不同序列化格式，讓開發者能依據資料特性與應用場景，選擇最合適的方案，在序列化速度、檔案大小、跨語言支援性之間取得平衡。然而，選擇序列化函式庫時，需考量資料結構的複雜度以及目標平臺的資源限制，例如嵌入式系統的記憶體容量。

深入分析 Rust 的檔案 I/O 操作，可以發現 OpenOptions 與 Path 等 API 的設計，在兼顧效能的同時，也提升了檔案操作的安全性與跨平臺相容性。OpenOptions 提供了精細的檔案開啟選項控制，讓開發者能明確指定讀寫許可權、建立或截斷行為，有效避免不必要的錯誤與安全風險。Path 和 PathBuf 則提供了型別安全的路徑操作，簡化了跨平臺檔案系統的處理。儘管如此，在處理大量檔案或高併發場景時，仍需注意潛在的效能瓶頸，例如檔案鎖定和系統呼叫的開銷。

展望未來，隨著 Rust 語言的持續發展，預期會有更多針對檔案處理和序列化效能最佳化的工具和技術出現。例如，非同步 I/O 的應用將進一步提升檔案讀寫的效率，而零複製序列化技術則有望減少資料複製的次數，降低 CPU 和記憶體的負擔。此外，結合 SIMD 指令集的序列化函式庫，將在特定資料型別上展現更強大的效能優勢。

對於追求極致效能的應用程式，玄貓建議深入研究不同序列化函式庫的底層實作，並根據實際需求進行基準測試，以選擇最佳方案。同時，善用 Rust 的型別系統和錯誤處理機制，確保檔案操作的安全性和穩定性。唯有如此，才能充分發揮 Rust 在檔案處理領域的效能優勢。

玄貓

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

Rust 序列化與反序列化及檔案處理實務技巧

序列化函式庫的選擇

定義可序列化的結構

序列化為不同格式

內容解密：

圖表翻譯：

內容解密：

序列化與反序列化技術的應用

Rust 中的序列化與反序列化

序列化與反序列化的應用

實作 Hexdump 的複製品

實作 fview

fview 的原始碼

fview 的輸出

std::io::prelude 的匯入

多行字串常數

fview 的實作

讀取檔案內容並以十六進位制格式顯示

程式碼

內容解密：

圖表翻譯：

擴充套件 fview 的功能以讀取真實檔案

基本的 hexdump 工具

主要函式

讀取檔案內容

處理 byte

完整程式碼

圖表翻譯：

讀取檔案內容並以十六進位制格式顯示

程式碼解釋

執行結果

內容解密

圖表翻譯

檔案操作在 Rust

7.4.1 在 Rust 中開啟檔案和控制檔案模式

7.4.2 使用 std::fs::Path 以型別安全的方式與檔案系統互動

內容解密：

圖表翻譯：

檔案系統操作：Rust 的檔案建立與寫入

建立檔案

寫入檔案

檔案操作選項

內容解密：

圖表翻譯：

玄貓

7.4.2 使用 `std::fs::Path` 以型別安全的方式與檔案系統互動