Rust के लिए CLI फ्रेमवर्क: कमांड लाइन उपयोगिताएँ बनाने के लिए सर्वश्रेष्ठ उपकरणों का अवलोकन

Rust के लिए CLI फ्रेमवर्क: कंसोल एप्लिकेशन बनाने के लिए शक्तिशाली उपकरण

Rust एक सिस्टम प्रोग्रामिंग भाषा है जो अपनी प्रदर्शन क्षमता, सुरक्षा और आधुनिक सुविधाओं के कारण लोकप्रियता प्राप्त कर रही है। Rust का सबसे आम उपयोग कमांड लाइन उपयोगिताएँ (CLI) बनाना है। ripgrep से लेकर bat और fd तक - कई प्रसिद्ध उपकरण Rust में लिखे गए हैं। इस लेख में, हम Rust के लिए मुख्य CLI फ्रेमवर्क की समीक्षा करेंगे जो आपको अपने स्वयं के कंसोल एप्लिकेशन को जल्दी और गुणवत्तापूर्ण तरीके से विकसित करने में मदद करेंगे।

CLI के लिए Rust को क्यों चुनें?

Rust CLI विकास के लिए कई प्रमुख लाभ प्रदान करता है:

• तेज़ प्रदर्शन — संकलित कोड न्यूनतम ओवरहेड के साथ चलता है।
• मेमोरी सुरक्षा — स्वामित्व प्रणाली (ownership) मेमोरी लीक और डेटा रेस को रोकती है।
• क्रॉस-प्लेटफ़ॉर्म समर्थन — एक कोड बेस Windows, macOS और Linux पर काम करता है।
• पारिस्थितिकी तंत्र — आर्गुमेंट पार्सिंग, रंगीन आउटपुट, कॉन्फ़िगरेशन प्रबंधन के लिए समृद्ध लाइब्रेरी सेट।

Rust के लिए मुख्य CLI फ्रेमवर्क

1. Clap (Command Line Argument Parser)

Clap Rust में कमांड लाइन आर्गुमेंट पार्स करने के लिए सबसे लोकप्रिय और कार्यात्मक फ्रेमवर्क है। यह स्वचालित सहायता निर्माण, सुझाव, मान्यता, उप-कमांड और बहुत कुछ का समर्थन करता है।

use clap::{Parser, Subcommand};

#[derive(Parser)]#[command(name = "git")]#[command(about = "A fictional version of git", long_about = None)]struct Cli {    #[command(subcommand)]    command: Commands,}

#[derive(Subcommand)]enum Commands {    /// Clone a repository    Clone {        /// URL of the repository        url: String,    },    /// Push changes    Push {        /// Remote name        remote: String,        /// Branch name        branch: String,    },}

fn main() {    let cli = Cli::parse();    match &cli.command {        Commands::Clone { url } => println!("Cloning from {}", url),        Commands::Push { remote, branch } => println!("Pushing to {} branch {}", remote, branch),    }}

Clap दो दृष्टिकोण प्रदान करता है: घोषणात्मक (derive मैक्रोज़ के माध्यम से) और कार्यात्मक (Builder API के माध्यम से)। अधिकांश प्रोजेक्ट्स के लिए derive दृष्टिकोण का उपयोग करने की अनुशंसा की जाती है - यह छोटा और अधिक पठनीय है।

2. StructOpt

StructOpt Clap के ऊपर एक परत है जो आपको स्ट्रक्चर के माध्यम से आर्गुमेंट परिभाषित करने की अनुमति देता है। संस्करण 3.0 से, Clap ने StructOpt की कार्यक्षमता को सीधे शामिल कर लिया है, इसलिए अब StructOpt को पुराना माना जाता है। हालाँकि, कई पुराने प्रोजेक्ट अभी भी इसका उपयोग करते हैं।

use structopt::StructOpt;

#[derive(StructOpt)]struct Cli {    #[structopt(short = 'n', long = "name")]    name: String,    #[structopt(short = 'c', long = "count", default_value = "1")]    count: u32,}

fn main() {    let args = Cli::from_args();    for _ in 0..args.count {        println!("Hello, {}!", args.name);    }}

महत्वपूर्ण: नए प्रोजेक्ट्स के लिए derive मैक्रोज़ के साथ Clap का उपयोग करें - यह आधुनिक और समर्थित विकल्प है।

3. Argh

Argh एक हल्का और तेज़ फ्रेमवर्क है जो न्यूनतमता पर केंद्रित है। इसे स्वयं के अलावा किसी अतिरिक्त निर्भरता की आवश्यकता नहीं है और यह बहुत तेज़ी से संकलित होता है। छोटी उपयोगिताओं के लिए आदर्श है।

use argh::FromArgs;

#[derive(FromArgs)]/// A simple greeting toolstruct Greeting {    /// name to greet    #[argh(option, short = 'n')]    name: String,

    /// number of times to greet    #[argh(option, short = 'c', default = "1")]    count: u32,}

fn main() {    let greeting: Greeting = argh::from_env();    for _ in 0..greeting.count {        println!("Hello, {}!", greet