Cargo और Modules (Working with Cargo and Modules in Rust)

Rust प्रोग्रामिंग में Cargo और Modules आपके प्रोजेक्ट को प्रबंधित और संरचित करने का मुख्य आधार हैं। Cargo Rust का पैकेज मैनेजर और प्रोजेक्ट बिल्ड सिस्टम है, जो dependencies, building, और testing को सरल बनाता है। Modules का उपयोग कोड को छोटे-छोटे हिस्सों में विभाजित करने और उसे व्यवस्थित करने के लिए किया जाता है। इस अध्याय में, हम Cargo के साथ काम करना, नए प्रोजेक्ट्स बनाना, dependencies प्रबंधित करना, और Modules के साथ कोड को organize करना सीखेंगे।

Cargo का उपयोग (Using Cargo to Manage Projects)

Rust में Cargo एक शक्तिशाली टूल है, जो आपके प्रोजेक्ट्स को प्रबंधित करने, dependencies को हैंडल करने, और कोड को build, run और test करने के लिए उपयोग किया जाता है। Cargo एक पैकेज मैनेजर और बिल्ड सिस्टम दोनों है, और अधिकांश Rust प्रोजेक्ट्स में इसका उपयोग किया जाता है। यह आपके Rust प्रोजेक्ट को आरंभ करने, प्रबंधित करने और उत्पादन के लिए तैयार करने में मदद करता है।

Cargo के प्रमुख फ़ीचर्स (Key Features of Cargo)

1. नया प्रोजेक्ट बनाना:
   • Cargo का उपयोग करके आप आसानी से नए Rust प्रोजेक्ट्स बना सकते हैं। यह आपके प्रोजेक्ट के लिए एक प्रारंभिक संरचना और आवश्यक फ़ाइलें बनाता है।
2. Dependencies प्रबंधित करना:
   • Cargo का सबसे महत्वपूर्ण फ़ीचर यह है कि यह आपके प्रोजेक्ट के external dependencies (लाइब्रेरियां) को प्रबंधित करता है। आप dependencies को Cargo.toml फ़ाइल में निर्दिष्ट करते हैं और Cargo उन्हें automatically डाउनलोड और अपडेट करता है।
3. प्रोजेक्ट बिल्ड करना और चलाना:
   • Cargo का उपयोग करके आप अपने प्रोजेक्ट को build और run कर सकते हैं। यह compile-time पर dependencies को resolve करता है और executable बाइनरी तैयार करता है।
4. Testing और Documentation:
   • Cargo के साथ आप कोड के लिए tests लिख सकते हैं और उन्हीं tools का उपयोग करके कोड की documentation तैयार कर सकते हैं।

1. नया प्रोजेक्ट बनाना (Creating a New Project)

Cargo का उपयोग करके नया प्रोजेक्ट बनाने के लिए cargo new या cargo init कमांड का उपयोग किया जाता है। यह कमांड आपके प्रोजेक्ट के लिए एक डिफ़ॉल्ट फाइल संरचना तैयार करता है।

cargo new my_project

यह कमांड my_project नाम का एक नया प्रोजेक्ट बनाएगी, जिसकी डिफ़ॉल्ट संरचना इस प्रकार होगी:

my_project/
├── Cargo.toml   # प्रोजेक्ट की configuration और dependencies
└── src/
    └── main.rs  # प्रोजेक्ट का मुख्य कोड फ़ाइल

2. Cargo.toml फ़ाइल (The Cargo.toml File)

Cargo प्रोजेक्ट की मुख्य configuration फ़ाइल Cargo.toml होती है। इसमें आपके प्रोजेक्ट की जानकारी, जैसे नाम, संस्करण, और dependencies होती हैं। यह टॉमल (TOML) फॉर्मेट में होती है, जिसमें आप अपने प्रोजेक्ट की लाइब्रेरियों और संस्करणों को सूचीबद्ध कर सकते हैं।

Cargo.toml का एक उदाहरण:

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8"  # इस प्रोजेक्ट में rand लाइब्रेरी की dependency जोड़ी गई है

इस उदाहरण में, हमने rand नाम की एक external लाइब्रेरी को dependencies में जोड़ा है। Cargo इसे डाउनलोड करेगा और प्रोजेक्ट में उपलब्ध कराएगा।

3. प्रोजेक्ट को बिल्ड और रन करना (Building and Running the Project)

Cargo का उपयोग करके प्रोजेक्ट को build करना बहुत सरल है। आप cargo build कमांड का उपयोग करके अपने प्रोजेक्ट को compile कर सकते हैं। यह सभी dependencies को resolve करेगा और एक बाइनरी executable बनाएगा।

cargo build

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

cargo run

यह कमांड आपके प्रोजेक्ट को build करने के बाद executable को रन करेगा। यह विकास के दौरान उपयोगी है, क्योंकि यह compile और run दोनों को एक ही कमांड में कर देता है।

4. Dependencies प्रबंधित करना (Managing Dependencies)

Cargo में dependencies को Cargo.toml फ़ाइल में जोड़ा जाता है। जब आप कोई dependency जोड़ते हैं, तो Cargo उसे crates.io (Rust का package registry) से डाउनलोड करता है और प्रोजेक्ट में शामिल करता है।

Dependency जोड़ने का उदाहरण:

मान लीजिए आपको अपने प्रोजेक्ट में serde नामक एक लाइब्रेरी जोड़नी है, जो JSON को serialize और deserialize करने में मदद करती है। आप इसे Cargo.toml फ़ाइल में निम्न प्रकार से जोड़ सकते हैं:

[dependencies]
serde = "1.0"

अब, Cargo dependency को डाउनलोड और प्रोजेक्ट में इंटिग्रेट करेगा। आप फिर इसे अपने कोड में उपयोग कर सकते हैं:

use serde::{Serialize, Deserialize};

आप cargo update कमांड का उपयोग करके dependencies को अपडेट भी कर सकते हैं:

cargo update

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

Cargo में testing built-in होती है। आप अपने प्रोजेक्ट में unit tests जोड़ सकते हैं और उन्हें Cargo के साथ चला सकते हैं। एक साधारण test फ़ंक्शन इस प्रकार दिख सकता है:

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

Tests को रन करने के लिए, आप cargo test कमांड का उपयोग कर सकते हैं:

cargo test

यह सभी tests को रन करेगा और उनकी पास या फेल स्थिति को दिखाएगा।

6. प्रोजेक्ट को डॉक्युमेंट करना (Documenting the Project)

Rust का documentation generation system बहुत ही शक्तिशाली है। आप Cargo का उपयोग करके अपने प्रोजेक्ट की documentation generate कर सकते हैं। आपके द्वारा लिखी गई comments को Rustdoc tool का उपयोग करके HTML दस्तावेज़ में परिवर्तित किया जा सकता है।

प्रोजेक्ट की documentation generate करने के लिए, आप cargo doc कमांड का उपयोग कर सकते हैं:

cargo doc --open

यह command आपके प्रोजेक्ट की documentation को generate करता है और ब्राउज़र में उसे ओपन करता है।

Modules और क्रेट्स (Understanding Modules and Crates in Rust)

Rust में कोड को व्यवस्थित और प्रबंधित करने के लिए Modules और Crates का उपयोग किया जाता है। ये दोनों अवधारणाएँ आपके कोड को छोटे-छोटे हिस्सों में विभाजित करके उसे अधिक प्रबंधनीय और पुनः उपयोग करने योग्य बनाती हैं। Modules का उपयोग बड़े प्रोग्रामों को छोटे, तार्किक हिस्सों में विभाजित करने के लिए किया जाता है, जबकि Crates Rust के पैकेजिंग सिस्टम का हिस्सा होते हैं, जो कि पुनः उपयोग के लिए कोड को साझा करने का एक तरीका है।

1. Modules का परिचय (Introduction to Modules)

Modules Rust में कोड को संरचित और व्यवस्थित रखने का तरीका हैं। Modules का उपयोग करके आप कोड को तार्किक रूप से विभाजित कर सकते हैं और बड़ी कोड फाइलों को छोटे-छोटे हिस्सों में तोड़ सकते हैं। Modules आपको नाम स्थान (namespace) प्रदान करते हैं, जो कि अलग-अलग नामों के बीच टकराव को रोकने में मदद करता है।

Modules का सिंटैक्स (Syntax of Modules)

Modules को Rust में mod कीवर्ड का उपयोग करके परिभाषित किया जाता है। एक module अपने अंदर फ़ंक्शंस, स्ट्रक्चर्स, इनेम्स, और अन्य मॉड्यूल्स को भी शामिल कर सकता है।

उदाहरण:

mod math {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }
}

fn main() {
    let result = math::add(5, 10);  // मॉड्यूल के अंदर के फ़ंक्शन को कॉल करना
    println!("परिणाम: {}", result);
}

इस उदाहरण में, हमने math नामक एक module बनाया है, जिसमें दो फ़ंक्शंस add और subtract हैं। हमने इन फ़ंक्शंस को pub कीवर्ड का उपयोग करके सार्वजनिक (public) बनाया है, ताकि इनका उपयोग module के बाहर भी किया जा सके।

2. Modules को फ़ाइलों में विभाजित करना (Splitting Modules into Files)

जब आपका कोड बड़ा हो जाता है, तो आप modules को अलग-अलग फ़ाइलों में विभाजित कर सकते हैं। Rust में, आप module को एक फ़ाइल में परिभाषित कर सकते हैं और उसे अपने मुख्य प्रोग्राम में उपयोग कर सकते हैं।

उदाहरण:

फ़ाइल संरचना:

src/
├── main.rs
└── math.rs

math.rs:

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

main.rs:

mod math;  // math मॉड्यूल को शामिल करना

fn main() {
    let result = math::add(5, 10);
    println!("परिणाम: {}", result);
}

यह संरचना बड़े प्रोजेक्ट्स के लिए उपयोगी है, जहाँ आप एक module के फ़ंक्शंस को अलग-अलग फ़ाइलों में बाँट सकते हैं और उन्हें मुख्य प्रोग्राम में import कर सकते हैं।

3. मॉड्यूल्स में सार्वजनिक और निजी आइटम्स (Public and Private Items in Modules)

Rust में सभी मॉड्यूल आइटम्स (जैसे फ़ंक्शंस, स्ट्रक्चर्स, इत्यादि) डिफ़ॉल्ट रूप से private होते हैं। यदि आप किसी आइटम को मॉड्यूल के बाहर से एक्सेस करना चाहते हैं, तो आपको उसे pub कीवर्ड के साथ public बनाना होगा।

उदाहरण:

mod math {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    fn private_function() {
        println!("यह एक निजी फ़ंक्शन है");
    }
}

fn main() {
    let result = math::add(5, 10);  // public फ़ंक्शन
    // math::private_function();  // एरर, क्योंकि यह फ़ंक्शन private है
    println!("परिणाम: {}", result);
}

यहाँ, add फ़ंक्शन public है और इसे module के बाहर से एक्सेस किया जा सकता है, जबकि private_function private है और इसे module के बाहर से कॉल करने पर एरर होगा।

4. Crates का परिचय (Introduction to Crates)

Rust में Crates सबसे छोटा कंपाइल करने योग्य यूनिट होते हैं। एक crate एक binary या एक library हो सकता है। Crates को modules के माध्यम से व्यवस्थित किया जाता है, और वे पुनः उपयोग किए जाने वाले कोड का एक पैकेज होते हैं।

• Binary Crates: वे crates जो executable programs उत्पन्न करते हैं। एक प्रोजेक्ट में केवल एक main crate होता है।
• Library Crates: वे crates जो लाइब्रेरी के रूप में उपयोग होते हैं और अन्य प्रोजेक्ट्स द्वारा उपयोग किए जा सकते हैं।

Crate का उपयोग कैसे करें?

Rust में crates का उपयोग करने के लिए, आप Cargo.toml फ़ाइल में उन्हें dependencies के रूप में जोड़ते हैं और फिर कोड में use कीवर्ड का उपयोग करके उन्हें import करते हैं।

उदाहरण:

Cargo.toml में:

[dependencies]
rand = "0.8"

कोड में:

use rand::Rng;  // rand crate से Rng ट्रेट को इंपोर्ट करना

fn main() {
    let mut rng = rand::thread_rng();
    let random_number: u32 = rng.gen_range(1..101);
    println!("रैंडम संख्या: {}", random_number);
}

इस उदाहरण में, rand crate को Cargo.toml में dependency के रूप में जोड़ा गया है और इसे कोड में उपयोग करने के लिए इंपोर्ट किया गया है।

5. Crates.io और External Crates (Using Crates from Crates.io)

Crates.io Rust का आधिकारिक पैकेज रेपो है, जहाँ से आप सैकड़ों crates डाउनलोड कर सकते हैं और अपने प्रोजेक्ट्स में उपयोग कर सकते हैं। Cargo का उपयोग करके, आप crates.io से crates को आसानी से अपने प्रोजेक्ट में जोड़ सकते हैं।

Crates.io से Crate जोड़ने का उदाहरण:

1. Cargo.toml फ़ाइल में crate जोड़ें:

   [dependencies]
   serde = "1.0"  # Serde crate को dependency के रूप में जोड़ना
   

    

2. अपने कोड में उपयोग करें:

   use serde::{Serialize, Deserialize};
   
   #[derive(Serialize, Deserialize)]
   struct Person {
       name: String,
       age: u8,
   }
   

    

Cargo अपने आप crates.io से इस crate को डाउनलोड करेगा और dependencies को प्रबंधित करेगा।

Modules और Crates के बीच का अंतर (Difference Between Modules and Crates)

1. Modules:
   • Modules का उपयोग आपके प्रोजेक्ट के अंदर कोड को व्यवस्थित और संरचित करने के लिए किया जाता है।
   • Modules एक ही crate के अंदर छोटे-छोटे हिस्सों में कोड को विभाजित करते हैं।
2. Crates:
   • Crates एक स्वतंत्र यूनिट होते हैं, जो एक binary या library के रूप में काम करते हैं।
   • Crates को पुनः उपयोग किए जाने वाले कोड के रूप में देखा जा सकता है, जिन्हें आप दूसरे प्रोजेक्ट्स में भी उपयोग कर सकते हैं।