HI
RU
EN
ES
ZH
FR
DE
PT
AR
परिचय: SOLID और Rust — एक आदर्श संयोजन
\nSOLID सिद्धांत ऑब्जेक्ट-ओरिएंटेड डिज़ाइन के मूलभूत नियम हैं जो लचीला, रखरखाव योग्य और स्केलेबल कोड बनाने में मदद करते हैं। हालाँकि Rust पूरी तरह से ऑब्जेक्ट-ओरिएंटेड भाषा नहीं है (यह क्लास के बजाय ट्रेट्स और स्ट्रक्चर का उपयोग करता है), फिर भी SOLID सिद्धांत इसमें पूरी तरह से लागू होते हैं। इस लेख में, हम Rust कोड उदाहरणों के साथ पाँचों सिद्धांतों में से प्रत्येक को समझेंगे, और दिखाएंगे कि वे मजबूत सिस्टम बनाने में कैसे मदद करते हैं।
\nपूरे लेख में, आप देखेंगे कि कैसे Rust की स्वामित्व प्रणाली, ट्रेट्स और जेनेरिक्स SOLID के कार्यान्वयन को स्वाभाविक और शक्तिशाली बनाते हैं। हम Single Responsibility से शुरू करके Dependency Inversion तक जाएंगे, और उपयोग के लिए तैयार उदाहरण प्रदान करेंगे।
\n\n1. Single Responsibility Principle (SRP) — एकल उत्तरदायित्व का सिद्धांत
\nसार: प्रत्येक मॉड्यूल, क्लास या फंक्शन में बदलाव का केवल एक ही कारण होना चाहिए। Rust में इसका मतलब है कि एक स्ट्रक्चर को केवल एक ही कार्य के लिए जिम्मेदार होना चाहिए।
\n\nखराब उदाहरण (SRP का उल्लंघन)
\nstruct Report {\n title: String,\n content: String,\n}\n\nimpl Report {\n fn generate(&self) -> String {\n format!("# {}\\n\\n{}", self.title, self.content)\n }\n\n fn save_to_file(&self, path: &str) -> std::io::Result<()> {\n std::fs::write(path, self.generate())?;\n Ok(())\n }\n\n fn send_email(&self, recipient: &str) {\n println!("Sending email to {} with report", recipient);\n }\n}यहाँ Report स्ट्रक्चर जनरेशन, सेविंग और भेजने के लिए जिम्मेदार है — बदलाव के तीन अलग-अलग कारण। यह SRP का उल्लंघन करता है।
अच्छा उदाहरण (SRP का पालन)
\nstruct Report {\n title: String,\n content: String,\n}\n\nimpl Report {\n fn generate(&self) -> String {\n format!("# {}\\n\\n{}", self.title, self.content)\n }\n}\n\nstruct ReportSaver;\n\nimpl ReportSaver {\n fn save(&self, report: &Report, path: &str) -> std::io::Result<()> {\n std::fs::write(path, report.generate())?;\n Ok(())\n }\n}\n\nstruct EmailSender;\n\nimpl EmailSender {\n fn send(&self, recipient: &str, message: &str) {\n println!("Sending email to {}: {}", recipient, message);\n }\n}अब प्रत्येक स्ट्रक्चर अपने कार्य के लिए जिम्मेदार है: Report — डेटा और जनरेशन के लिए, ReportSaver — सेविंग के लिए, EmailSender — भेजने के लिए। इससे परीक्षण और रखरखाव आसान हो जाता है।
2. Open-Closed Principle (OCP) — खुले/बंद का सिद्धांत
\nसार: सॉफ्टवेयर संस्थाएँ विस्तार के लिए खुली होनी चाहिए, लेकिन संशोधन के लिए बंद। Rust में यह ट्रेट्स और जेनेरिक्स के माध्यम से प्राप्त किया जाता है।
\n\nउदाहरण: फ़िल्टरिंग सिस्टम
\ntrait Filter<T> {\n fn apply(&self, items: &[T]) -> Vec<T>;\n}\n\nstruct EvenFilter;\n\nimpl Filter<i32> for EvenFilter {\n fn apply(&self, items: &[i32]) -> Vec<i32> {\n items.iter().filter(|&x| x % 2 == 0).copied().collect()\n }\n}\n\nstruct GreaterThanFilter {\n threshold: i32,\n}\n\nimpl Filter<i32> for GreaterThanFilter {\n fn apply(&self, items: &[i32]) -> Vec<i32> {\n items.iter().filter(|&&x| x > self.threshold).copied().collect()\n }\n}\n\nfn process<T: Clone, F: Filter<T>>(items: &[T], filter: F) -> Vec<T> {\n filter.apply(items)\n}\n\nfn main() {\n let numbers = vec![1, 2, 3, 4, 5, 6];\n let even = process(&numbers, EvenFilter);\n let greater = process(&numbers, GreaterThanFilter { threshold: 3 });\n println!("Even: {:?}, Greater: {:?}", even, greater);\n}हम मौजूदा process कोड को बदले बिना नए फ़िल्टर जोड़ सकते हैं। यह ट्रेट पॉलीमॉर्फिज़्म के माध्यम से OCP का कार्यान्वयन है।
3. Liskov Substitution Principle (LSP) — बारबरा लिस्कोव का प्रतिस्थापन सिद्धांत
\nसार:
ब्लॉग
पुस्तक अनुशंसाएँ
यह भी पढ़ें
