Rust में कलेक्शंस (Collections in Rust)

Rust में कलेक्शंस (Collections) प्रोग्रामिंग के दौरान डेटा को संगठित और संग्रहित करने का एक महत्वपूर्ण हिस्सा हैं। कलेक्शंस आपको डेटा को एक स्थान पर संग्रहीत करने और उन्हें लचीले तरीके से प्रबंधित करने की सुविधा देते हैं। इस अध्याय में, हम Rust में उपलब्ध प्रमुख कलेक्शंस जैसे Vectors, HashMaps, और Strings पर चर्चा करेंगे। आप सीखेंगे कि कलेक्शंस को कैसे परिभाषित किया जाता है, उनमें डेटा कैसे जोड़ा जाता है और प्रबंधित किया जाता है, और इन्हें विभिन्न स्थितियों में कैसे उपयोग किया जाता है।

Vectors, HashMaps और Strings का परिचय (Introduction to Vectors, HashMaps, and Strings)

Rust में कलेक्शंस का उपयोग बड़ी मात्रा में डेटा को संगठित और संग्रहित करने के लिए किया जाता है। तीन सबसे सामान्य और उपयोगी कलेक्शंस हैं: Vectors, HashMaps, और Strings। ये कलेक्शंस आपको डेटा को लचीले और कुशल तरीके से स्टोर और प्रबंधित करने की सुविधा देते हैं। आइए, इनके परिचय पर एक नज़र डालते हैं।

Vectors (वेक्टर)

Vectors Rust में सबसे सामान्य कलेक्शन प्रकारों में से एक हैं। Vectors आपको समान प्रकार के डेटा का एक डायनामिक सूची (dynamic list) बनाने की अनुमति देते हैं, जहाँ आप डेटा को जोड़ सकते हैं, हटा सकते हैं, या एक्सेस कर सकते हैं। Vectors एक ही प्रकार के डेटा को संगठित रखने का एक अच्छा तरीका है, जैसे संख्याएँ, स्ट्रिंग्स, या अन्य प्रकार के डेटा।

उदाहरण:

fn main() {
    let mut numbers: Vec<i32> = Vec::new();
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);

    println!("{:?}", numbers);
}

इस उदाहरण में, numbers नाम का एक खाली वेक्टर बनाया गया है और उसमें संख्याएँ जोड़ी जा रही हैं। Vectors का उपयोग तब किया जाता है जब आपको लचीले तरीके से एक क्रमबद्ध सूची की आवश्यकता होती है।

HashMaps (हैशमैप)

HashMaps एक कलेक्शन है जो आपको key-value पेयर (कुंजी-मूल्य जोड़ी) के रूप में डेटा संग्रहीत करने की सुविधा देता है। HashMaps का उपयोग तब किया जाता है जब आपको डेटा को एक कुंजी के आधार पर एक्सेस करना हो, जैसे किसी छात्र का रोल नंबर और उसका नाम।

HashMaps की कुंजी (key) और वैल्यू (value) किसी भी प्रकार की हो सकती हैं, लेकिन एक ही HashMap में सभी कुंजियाँ और सभी मान एक ही प्रकार के होने चाहिए।

उदाहरण:

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 90);
    scores.insert(String::from("Bob"), 85);

    println!("{:?}", scores);
}

इस उदाहरण में, scores नाम का एक HashMap बनाया गया है, जो छात्रों के नाम (keys) और उनके अंकों (values) को संग्रहीत करता है। HashMaps तब उपयोगी होते हैं जब आपको किसी कुंजी के आधार पर मान एक्सेस करना हो।

Strings (स्ट्रिंग्स)

Strings Rust में टेक्स्ट को स्टोर करने का प्रमुख तरीका हैं। Rust में Strings UTF-8 एन्कोडेड होती हैं, जिसका मतलब है कि यह सभी प्रकार के कैरेक्टर्स (Unicode) को स्टोर कर सकती हैं। Rust में दो मुख्य प्रकार की स्ट्रिंग्स होती हैं: String और &str (string slices)।

• String: Heap-allocated, mutable string जिसे आप संशोधित कर सकते हैं।
• &str: Immutable string slice, जिसे आप केवल पढ़ सकते हैं।

उदाहरण:

fn main() {
    let mut s = String::from("नमस्ते");
    s.push_str(", दुनिया!");

    println!("{}", s);
}

इस उदाहरण में, String प्रकार की स्ट्रिंग बनाई गई है, जिसे हम बदल सकते हैं। इसमें “नमस्ते” के बाद “, दुनिया!” जोड़ा गया है।

कलेक्शन का उपयोग और मैनेजमेंट (Managing and Using Collections)

Rust में कलेक्शंस जैसे Vectors, HashMaps, और Strings का उपयोग डेटा को स्टोर करने और प्रबंधित करने के लिए किया जाता है। कलेक्शंस का सही उपयोग और प्रभावी ढंग से मैनेजमेंट आपके प्रोग्राम को अधिक संगठित और कुशल बनाता है। इस खंड में, हम कलेक्शंस का उपयोग और प्रबंधन कैसे किया जाता है, इसके बारे में विस्तार से जानेंगे।

1. Vectors का उपयोग और मैनेजमेंट (Managing and Using Vectors)

Vector में आइटम जोड़ना (Adding Items to a Vector)

आप एक खाली या पहले से भरे हुए Vector में नए आइटम्स जोड़ सकते हैं। आइटम जोड़ने के लिए, push फ़ंक्शन का उपयोग किया जाता है।

fn main() {
    let mut numbers: Vec<i32> = Vec::new();
    numbers.push(10);
    numbers.push(20);
    numbers.push(30);

    println!("{:?}", numbers);  // [10, 20, 30]
}

Vector से आइटम एक्सेस करना (Accessing Items from a Vector)

आप Vector से आइटम को उसकी इंडेक्स वैल्यू द्वारा एक्सेस कर सकते हैं। Vector का इंडेक्स 0 से शुरू होता है।

fn main() {
    let numbers = vec![10, 20, 30];
    let first = numbers[0];  // पहला आइटम एक्सेस
    println!("पहला आइटम: {}", first);  // 10
}

Vector से आइटम हटाना (Removing Items from a Vector)

Vector से आइटम को हटाने के लिए pop फ़ंक्शन का उपयोग किया जाता है, जो लास्ट आइटम को हटाता है।

fn main() {
    let mut numbers = vec![10, 20, 30];
    numbers.pop();  // लास्ट आइटम (30) हटा दिया जाता है

    println!("{:?}", numbers);  // [10, 20]
}

Vector को Iterate करना (Iterating Over a Vector)

आप Vector के सभी आइटम्स को for लूप के जरिए iterate कर सकते हैं।

fn main() {
    let numbers = vec![10, 20, 30];
    for number in &numbers {
        println!("{}", number);
    }
}

2. HashMaps का उपयोग और मैनेजमेंट (Managing and Using HashMaps)

HashMap में आइटम जोड़ना (Adding Items to a HashMap)

HashMap में insert फ़ंक्शन का उपयोग करके कुंजी-मूल्य जोड़ियां जोड़ी जाती हैं।

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 95);
    scores.insert(String::from("Bob"), 85);

    println!("{:?}", scores);
}

HashMap से आइटम एक्सेस करना (Accessing Items from a HashMap)

आप किसी कुंजी का उपयोग करके HashMap से वैल्यू एक्सेस कर सकते हैं। यदि कुंजी HashMap में नहीं है, तो यह ऑपरेशन None लौटाएगा।

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 95);

    let score = scores.get(&String::from("Alice"));
    match score {
        Some(&value) => println!("Alice का स्कोर: {}", value),
        None => println!("कोई स्कोर नहीं मिला"),
    }
}

HashMap से आइटम हटाना (Removing Items from a HashMap)

HashMap से किसी कुंजी-मूल्य को हटाने के लिए remove फ़ंक्शन का उपयोग किया जाता है।

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 95);

    scores.remove(&String::from("Alice"));
    println!("{:?}", scores);  // HashMap अब खाली है
}

HashMap को Iterate करना (Iterating Over a HashMap)

HashMap के सभी कुंजी-मूल्य जोड़ियों को for लूप का उपयोग करके iterate कर सकते हैं।

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 95);
    scores.insert(String::from("Bob"), 85);

    for (key, value) in &scores {
        println!("{} का स्कोर: {}", key, value);
    }
}

3. Strings का उपयोग और मैनेजमेंट (Managing and Using Strings)

Strings में डेटा जोड़ना (Appending to a String)

Rust में आप push_str फ़ंक्शन का उपयोग करके किसी स्ट्रिंग के अंत में डेटा जोड़ सकते हैं।

fn main() {
    let mut greeting = String::from("नमस्ते");
    greeting.push_str(", दुनिया!");

    println!("{}", greeting);  // "नमस्ते, दुनिया!"
}

String से डेटा एक्सेस करना (Accessing Data from a String)

Strings को एक्सेस करने के लिए आप उन्हें सीधे प्रिंट कर सकते हैं, या उनके सबस्ट्रिंग्स (slices) निकाल सकते हैं।

fn main() {
    let s = String::from("नमस्ते");
    let first_char = &s[0..3];  // 'न' (पहला यूनिकोड कैरेक्टर)

    println!("{}", first_char);  // "न"
}

String को Iteration करना (Iterating Over a String)

आप Strings के प्रत्येक कैरेक्टर पर for लूप का उपयोग करके iterate कर सकते हैं।

fn main() {
    let s = String::from("नमस्ते");
    
    for c in s.chars() {
        println!("{}", c);
    }
}