Rust मानक पुस्तकालय: मुख्य मॉड्यूल और क्षमताओं का पूर्ण अवलोकन

Rust मानक पुस्तकालय: पूर्ण अवलोकन

Rust मानक पुस्तकालय (std) मूलभूत मॉड्यूल का एक सेट है जो डेवलपर को विश्वसनीय, तेज़ और सुरक्षित अनुप्रयोग बनाने के लिए आवश्यक सब कुछ प्रदान करता है। कई अन्य भाषाओं के विपरीत, Rust कचरा संग्रहकर्ता के बिना मेमोरी सुरक्षा और समांतरता पर विशेष ध्यान देता है। इस लेख में, हम कोड उदाहरणों के साथ std के प्रमुख घटकों का विस्तार से विश्लेषण करेंगे।

1. मानक पुस्तकालय के मुख्य मॉड्यूल

पुस्तकालय कई तार्किक समूहों में विभाजित है। आइए उनमें से सबसे महत्वपूर्ण पर विचार करें।

1.1. मॉड्यूल std::collections

इसमें तत्वों के संग्रह को संग्रहीत और प्रबंधित करने के लिए डेटा संरचनाएं शामिल हैं। सबसे लोकप्रिय:

• Vec<T> — गतिशील सरणी (Java में ArrayList का एनालॉग)।
• HashMap<K, V> — कुंजी-मान जोड़े संग्रहीत करने के लिए हैश तालिका।
• HashSet<T> — अद्वितीय मानों का सेट।
• BTreeMap और BTreeSet — रेड-ब्लैक ट्री पर आधारित क्रमबद्ध संग्रह।

use std::collections::HashMap;

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

    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

1.2. मॉड्यूल std::io

इनपुट-आउटपुट के लिए जिम्मेदार: कीबोर्ड से पढ़ना, फ़ाइलों के साथ काम करना, बफ़र्ड इनपुट/आउटपुट। प्रमुख ट्रेट्स: Read और Write।

use std::io::{self, BufRead};

fn main() -> io::Result<()> {    let stdin = io::stdin();    for line in stdin.lock().lines() {        println!("आपने दर्ज किया: {}", line?);    }    Ok(())}

1.3. मॉड्यूल std::thread

निष्पादन के थ्रेड बनाने और प्रबंधित करने की अनुमति देता है। Rust स्वामित्व प्रणाली और Send और Sync ट्रेट्स के माध्यम से थ्रेड के बीच डेटा सुरक्षा की गारंटी देता है।

use std::thread;

fn main() {    let handle = thread::spawn(|| {        for i in 1..10 {            println!("थ्रेड: {}", i);        }    });

    for i in 1..5 {        println!("मुख्य थ्रेड: {}", i);    }

    handle.join().unwrap();}

2. स्ट्रिंग्स और टेक्स्ट के साथ कार्य

Rust में दो स्ट्रिंग प्रकार हैं:

• String — परिवर्तनीय, स्वामित्व वाली स्ट्रिंग (हीप में संग्रहीत)।
• &str — अपरिवर्तनीय स्ट्रिंग स्लाइस (UTF-8 अनुक्रम का संदर्भ)।

fn main() {    let mut hello = String::from("नमस्ते, ");    hello.push_str("दुनिया!");    println!("{}", hello); // आउटपुट: नमस्ते, दुनिया!

    let slice: &str = &hello[0..6];    println!("स्लाइस: {}", slice); // आउटपुट: नमस्ते}

3. त्रुटि प्रबंधन

अपवादों के बजाय, Rust दो एनुम का उपयोग करता है:

• Option<T> — उन मामलों के लिए जहां मान अनुपस्थित हो सकता है (Some या None).
• Result<T, E> — उन संक्रियाओं के लिए जो त्रुटि में समाप्त हो सकती हैं (Ok या Err).

use std::fs::File;use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let mut file = File::open(path)?;    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

fn main() {    match read_file("test.txt") {        Ok(content) => println!("सामग्री: {}", content),        Err(e) => eprintln!("त्रुटि: {}", e),    }}

4. इटरेटर और क्लोजर

Rust में इटरेटर आलसी और शक्तिशाली होते हैं। वे स्पष्ट लूप के बिना डेटा अनुक्रमों को संसाधित करने की अनुमति देते हैं।

fn main() {    let numbers = vec![1,