Rust में कमांड निष्पादित करना: 2025 में आउटपुट कैसे कैप्चर करें

Python से Rust तक: कमांड निष्पादन का विकास

यदि आपने कभी Stack Overflow पर "How do I invoke a system command and capture its output?" प्रश्न पूछा है, तो आप जानते हैं: यह किसी भी डेवलपर के लिए सबसे लोकप्रिय और महत्वपूर्ण प्रश्नों में से एक है। Python की दुनिया में, इसका सरल उत्तर है — subprocess.check_output()। लेकिन यदि आप Rust पर स्विच कर चुके हैं और केवल एक कमांड चलाना ही नहीं, बल्कि इसे सुरुचिपूर्ण, सुरक्षित और अधिकतम प्रदर्शन के साथ करना चाहते हैं, तो क्या करें?

Rust केवल "एक और भाषा" नहीं है। यह एक ऐसी प्रणाली है जहाँ हर बाइट नियंत्रण में है, और कमांड निष्पादन में त्रुटियाँ पूरे एप्लिकेशन को क्रैश नहीं करती हैं। 2025 में, जब सुरक्षा और गति डी-फैक्टो मानक बन गए हैं, Rust में उपप्रक्रियाओं के साथ सही ढंग से काम करना एक must-have कौशल है। आइए सर्वोत्तम अभ्यासों को समझें जो सिस्टम कमांड चलाने को एक दिनचर्या से कला में बदल देंगे।

std::process::Command: आपका स्विस आर्मी चाकू

Rust में कमांड निष्पादन का केंद्र मॉड्यूल std::process::Command है। यह बाहरी प्रोग्राम चलाने, उनके आउटपुट को कैप्चर करने और त्रुटियों को संभालने के लिए आवश्यक सब कुछ प्रदान करता है। Python के विपरीत, जहाँ subprocess कई विवरण छिपाता है, Rust आपको पूर्ण नियंत्रण देता है।

मूल उदाहरण: stdout कैप्चर करना

आइए क्लासिक से शुरू करें — echo "Hello, Rust!" कमांड चलाएँ और इसका आउटपुट कैप्चर करें:

use std::process::Command;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let output = Command::new("echo")\n        .arg("Hello, Rust!")\n        .output()?;\n\n    let stdout = String::from_utf8(output.stdout)?;\n    println!("कमांड का आउटपुट: {}", stdout);\n\n    Ok(())\n}\n

यहाँ क्या महत्वपूर्ण है? हम .output() का उपयोग करते हैं, जो एक Output संरचना लौटाता है। इसमें तीन फ़ील्ड हैं: stdout, stderr और status। ? पर ध्यान दें — यह त्रुटि प्रसार ऑपरेटर है, जो हमें भारी match ब्लॉक से बचाता है। Rust हमें संभावित विफलताओं को स्पष्ट रूप से संभालने के लिए बाध्य करता है: कमांड मौजूद नहीं हो सकती, उसके पास एक्सेस अधिकार नहीं हो सकते, या वह त्रुटि के साथ समाप्त हो सकती है।

stderr और रिटर्न कोड को संभालना

वास्तविक परिदृश्यों में, आपको केवल stdout ही नहीं, बल्कि stderr की भी आवश्यकता होती है। कल्पना करें कि आप ls /nonexistent चला रहे हैं — एक ऐसा कमांड जो निश्चित रूप से त्रुटि देगा:

use std::process::Command;\n\nfn main() {\n    let output = Command::new("ls")\n        .arg("/nonexistent")\n        .output()\n        .expect("कमांड निष्पादित करने में विफल");\n\n    if output.status.success() {\n        let stdout = String::from_utf8_lossy(&output.stdout);\n        println!("सफलता: {}", stdout);\n    } else {\n        let stderr = String::from_utf8_lossy(&output.stderr);\n        eprintln!("त्रुटि (कोड {}): {}", output.status.code().unwrap_or(-1), stderr);\n    }\n}\n

यहाँ हम String::from_utf8_lossy() का उपयोग करते हैं — बाइट्स को स्ट्रिंग में बदलने का एक सुरक्षित तरीका, जो अमान्य UTF-8 वर्णों को � से बदल देता है। यह महत्वपूर्ण है यदि कमांड के आउटपुट में बाइनरी डेटा है या अप्रत्याशित एन्कोडिंग का उपयोग किया गया है।

उन्नत तकनीकें: अतुल्यकालिकता और पाइप

2025 में, सिंक्रोनस कमांड निष्पादन पुराना हो गया है। आधुनिक एप्लिकेशनों को अतुल्यकालिकता की आवश्यकता होती है, खासकर यदि आप वेब सर्वर के साथ काम कर रहे हैं या एक साथ कई कमांड संसाधित कर रहे हैं। Rust अपने Tokio इकोसिस्टम के साथ एक सुरुचिपूर्ण समाधान प्रदान करता है।

Tokio के साथ अतुल्यकालिक आउटपुट कैप्चर

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

[dependencies]\ntokio = { version = "1", features = ["full"] }\n

अब कमांड को अतुल्यकालिक रूप से निष्पादित करें:

use tokio::process::Command;\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let output = Command::new("sleep")\n        .arg("2")\n        .output()\n