Rust में कमांड लाइन आर्गुमेंट्स: शुरुआती के लिए पूरी गाइड

Rust में कमांड लाइन आर्गुमेंट्स कैसे पास और प्रोसेस करें?

जिसने भी Python में कंसोल यूटिलिटीज लिखी हैं, वह जानता है कि sys.argv के जरिए पैरामीटर्स प्राप्त करना कितना आसान है। लेकिन जब आप Rust पर आते हैं — एक सिस्टम प्रोग्रामिंग भाषा जो स्पीड और सुरक्षा का वादा करती है — तो एक स्वाभाविक सवाल उठता है: "Rust में कमांड लाइन पैरामीटर्स कैसे एक्सेस करें?"

यह सवाल Stack Overflow पर सबसे लोकप्रिय सवालों में से एक है (हजारों व्यूज), और यह कोई संयोग नहीं है। Rust कमांड लाइन आर्गुमेंट्स के साथ काम करने के लिए तीन मुख्य तरीके प्रदान करता है। सबसे सरल std::env::args() से लेकर clap और structopt जैसी पावरफुल लाइब्रेरीज तक। इस लेख में हम प्रैक्टिकल उदाहरणों के साथ प्रत्येक तरीके को समझेंगे, ताकि आप अपने काम के लिए सही टूल चुन सकें।

यह क्यों जरूरी है?

कमांड लाइन आर्गुमेंट्स के साथ काम करना Rust डेवलपर के लिए एक बुनियादी स्किल है। इसके बिना आप ये नहीं बना सकते:

\n
• CLI-यूटिलिटीज (जैसे grep, find या अपना खुद का डिप्लॉय स्क्रिप्ट);
\n
• सर्वर एप्लिकेशन जो फ्लैग्स के जरिए कॉन्फिगर होते हैं;
\n
• ऑटोमेशन और DevOps के लिए टूल्स।
\n

चलिए सबसे सरल तरीके से शुरू करते हैं, फिर धीरे-धीरे प्रोफेशनल सॉल्यूशंस की ओर बढ़ते हैं।

तरीका 1: std::env::args() — न्यूनतम दृष्टिकोण

Rust में कमांड लाइन आर्गुमेंट्स प्राप्त करने का सबसे आसान तरीका स्टैंडर्ड फंक्शन std::env::args() का उपयोग करना है। यह स्ट्रिंग्स का एक इटरेटर लौटाता है, जहां पहला एलिमेंट एग्जीक्यूटेबल फाइल का पथ होता है, और बाकी पास किए गए पैरामीटर होते हैं।

use std::env;\n\nfn main() {\n    let args: Vec<String> = env::args().collect();\n    \n    // पहला आर्गुमेंट हमेशा प्रोग्राम का नाम होता है\n    println!("प्रोग्राम का पथ: {}", args[0]);\n    \n    // बाकी यूज़र के आर्गुमेंट्स\n    if args.len() > 1 {\n        println!("पास किए गए आर्गुमेंट्स:");\n        for (i, arg) in args[1..].iter().enumerate() {\n            println!("  आर्गुमेंट {}: {}", i + 1, arg);\n        }\n    } else {\n        println!("कोई आर्गुमेंट पास नहीं किया गया।");\n    }\n}

हमारा प्रोग्राम चलाएं:

$ cargo run -- hello world 42\nप्रोग्राम का पथ: ./target/debug/myapp\nपास किए गए आर्गुमेंट्स:\n  आर्गुमेंट 1: hello\n  आर्गुमेंट 2: world\n  आर्गुमेंट 3: 42

फायदे: न्यूनतम कोड, कोई डिपेंडेंसी नहीं, पूरा कंट्रोल।

नुकसान: फ्लैग्स (जैसे --name या -v) को मैन्युअली हैंडल करना, टाइप चेकिंग नहीं (सभी आर्गुमेंट्स स्ट्रिंग हैं), कोई बिल्ट-इन --help नहीं।

यह तरीका त्वरित स्केचेस या जब आपके पास बिल्कुल एक अनिवार्य आर्गुमेंट हो, तब बढ़िया काम करता है। लेकिन गंभीर प्रोजेक्ट्स के लिए विकल्पों पर विचार करें।

env::args_os() का विकल्प

अगर आपको रॉ बाइट्स चाहिए (जैसे गैर-UTF8 फाइल नामों के लिए), तो std::env::args_os() का उपयोग करें। यह String के बजाय OsString लौटाता है:

use std::env;\nuse std::ffi::OsString;\n\nfn main() {\n    let args: Vec<OsString> = env::args_os().collect();\n    println!("पहला आर्गुमेंट (OsString): {:?}", args[0]);\n}

तरीका 2: clap क्रेट — डिक्लेरेटिव पार्सिंग

जब प्रोजेक्ट बड़ा होता है, तो मैन्युअल आर्गुमेंट पार्सिंग बग्स का स्रोत बन जाता है। यहां मदद करता है clap — Rust इकोसिस्टम में कमांड लाइन के लिए सबसे लोकप्रिय क्रेट। यह आपको सभी पैरामीटर्स, फ्लैग्स और सबकमांड्स को डिक्लेरेटिव तरीके से डिफाइन करने देता है।

Cargo.toml में जोड़ें:

[dependencies]\nclap = { version = "4.5", features = ["derive"] }

अब derive-मैक्रोज़ का उपयोग करते हुए उदाहरण (अनुशंसित तरीका):

use clap::Parser;\n\n/// clap प्रदर्शित करने के लिए सरल प्रोग्राम\n#[derive(