Rust में CLI उपयोगिताएँ: एक शाम में अपना पहला टूल कैसे लिखें

Rust CLI-टूल्स के लिए आदर्श विकल्प क्यों है?

क्या आपने कभी सोचा है कि सभी आधुनिक DevOps-टूल्स — bat से लेकर ripgrep और fd तक — Rust में क्यों लिखे गए हैं? यह सिर्फ़ फैशन की बात नहीं है। Rust में CLI उपयोगिताएँ अविश्वसनीय रूप से तेज़, सुरक्षित और, सबसे अच्छी बात, उन्हें बिना किसी निर्भरता के एक छोटे बाइनरी में संकलित किया जा सकता है। कोई "क्या आपके पास Java स्थापित है?" या "Node.js के node_modules लाने तक प्रतीक्षा करें" नहीं। बस डाउनलोड करें — और तैयार।

इस लेख में हम शुरुआत से Rust में एक CLI उपयोगिता बनाएंगे। यह कोई अमूर्त "Hello, World!" नहीं होगा, बल्कि एक वास्तविक उपयोगी टूल होगा — एक लॉग विश्लेषक जो त्रुटियों को खोजता है, उनकी गिनती करता है और परिणामों को एक सुंदर रंगीन प्रारूप में प्रदर्शित करता है। और हाँ, हम इसे एक शाम में करेंगे।

हमें क्या चाहिए?

शुरू करने के लिए न्यूनतम आवश्यकता:

\n
• Rust (यदि नहीं है तो rustup के माध्यम से स्थापित करें)
\n
• कोई भी कोड एडिटर (rust-analyzer प्लगइन के साथ VS Code — आदर्श)
\n
• कुछ घंटे का खाली समय
\n

यदि आपने पहले Python या Go में लिखा है, तो Rust आपको असामान्य लगेगा, लेकिन तार्किक। मुख्य बात — कंपाइलर से डरना नहीं है। वह बुरा नहीं है, वह बस देखभाल करने वाला है।

चरण 1: प्रोजेक्ट बनाएँ

टर्मिनल खोलें और लिखें:

cargo new log-scanner\ncd log-scanner

Cargo — यह हमारा स्विस आर्मी चाकू है। इसने Cargo.toml (निर्भरता फ़ाइल) और src/main.rs (प्रवेश बिंदु) के साथ एक बुनियादी संरचना बनाई। अब आप cargo run चला सकते हैं और "Hello, world!" देख सकते हैं। लेकिन हम आगे बढ़ेंगे।

Cargo.toml खोलें और निर्भरताएँ जोड़ें जो हमारे कोड को एक वास्तविक CLI उपयोगिता में बदल देंगी:

[dependencies]\nclap = { version = "4.5", features = ["derive"] }\ncolored = "2.1"\nanyhow = "1.0"

\n
• clap — कमांड लाइन आर्गुमेंट पार्सिंग (इसके बिना काम नहीं चलेगा)
\n
• colored — टर्मिनल में रंगीन आउटपुट
\n
• anyhow — सुविधाजनक त्रुटि प्रबंधन
\n

चरण 2: आर्गुमेंट संरचना परिभाषित करें

clap में सबसे अच्छी बात derive-मैक्रोज़ हैं। आप बस संरचना का वर्णन करते हैं, और जादू अपने आप हो जाता है। यह इस तरह दिखता है:

use clap::Parser;\n\n#[derive(Parser)]\n#[command(name = "log-scanner")]\n#[command(about = "लॉग-फ़ाइलों को स्कैन करता है और त्रुटियाँ खोजता है")]\nstruct Cli {\n    /// लॉग-फ़ाइल का पथ\n    file: String,\n\n    /// खोजने के लिए स्ट्रिंग (डिफ़ॉल्ट "ERROR")\n    #[arg(short, long, default_value = "ERROR")]\n    pattern: String,\n\n    /// केवल मिली पंक्तियों की संख्या दिखाएँ\n    #[arg(short, long)]\n    count: bool,\n}

ध्यान दें: तीन स्लैश /// वाली टिप्पणियाँ स्वचालित रूप से --help में संकेत बन जाती हैं। cargo run -- --help चलाएँ — और आप एक साफ-सुथरी स्वचालित रूप से उत्पन्न सहायता देखेंगे। यह उन कारणों में से एक है कि Rust में CLI बनाना इतना सुखद क्यों है: दस्तावेज़ीकरण अपने आप लिखा जाता है।

चरण 3: खोज तर्क लिखें

अब सबसे दिलचस्प भाग — फ़ाइल पढ़ना और मिलान खोजना। Rust फ़ाइलों और मेमोरी के साथ अपने सुरक्षित काम के लिए प्रसिद्ध है, लेकिन व्यवहार में यह बस सुविधाजनक है:

use std::fs::File;\nuse std::io::{BufRead, BufReader};\nuse colored::*;\nuse anyhow::Result;\n\nfn scan_log(file_path: &str, pattern: &str, count_only: bool) -> Result<()> {\n    let file = File::open(file_path)?;\n    let reader = BufReader::new(file);\n    let mut total_matches = 0;\n\n    for (line_num, line) in reader.lines().enumerate() {\n        let line = line?;\n        if line.contains(pattern) {\n            total_matches += 1;\n            if !count_only {\n                println!(\n                    "{}:{} {}",\n                    format!("{:>4}", line_num + 1).blue(),\n                    patt