एक छोटा प्रोजेक्ट (Building a Simple Project in Rust)

इस अध्याय में, हम Rust में एक छोटे प्रोजेक्ट का निर्माण करेंगे। इसमें हम अब तक सीखी गई अवधारणाओं जैसे कि Cargo, Modules, Traits, और Generics का उपयोग करेंगे। यह प्रोजेक्ट आपको Rust में एक वास्तविक एप्लिकेशन विकसित करने की प्रक्रिया से परिचित कराएगा और यह समझने में मदद करेगा कि Rust के विभिन्न टूल्स और फीचर्स का उपयोग कैसे किया जाता है। प्रोजेक्ट का उद्देश्य आपको एक व्यावहारिक अनुभव देना है, ताकि आप अपने कौशल को बेहतर बना सकें।

Mini Project: एक CLI टूल (Building a Command-Line Tool in Rust)

इस मिनी प्रोजेक्ट में, हम एक Command-Line Interface (CLI) Tool बनाएंगे, जो उपयोगकर्ता को कुछ सरल ऑपरेशन करने की अनुमति देगा। यह प्रोजेक्ट आपको Rust के Cargo, Modules, Traits, और Generics के साथ काम करने का व्यावहारिक अनुभव देगा। हम एक ऐसा CLI टूल बनाएंगे जो टेक्स्ट खोज (text search) का कार्य करेगा, जिसमें उपयोगकर्ता एक फ़ाइल में किसी शब्द को खोज सकता है और इसे कमांड लाइन से चला सकता है।

प्रोजेक्ट का उद्देश्य (Project Objective)

हम एक छोटा CLI टूल बनाएंगे जिसका नाम होगा “Rusty Search”। इस टूल में निम्नलिखित कार्यक्षमता होगी:

1. उपयोगकर्ता एक टेक्स्ट फ़ाइल का नाम और खोजा जाने वाला शब्द कमांड लाइन पर पास करेगा।
2. प्रोग्राम फ़ाइल को पढ़ेगा और खोजे गए शब्द को हर लाइन में ढूंढेगा।
3. परिणामस्वरूप उन लाइनों को प्रदर्शित करेगा जिनमें खोजा गया शब्द मौजूद है।

प्रोजेक्ट की संरचना (Project Structure)

प्रोजेक्ट की फाइल संरचना कुछ इस प्रकार होगी:

rusty_search/
├── Cargo.toml
└── src/
    ├── main.rs
    └── lib.rs

चरण 1: Cargo प्रोजेक्ट बनाना (Creating the Cargo Project)

सबसे पहले, Cargo का उपयोग करके नया प्रोजेक्ट बनाएं:

cargo new rusty_search
cd rusty_search

यह आपके लिए प्रोजेक्ट फाइलें बनाएगा। अब आपके पास src/main.rs और Cargo.toml जैसी फाइलें होंगी।

चरण 2: आवश्यक क्रेट्स जोड़ना (Adding Required Crates)

इस प्रोजेक्ट में हमें फ़ाइल इनपुट-आउटपुट और कमांड-लाइन argument parsing के लिए कुछ क्रेट्स की आवश्यकता होगी। इसके लिए हम clap और fs का उपयोग करेंगे।

Cargo.toml फ़ाइल में निम्नलिखित dependencies जोड़ें:

[dependencies]
clap = { version = "4.0", features = ["derive"] }

यह clap क्रेट हमें कमांड लाइन arguments को आसानी से पार्स करने में मदद करेगा।

चरण 3: कमांड लाइन से इनपुट लेना (Taking Input from the Command Line)

अब, हम src/main.rs में कमांड लाइन से इनपुट लेना शुरू करेंगे।

use clap::Parser;
use std::fs;
use std::error::Error;

/// कमांड लाइन arguments के लिए Parser structure
#[derive(Parser)]
struct Config {
    query: String,
    filename: String,
}

fn main() -> Result<(), Box<dyn Error>> {
    let args = Config::parse();

    // फ़ाइल को पढ़ना
    let contents = fs::read_to_string(args.filename)?;

    // शब्द की खोज और परिणाम प्रिंट करना
    search(&args.query, &contents);

    Ok(())
}

/// टेक्स्ट में खोजे गए शब्द की खोज करना
fn search(query: &str, contents: &str) {
    for line in contents.lines() {
        if line.contains(query) {
            println!("{}", line);
        }
    }
}

यहाँ, हमने:

1. clap::Parser का उपयोग करके Config struct में कमांड लाइन arguments को पार्स किया है।
2. फ़ाइल से डेटा पढ़ने के लिए fs::read_to_string का उपयोग किया है।
3. एक search फ़ंक्शन बनाया है, जो हर लाइन में दिए गए शब्द की खोज करता है।

चरण 4: Modules में कोड विभाजित करना (Splitting Code into Modules)

कोड को अधिक संरचित बनाने के लिए, हम इसे Modules में विभाजित करेंगे। इसके लिए, हम lib.rs फ़ाइल में खोज से संबंधित लॉजिक को रखेंगे।

src/lib.rs:

use std::fs;
use std::error::Error;

/// Config struct जिसमें query और filename होते हैं
pub struct Config {
    pub query: String,
    pub filename: String,
}

impl Config {
    pub fn new(query: String, filename: String) -> Config {
        Config { query, filename }
    }
}

/// फ़ाइल पढ़ने और खोज शुरू करने के लिए फ़ंक्शन
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.filename)?;

    search(&config.query, &contents);

    Ok(())
}

/// टेक्स्ट में खोजे गए शब्द की खोज करना
fn search(query: &str, contents: &str) {
    for line in contents.lines() {
        if line.contains(query) {
            println!("{}", line);
        }
    }
}

अब हम main.rs फ़ाइल को update करेंगे:

src/main.rs:

use clap::Parser;
use rusty_search::Config;
use std::error::Error;

#[derive(Parser)]
struct Args {
    query: String,
    filename: String,
}

fn main() -> Result<(), Box<dyn Error>> {
    let args = Args::parse();

    let config = Config::new(args.query, args.filename);

    rusty_search::run(config)?;

    Ok(())
}

यह कोड अब modules का उपयोग करके संरचित हो गया है, जिससे प्रोजेक्ट अधिक modular और organized हो गया है।

चरण 5: प्रोजेक्ट को टेस्ट करना (Testing the Project)

अब हम इस CLI टूल को कमांड लाइन से चला सकते हैं।

आप प्रोजेक्ट को इस तरह से रन कर सकते हैं:

cargo run -- "खोज_शब्द" file.txt

यह प्रोग्राम उस टेक्स्ट फ़ाइल में दिए गए शब्द को खोजेगा और उस शब्द को शामिल करने वाली सभी लाइनों को कमांड लाइन पर प्रिंट करेगा।

चरण 6: प्रोजेक्ट का विस्तार (Enhancing the Project)

आप इस प्रोजेक्ट में और भी कई फीचर्स जोड़ सकते हैं, जैसे:

1. केस-संवेदनशील खोज (Case-sensitive search) और केस-असंवेदनशील खोज (Case-insensitive search) विकल्प।
2. Regex का उपयोग करके अधिक जटिल खोजें।
3. फ़ाइल के परिणाम को किसी अन्य फ़ाइल में लिखने का विकल्प।