Cách làm việc với file TOML trong Rust

TOML là một lựa chọn mạnh mẽ và “thân thiện người dùng” trong số các định dạng file cấu hình. Hãy cùng Quantrimang.com học cách xử lý file TOML hiệu quả trong Rust qua hướng dẫn toàn diện này nhé!

Cấu hình file đóng vai trò quan trọng trong phát triển phần mềm và quản trị hệ thống để cấu hình và tinh chỉnh hoạt động phần mềm nhằm khiến chúng có thể thích ứng với các môi trường cùng cấu hình người dùng khác nhau. Hiện có nhiều kiểu file cấu hình như YAML và TOML.

TOML (Tom’s Obvious Minimal Language) nổi bật trong định dạng file cấu hình bởi cú pháp và cách nó xử lý những thiếu sót của định dạng file cấu hình hiện tại để cung cấp một lựa chọn thay thế trực quan, đơn giản hơn.

File TOML là gì?

Về bản chất, định dạng tệp TOML thể hiện dữ liệu có cấu trúc ở định dạng mà con người có thể đọc được. TOML tự phân biệt với thiết kế tối giản và trực quan theo cấu trúc cặp khóa-giá trị trong đó mỗi khóa đại diện cho một tùy chọn cấu hình được liên kết với một giá trị xác định cài đặt của nó.

Định dạng file TOML dựa vào những quy tắc cú pháp đơn giản, ưu tiên khả năng đọc, giúp con người và máy móc có thể truy cập. Một tính năng nổi bật của TOML là hỗ trợ nhiều kiểu dữ liệu khác nhau, bao gồm chuỗi, số nguyên, số thực dấu chấm động, boolean, mảng và bảng.

Tính linh hoạt của TOML cho phép bạn dễ dàng thể hiện các cấu hình phức tạp để phù hợp với nhiều trường hợp sử dụng hơn. TOML cung cấp nhiều đặc điểm và chức năng, khiến nó trở thành lựa chọn lý tưởng cho mục đích cấu hình.

• Cấu trúc trực quan.
• Hỗ trợ bình luận và khoảng trắng.
• Kiểu nhập dữ liệu mạnh mẽ.
• Hỗ trợ các cấu trúc lồng nhau.
• Hỗ trợ mảng và bảng nội tuyến.

TOML tuân thủ các quy tắc và quy ước xác định cú pháp và cấu trúc của nó. Định dạng này dựa vào các cặp khóa - giá trị và thụt dòng để đại diện cho dữ liệu cấu hình.

Đây là một ví dụ cấu hình của file TOML đơn giản:

[server]
port = 8080
host = "localhost"
debug = false

[database]
name = "mydatabase"
username = "admin"
password = "secretpassword"

File TOML này có hai phần chứa cặp khóa-giá trị đại diện cho các lựa chọn cấu hình cụ thể. Tại đây, khóa port trong phần [server] chỉ một số cổng trên khóa host chỉ định hostname của máy chủ.

Làm việc với file TOML trong Rust

Rust, một ngôn ngữ tự hào về tính an toàn, hiệu suất và trải nghiệm của nhà phát triển, đã chọn các tệp TOML làm định dạng cấu hình do tích hợp liền mạch với đặc tính của nó.

Có thể bạn cho rằng quyết định của Rust dùng TOML là do một số nhân tố chính. Đầu tiên, TOML tạo ra sự cân bằng hài hòa giữa khả năng đọc và tính biểu cảm. Ngoài ra, cách tiếp cận tối giản của TOML đảm bảo nó không có sự phức tạp không cần thiết, phù hợp với triết lý thiết kế của Rust.

Hiện có nhiều crate bên thứ ba để làm việc với file TOML trong hệ sinh thái của Rust, trong đó crate toml là phổ biến nhất.

Crate toml cung cấp hỗ trợ toàn diện cho việc phân tích, xử lý và tuần tự hóa dữ liệu TOML, làm cho nó trở thành một công cụ không thể thiếu để xử lý các tệp cấu hình và dữ liệu có cấu trúc trong mỗi ứng dụng Rust.

Để làm việc với các gói bên thứ ba trong Rust, tạo một dự án Rust với Cargo và thêm lệnh này vào phần dependencies của file Cargo.toml trong dự án nhằm cài đặt và dùng crate toml ở các dự án Rust:

[dependencies]
toml = "0.5"

Đối với việc tuần tự hóa và giải tuần tự hóa dữ liệu TOML, bạn sẽ cần serde crate. Crate toml tương tác tốt với serde để xử lý dữ liệu.

[dependencies]
serde = { version = "1.0", features = ["derive"] }
toml = "0.5"

Sau khi bạn đã thêm crate toml và serde làm phần phụ thuộc, bạn có thể nhập chúng vào code Rust và sử dụng các chức năng của nó.

use toml;

Crate toml có thể đọc, viết và phân tích file TOML.

Đọc file TOML với Rust

Sau khi thêm crate toml làm phần phụ thuộc của dự án và nhập crate vào dự án, bạn có thể đọc file TOML trong những chương trình Rust.

Đầu tiên, bạn cần mở file TOML với struct File của crate fs:

use std::fs::File;
use std::io::Read;

fn main() {
    let mut file = File::open("config.toml").expect("Failed to open file");
    let mut contents = String::new();
    file.read_to_string(&mut contents)
        .expect("Failed to read file");

    // Tại thời điểm này, `contents` chứa nội dung của file TOML 
    println!("{}", contents);
}

Hàm main mở một file cargo.toml bằng phương thức File::open và đọc nội dung của file trong một chuỗi với reat_to_string trước khi in nội dung vào console bằng macro println!.

Đọc nội dung của file TOML dưới dạng chuỗi hữu ích nhưng trong hầu hết trường hợp, bạn muốn tải dữ liệu vào một định dạng có cấu trúc hơn. Rust cho phép xác định các kiểu cấu trúc đại diện cho cấu trúc dữ liệu của file TOML. Giờ bạn có thể dùng crate toml để tự động bỏ tuần tự hóa dữ liệu TOML thành những struct này.

Đây là cách bạn có thể đọc nội dung của file Cargo.toml trong dự án và in chúng vào console:

use serde::Deserialize;
use std::fs;

#[derive(Debug, Deserialize)]
struct CargoToml {
    #[allow(dead_code)] // Disable dead code warning for the entire struct
    package: Package,
    #[allow(dead_code)]
    dependencies: Dependencies,
}

#[derive(Debug, Deserialize)]
struct Package {
    #[allow(dead_code)]
    name: String,
    #[allow(dead_code)]
    version: String,
    #[allow(dead_code)]
    edition: String,
}

#[derive(Debug, Deserialize)]
struct Dependencies {
    #[allow(dead_code)]
    serde: SerdeDependency,
    #[allow(dead_code)]
    toml: String,
}

#[derive(Debug, Deserialize)]
struct SerdeDependency {
    #[allow(dead_code)]
    version: String,
    #[allow(dead_code)]
    features: Vec<String>,
}

fn main() {
    let toml_str = fs::read_to_string("Cargo.toml").expect("Failed to read Cargo.toml file");

    let cargo_toml: CargoToml = toml::from_str(&toml_str).expect("Failed to deserialize Cargo.toml");

    println!("{:#?}", cargo_toml);
}

Struct CargoToml, Package, Dependencies, và SerdeDependency đại diện cho cấu trúc của file TOML. Các cấu trúc được chú thích bằng thuộc tính #[allow(dead_code)] để vô hiệu hóa cảnh báo code chết cho struct.

Hàm main đọc nội dung của file Cargo.toml vào biến toml_str và phương thức from_str của crate toml đọc chuỗi TOML và giải tuần tự hóa nội dung vào biến cargo_toml.

Đây là kết quả của việc chạy hàm main:

Viết dữ liệu vào file TOML với Rust

Viết dữ liệu vào file TOML hữu ích trong việc tạo file cấu hình từ các chương trình của bạn.

Đây là cách tuần tự hóa một struct vào TOML và viết nội dung cho file config.toml trong thư mục gốc của dự án.

use std::fs::File;
use std::io::Write;
use serde::Serialize;
use toml::to_string;

#[derive(Serialize)]
struct ServerConfig {
    host: String,
    port: u16,
    timeout: u32,
}

fn write_config_to_file(config: &ServerConfig, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let toml_string = to_string(config)?;
    let mut file = File::create(file_path)?;
    file.write_all(toml_string.as_bytes())?;
    Ok(())
}

fn main() {
    let config = ServerConfig {
        host: "localhost".to_owned(),
        port: 8000,
        timeout: 30,
    };

    if let Err(e) = write_config_to_file(&config, "config.toml") {
        eprintln!("Error: {}", e);
    } else {
        println!("Config file created successfully.");
    }
}

Hàm write_config_to_file tham chiếu tới một phiên bản của struct ServerConfig và đường dẫn file cho tệp config.toml chuyển đổi phiên bản struct sang một chuỗi và tạo file config.toml trong đường dẫn file cụ thể. Cuối cùng, nó viết chuỗi TOML vào file TOML bằng hàm write_all.

Hàm main khởi tạo một đối tượng struct ServerConfig, gọi write_config_to_file với dữ liệu cần thiết, và in thông báo cho console dựa trên trạng thái hoạt động.

Trên đây là những điều cần biết về cách làm việc với file TOML trong Rust . Hi vọng bài viết hữu ích với các bạn.