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

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

डिज़ाइन पैटर्न सॉफ़्टवेयर विकास में सामान्य समस्याओं के सिद्ध समाधान हैं। Rust में, इसकी अद्वितीय स्वामित्व, उधार और जीवनकाल प्रणाली के कारण, क्लासिक GoF पैटर्न के कार्यान्वयन के लिए अक्सर एक विशेष दृष्टिकोण की आवश्यकता होती है। इस लेख में, हम Rust में वास्तविक कोड उदाहरणों के साथ कई लोकप्रिय पैटर्न पर चर्चा करेंगे।

Rust पैटर्न के प्रति दृष्टिकोण क्यों बदलता है?

गार्बेज कलेक्शन वाली भाषाओं (Java, C#) के विपरीत, Rust मेमोरी स्वामित्व पर सख्त नियम लागू करता है। यह कुछ क्लासिक कार्यान्वयनों (जैसे, वैश्विक परिवर्तनीय स्थिति के माध्यम से Singleton) को असुरक्षित या अक्षम बनाता है। हालाँकि, Rust प्रकारों और ट्रेट्स पर आधारित अपने स्वयं के सुरुचिपूर्ण विकल्प प्रदान करता है।

1. Builder (निर्माता) — वस्तुओं का चरण-दर-चरण निर्माण

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

उदाहरण: HTTP अनुरोध बनाना

struct Request {    method: String,    url: String,    headers: Vec<(String, String)>,    body: Option<String>,}

struct RequestBuilder {    method: String,    url: String,    headers: Vec<(String, String)>,    body: Option<String>,}

impl RequestBuilder {    fn new(method: &str, url: &str) -> Self {        Self {            method: method.to_string(),            url: url.to_string(),            headers: Vec::new(),            body: None,        }    }

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

    fn body(mut self, body: &str) -> Self {        self.body = Some(body.to_string());        self    }

    fn build(self) -> Request {        Request {            method: self.method,            url: self.url,            headers: self.headers,            body: self.body,        }    }}

fn main() {    let req = RequestBuilder::new("POST", "https://api.example.com/data")        .header("Content-Type", "application/json")        .header("Authorization", "Bearer token123")        .body(r#"{"key": "value"}"#)        .build();

    println!("URL: {}", req.url);    println!("Headers count: {}", req.headers.len());}

Rust में इस दृष्टिकोण के लाभ

• सुरक्षा: वस्तु केवल build() कॉल करने के बाद ही बनाई जाती है — अधूरा कॉन्फ़िगरेशन संभव नहीं है।
• पठनीयता: विधियों की श्रृंखला सहज रूप से समझ में आती है।
• प्रकार सुरक्षा: कंपाइलर प्रत्येक चरण पर प्रकारों की जाँच करता है।

2. Strategy (रणनीति) — चलते-फिरते एल्गोरिदम चुनना

Strategy रनटाइम के दौरान किसी वस्तु के व्यवहार को बदलने की अनुमति देता है। Rust में, इसे ट्रेट्स और डायनेमिक डिस्पैच (Box के साथ ट्रेट्स) या स्टैटिक डिस्पैच (जेनेरिक्स) के माध्यम से कार्यान्वित किया जाता है।

उदाहरण: डेटा सॉर्ट करना

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

struct BubbleSort;struct QuickSort;

impl SortStrategy for BubbleSort {    fn sort(&self, data: &mut [i32]) {        // बबल सॉर्ट का सरलतम कार्यान्वयन        for i in 0..data.len() {            for j in 0..data.len() - 1 - i {                if data[j] > data[j + 1] {                    data.swap(j, j + 1);                }            }        }    }}

impl SortStrategy for QuickSort {    fn sort(&self, data: &mut [i32]) {        // क्विक सॉर्ट (सरलीकृत)        if data.len() > 1 {            let pivot = data.len() / 2;            data.sort(); // उदाहरण के लिए अंतर्निहित का उपयोग करें        }    }}

struct Sorter {    strategy: Box<dyn SortStrategy>,}

impl Sorter {    fn new(strategy: Box<dyn SortStrategy>) ->