Rust में YAML के साथ काम करना: serde_yaml लाइब्रेरी

Rust पर YAML के साथ काम करने का परिचय

YAML (YAML Ain't Markup Language) अपनी पठनीयता और लचीलेपन के कारण कॉन्फ़िगरेशन फ़ाइलों के लिए सबसे लोकप्रिय फ़ॉर्मेट में से एक है। Rust इकोसिस्टम में YAML के साथ काम करने के लिए क्रेट serde_yaml का उपयोग किया जाता है, जो शक्तिशाली सीरियलाइज़ेशन प्लेटफ़ॉर्म Serde पर बनाया गया है। यह लाइब्रेरी Rust स्ट्रक्चर को YAML में और वापस आसानी से बदलने की अनुमति देती है।

स्थापना और सेटअप

अपने Cargo.toml में निर्भरताएँ जोड़ें:

[dependencies]serde = { version = "1.0", features = ["derive"] }serde_yaml = "0.9"

प्रोजेक्ट अपडेट करने के बाद cargo build चलाएँ। लाइब्रेरी उपयोग के लिए तैयार है।

Rust में बेसिक YAML डीसीरियलाइज़ेशन

सबसे सरल उदाहरण देखें — YAML स्ट्रिंग को पढ़ना और उसे Rust स्ट्रक्चर में बदलना।

चरण 1: स्ट्रक्चर को परिभाषित करें

use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Config {    host: String,    port: u16,    debug: bool,}

चरण 2: YAML को पार्स करें

use serde_yaml;

fn main() -> Result<(), serde_yaml::Error> {    let yaml_str = r#"        host: "127.0.0.1"        port: 8080        debug: true    "#;

    let config: Config = serde_yaml::from_str(yaml_str)?;    println!("{:?}", config);    Ok(())}

आउटपुट: Config { host: "127.0.0.1", port: 8080, debug: true }

Rust स्ट्रक्चर का YAML में सीरियलाइज़ेशन

उल्टी प्रक्रिया — Rust डेटा को YAML स्ट्रिंग में बदलना:

use serde::Serialize;

#[derive(Debug, Serialize)]struct Server {    name: String,    ip: String,    ports: Vec<u16>,}

fn main() -> Result<(), serde_yaml::Error> {    let server = Server {        name: "web-server".into(),        ip: "10.0.0.1".into(),        ports: vec![80, 443, 22],    };

    let yaml = serde_yaml::to_string(&server)?;    println!("{}", yaml);    Ok(())}

परिणाम:

---name: web-serverip: 10.0.0.1ports:  - 80  - 443  - 22

नेस्टेड स्ट्रक्चर और टैग के साथ काम करना

YAML जटिल पदानुक्रमों का समर्थन करता है। Rust में यह नेस्टेड स्ट्रक्चर और एनुम पर मैप होता है:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Database {    #[serde(rename = "db")]    database: DbConfig,    pool_size: u32,}

#[derive(Debug, Serialize, Deserialize)]struct DbConfig {    host: String,    port: u16,    user: String,    password: String,}

fn main() -> Result<(), serde_yaml::Error> {    let yaml = r#"        db:          host: "localhost"          port: 5432          user: "admin"          password: "secret"        pool_size: 10    "#;

    let db: Database = serde_yaml::from_str(yaml)?;    println!("{:#?}", db);    Ok(())}

एट्रीब्यूट #[serde(rename = "db")] पर ध्यान दें — यह Rust फ़ील्ड को YAML में दूसरे नाम से मैप करने की अनुमति देता है।

त्रुटि प्रबंधन और वैकल्पिक फ़ील्ड

वास्तविक YAML फ़ाइलों में अक्सर वैकल्पिक पैरामीटर होते हैं। Option<T> का उपयोग करें:

#[derive(Debug, Deserialize)]struct AppConfig {    name: String,    version: String,    #[serde(default)]    features: Vec<String>,    #[serde(default = "default_timeout")]    timeout: u64,}

fn default_timeout() -> u64 {    30}

एट्रीब्यूट #[serde(default)] डिफ़ॉल्ट मान निर्दिष्ट करता है (Vec के लिए खाली वेक्टर, Option के लिए None)। timeout के उदाहरण की तरह एक जनरेटर फ़ंक्शन भी निर्दिष्ट किया जा सकता है।

फ़ाइल से YAML पढ़ना

व्यवहार में, कॉन्फ़िगरेशन फ़ाइलों में संग्रहीत होते हैं। पढ़ना सरलता से किया जाता है:

use std::fs;use serde_yaml;

fn main() -> Result<(), Box<dyn std::error::Error>