Rust में डिज़ाइन पैटर्न कोड उदाहरणों के साथ

Rust में डिज़ाइन पैटर्न: उदाहरणों के साथ व्यावहारिक मार्गदर्शिका

डिज़ाइन पैटर्न सामान्य विकास समस्याओं के सिद्ध समाधान हैं। Rust में, इसकी अद्वितीय स्वामित्व प्रणाली और मेमोरी मॉडल के कारण, क्लासिकल पैटर्न का कार्यान्वयन अक्सर गार्बेज कलेक्शन वाली भाषाओं से भिन्न होता है। इस लेख में, हम तीन प्रमुख पैटर्न पर चर्चा करेंगे: Singleton, Builder और Strategy, जो Rust की विशेषताओं के अनुकूल हैं।

1. Rust में Singleton पैटर्न: unsafe के बिना वैश्विक स्थिति

Singleton यह सुनिश्चित करता है कि क्लास का केवल एक इंस्टेंस हो, और उस तक वैश्विक पहुँच प्रदान करता है। Rust में, इसके लिए once_cell क्रेट या स्थिर std::sync::OnceLock (Rust 1.70 से) आदर्श है।

OnceLock के साथ कार्यान्वयन

use std::sync::OnceLock;

pub struct Logger {    level: String,}

impl Logger {    pub fn global() -> &'static Logger {        static INSTANCE: OnceLock<Logger> = OnceLock::new();        INSTANCE.get_or_init(|| Logger {            level: "info".to_string(),        })    }

    pub fn log(&self, msg: &str) {        println!("[{}] {}", self.level, msg);    }}

fn main() {    let logger = Logger::global();    logger.log("नमस्ते, Rust!");    // Logger::global() वही इंस्टेंस लौटाएगा}

लाभ: सुरक्षा (कोई unsafe नहीं), आलसी आरंभीकरण, थ्रेड-सुरक्षा। कमी — वैश्विक स्थिति परीक्षण को जटिल बनाती है।

2. Builder पैटर्न: जटिल ऑब्जेक्ट का निर्माण

Builder जटिल ऑब्जेक्ट के निर्माण को उसके प्रतिनिधित्व से अलग करता है। Rust में, यह कई वैकल्पिक फ़ील्ड वाली संरचनाओं के लिए विशेष रूप से उपयोगी है।

उदाहरण: HTTP-क्लाइंट कॉन्फ़िगरेशन

pub struct HttpClient {    url: String,    timeout: u64,    headers: Vec<(String, String)>,}

pub struct HttpClientBuilder {    url: String,    timeout: Option<u64>,    headers: Vec<(String, String)>,}

impl HttpClientBuilder {    pub fn new(url: &str) -> Self {        HttpClientBuilder {            url: url.to_string(),            timeout: None,            headers: vec![],        }    }

    pub fn timeout(mut self, secs: u64) -> Self {        self.timeout = Some(secs);        self    }

    pub fn header(mut self, key: &str, value: &str) -> Self {        self.headers.push((key.to_string(), value.to_string()));        self    }

    pub fn build(self) -> HttpClient {        HttpClient {            url: self.url,            timeout: self.timeout.unwrap_or(30),            headers: self.headers,        }    }}

fn main() {    let client = HttpClientBuilder::new("https://api.example.com")        .timeout(10)        .header("Authorization", "Bearer token123")        .build();    println!("Client URL: {}", client.url);}

महत्वपूर्ण: builder के तरीकों में self (न कि &self) का उपयोग क्लोनिंग से बचाता है और API को अधिक एर्गोनोमिक बनाता है।

3. Strategy पैटर्न: एल्गोरिदम विनिमेय रणनीतियों के रूप में

Strategy एल्गोरिदम के एक परिवार को परिभाषित करता है, उनमें से प्रत्येक को एनकैप्सुलेट करता है और उन्हें विनिमेय बनाता है। Rust में, इसे ट्रेट्स (traits) और डायनामिक डिस्पैच (Box<dyn Trait>) के माध्यम से कार्यान्वित किया जाता है।

उदाहरण: सॉर्टिंग सिस्टम

trait SortStrategy {    fn sort(&self, data: &mut [i32]);}

struct BubbleSort;impl SortStrategy for BubbleSort {    fn sort(&self, data: &mut [i32]) {        let n = data.len();        for i in 0..n {            for j in 0..n - i - 1 {                if data[j] > data[j + 1] {                    data.swap(j, j + 1);                }            }        }    }}

struct QuickSort;impl SortStrategy for QuickSort {    fn sort(&self, da
```