Rust में YAML के साथ काम: serde_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"

serde_yaml लाइब्रेरी अपने आप YAML पार्सिंग और जनरेशन के लिए ज़रूरी सभी कंपोनेंट्स ला देगी।

बेसिक डीसीरियलाइज़ेशन (YAML → Rust स्ट्रक्चर)

सबसे आम उपयोग कॉन्फ़िगरेशन फ़ाइल पढ़ना है। YAML डॉक्यूमेंट के अनुसार एक स्ट्रक्चर डिफ़ाइन करें:

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Config {
    server: ServerConfig,
    database: DatabaseConfig,
}

#[derive(Debug, Deserialize)]
struct ServerConfig {
    host: String,
    port: u16,
    workers: Option<u32>,
}

#[derive(Debug, Deserialize)]
struct DatabaseConfig {
    url: String,
    pool_size: u32,
}

अब YAML फ़ाइल पढ़कर उसे स्ट्रक्चर में बदलें:

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let yaml_content = fs::read_to_string("config.yaml")?;
    let config: Config = serde_yaml::from_str(&yaml_content)?;
    
    println!("सर्वर: {}:{}", config.server.host, config.server.port);
    println!("डेटाबेस: {}", config.database.url);
    
    Ok(())
}

config.yaml फ़ाइल का उदाहरण:

server:
  host: "127.0.0.1"
  port: 8080
  workers: 4
database:
  url: "postgres://user:pass@localhost/db"
  pool_size: 10

सीरियलाइज़ेशन (Rust स्ट्रक्चर → YAML)

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

use serde::Serialize;

#[derive(Debug, Serialize)]
struct Project {
    name: String,
    version: String,
    dependencies: Vec<Dependency>,
}

#[derive(Debug, Serialize)]
struct Dependency {
    name: String,
    version: String,
    optional: bool,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let project = Project {
        name: "my-app".to_string(),
        version: "0.1.0".to_string(),
        dependencies: vec![
            Dependency {
                name: "serde".to_string(),
                version: "1.0".to_string(),
                optional: false,
            },
            Dependency {
                name: "tokio".to_string(),
                version: "1.35".to_string(),
                optional: true,
            },
        ],
    };

    let yaml_string = serde_yaml::to_string(&project)?;
    println!("{}", yaml_string);
    
    // फ़ाइल में सेव करें
    std::fs::write("project.yaml", &yaml_string)?;
    
    Ok(())
}

मनमाने YAML डॉक्यूमेंट्स के साथ काम

कभी-कभी YAML की स्ट्रक्चर पहले से पता नहीं होती। ऐसे में serde_yaml::Value का उपयोग करें:

use serde_yaml::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let yaml_data = "
apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app: web
spec:
  ports:
    - port: 80
      targetPort: 8080
  selector:
    app: web
";
    
    let value: Value = serde_yaml::from_str(yaml_data)?;
    
    // नेस्टेड डेटा तक पहुँच
    if let Some(ports) = value["spec"]["ports"].as_sequence() {
        for port in ports {
            if let Some(port_num) = port["port"].as_u64() {
                println!("पोर्ट: {}", port_num);
            }
        }
    }
    
    // डेटा में बदलाव