نحوه کار با فایل های TOML در Rust

با این راهنمای جامع، نحوه مدیریت موثر فایل های TOML در Rust را بیاموزید.

فایل‌های پیکربندی نقش مهمی در توسعه نرم‌افزار و مدیریت سیستم برای سفارشی‌سازی و تنظیم دقیق رفتار نرم‌افزار ایفا می‌کنند تا آنها را با محیط‌های مختلف و ترجیحات کاربر سازگار کند. انواع مختلفی از فایل های پیکربندی مانند YAML و TOML وجود دارد.

TOML (زبان حداقلی واضح تام) به عنوان یک گزینه قدرتمند و کاربرپسند در میان فرمت‌های فایل پیکربندی متعدد برای نحو آن و نحوه رفع کاستی‌های قالب‌های فایل پیکربندی موجود برای ارائه جایگزینی بصری‌تر و ساده‌تر متمایز است.

آشنایی با فایل TOML

در هسته خود، فرمت فایل TOML داده های ساختار یافته را در قالبی قابل خواندن برای انسان بیان می کند. TOML خود را با طراحی مینیمالیستی و شهودی خود به دنبال ساختار جفت کلید-مقدار متمایز می کند که در آن هر کلید یک گزینه پیکربندی مرتبط با مقداری را نشان می دهد که تنظیمات آن را تعیین می کند.

فرمت فایل TOML متکی بر قوانین نحوی ساده است که خوانایی را در اولویت قرار می دهد و آن را برای انسان و ماشین قابل دسترس می کند. یکی از ویژگی های قابل توجه TOML پشتیبانی آن از انواع داده ها از جمله رشته ها، اعداد صحیح، اعداد ممیز شناور، بولی ها، آرایه ها و جداول است.

تطبیق پذیری TOML به شما امکان می دهد پیکربندی های پیچیده را به راحتی بیان کنید تا طیف وسیع تری از موارد استفاده را در خود جای دهید. TOML ویژگی ها و عملکردهای زیادی را ارائه می دهد که آن را به یک انتخاب ایده آل برای اهداف پیکربندی تبدیل می کند.

1. ساختار شهودی: TOML یک ساختار سلسله مراتبی متشکل از جداول، جفت‌های کلید-مقدار و آرایه‌ها را اتخاذ می‌کند. سازمان TOML امکان نمایش واضح و منطقی تنظیمات پیکربندی پیچیده را فراهم می کند.
2. نظرات و فضاهای خالی: TOML از نظرات درون خطی و چند خطی پشتیبانی می کند و به شما امکان می دهد فایل های پیکربندی خود را به طور موثر حاشیه نویسی و مستند کنید. فضاهای سفید عمدتاً برای اطمینان از خوانایی و کاهش نویزهای غیر ضروری نادیده گرفته می شوند.
3. تایپ قوی: هر مقدار در TOML با یک نوع داده خاص مرتبط است، از رشته ها گرفته تا اعداد صحیح، شناورها، بولی ها و تاریخ ها. اجرای تایپ قوی TOML به حفظ یکپارچگی داده ها برای پردازش بدون خطا کمک می کند.
4. پشتیبانی از ساختارهای تودرتو: TOML تودرتو کردن جداول در جداول را برای نمایش پیکربندی سلسله مراتبی تسهیل می کند. ساختارهای تودرتو در هنگام برخورد با تنظیمات چند بعدی یا تنظیمات پیچیده برنامه مفید هستند.
5. پشتیبانی از آرایه و جداول درون خطی: TOML آرایه ها و جداول درون خطی را برای انعطاف پذیری در بیان ساختارهای داده اضافی یا فشرده ارائه می دهد.

TOML از قوانین و قراردادهایی پیروی می کند که نحو و ساختار آن را تعریف می کند. این قالب برای نمایش داده‌های پیکربندی به جفت‌های تورفتگی و کلید-مقدار متکی است.

در اینجا یک مثال از یک فایل TOML ساده برای پیکربندی آمده است:

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

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

این فایل TOML دارای دو بخش است که شامل جفت‌های کلید-مقدار است که گزینه‌های پیکربندی خاصی را نشان می‌دهند. در اینجا، کلید پورت در بخش [server] شماره پورتی را در کلید میزبان مشخص می‌کند که نام میزبان سرور را مشخص می‌کند.

کار با فایل های TOML در Rust

Rust، زبانی که به ایمنی، عملکرد و تجربه توسعه‌دهنده افتخار می‌کند، فایل‌های TOML را به دلیل ادغام یکپارچه با اخلاق خود به عنوان فرمت پیکربندی خود انتخاب کرد.

شما می توانید تصمیم Rust برای استفاده از TOML را به چندین عامل کلیدی نسبت دهید. اول، TOML تعادل هماهنگی بین خوانایی و بیان برقرار می کند. علاوه بر این، رویکرد مینیمالیستی TOML تضمین می‌کند که از پیچیدگی‌های غیرضروری عاری است و با فلسفه طراحی Rust همسو می‌شود.

جعبه های شخص ثالث متعددی برای کار با فایل های TOML در اکوسیستم Rust وجود دارد که جعبه toml محبوب ترین آنها است.

جعبه toml پشتیبانی جامعی برای تجزیه، دستکاری و سریال سازی داده های TOML ارائه می دهد و آن را به ابزاری ضروری برای مدیریت فایل های پیکربندی و داده های ساختار یافته در برنامه های Rust تبدیل می کند.

برای کار با بسته های شخص ثالث در Rust، یک پروژه Rust با Cargo ایجاد کنید و این دستورالعمل را به بخش وابستگی ها در فایل Cargo.toml پروژه خود اضافه کنید تا جعبه toml را در پروژه های Rust خود نصب و استفاده کنید:

[dependencies]
toml = "0.5"

برای سریال‌سازی و سریال‌زدایی داده‌های TOML، به جعبه سرد نیاز دارید. جعبه toml به خوبی با serde برای پردازش داده ها کار می کند.

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

هنگامی که جعبه‌های toml و serde را به عنوان وابستگی اضافه کردید، می‌توانید آنها را به کد Rust خود وارد کنید و از عملکردهای آن استفاده کنید.

use toml;

جعبه toml می تواند فایل های TOML را بخواند، بنویسد و تجزیه کند.

خواندن فایل های TOML با زنگ

پس از افزودن جعبه toml به عنوان وابستگی پروژه و وارد کردن جعبه به پروژه خود، می توانید فایل های TOML را در برنامه های Rust خود بخوانید.

ابتدا باید فایل TOML را با ساختار داخلی fs crate’s File باز کنید:

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");

    // At this point, `contents` contains the content of the TOML file
    println!("{}", contents);
}

تابع main یک فایل cargo.toml را با متد File::open باز می کند و قبل از چاپ محتویات روی کنسول با println، محتویات فایل را با روش read_to_string در یک رشته می خواند! کلان.

خواندن محتویات یک فایل TOML به عنوان یک رشته مفید است، اما در بیشتر موارد، می‌خواهید داده‌ها را در قالب ساختار یافته‌تری بارگیری کنید. Rust به ما اجازه می دهد تا انواع ساختاری را تعریف کنیم که ساختار داده فایل های TOML ما را نشان می دهد. اکنون می توانید از جعبه toml برای جداسازی خودکار داده های TOML در این ساختارها استفاده کنید.

در اینجا می توانید محتوای فایل Cargo.toml پروژه خود را بخوانید و آنها را در کنسول چاپ کنید:

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);
}

ساختارهای CargoToml، Package، Dependencies و SerdeDependency ساختار فایل TOML را نشان می دهند. ساختارها با ویژگی های #[allow(dead_code)] حاشیه نویسی می شوند تا هشدارهای کد مرده را برای ساختارها غیرفعال کنند.

تابع اصلی محتویات فایل Cargo.toml را در متغیر toml_str می‌خواند و روش from_str جعبه toml رشته TOML را می‌خواند و محتویات را در متغیر cargo_toml جدا می‌کند.

در اینجا خروجی اجرای تابع اصلی است:

نوشتن داده ها در فایل های TOML با Rust

نوشتن داده ها در فایل های TOML برای تولید فایل های پیکربندی از برنامه های شما مفید است.

در اینجا نحوه سریال سازی یک ساختار در TOML و نوشتن محتویات در یک فایل config.toml در دایرکتوری ریشه پروژه آمده است:

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.");
    }
}

تابع write_config_to_file به نمونه ای از ساختار ServerConfig اشاره دارد و مسیر فایل برای فایل config.toml نمونه ساختار را به رشته تبدیل می کند و فایل config.toml را در مسیر فایل مشخص شده ایجاد می کند. در نهایت با استفاده از تابع write_all رشته TOML را در فایل TOML می نویسد.

تابع اصلی یک شی struct ServerConfig را مقداردهی اولیه می کند، write_config_to_file را با داده های لازم فراخوانی می کند و یک پیام را بر اساس وضعیت عملیات به کنسول چاپ می کند.

Cargo از فایل های TOML برای مدیریت وابستگی استفاده می کند

Cargo، مدیر وابستگی Rust و ابزار ساخت، از فایل‌های TOML برای تعیین و مدیریت وابستگی‌ها استفاده می‌کنند.

هنگامی که یک پروژه Rust جدید با Cargo ایجاد می کنید، یک فایل Cargo.toml در فهرست اصلی پروژه شما ایجاد می کند که به عنوان مانیفست پروژه شما عمل می کند. در اینجا می‌توانید ابرداده‌ها، وابستگی‌ها، پیکربندی‌های ساخت و سایر تنظیمات پروژه خود را اعلام کنید.

منبع مقاله