Rust में SOLID सिद्धांत: डेवलपर्स के लिए सिद्धांत और व्यवहार

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

```html

परिचय: Rust में SOLID सिद्धांत — इसकी आवश्यकता क्यों है?

SOLID — ये ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के पाँच मूलभूत सिद्धांत हैं जो लचीला, रखरखाव योग्य और स्केलेबल कोड बनाने में मदद करते हैं। हालाँकि Rust एक शास्त्रीय OOP भाषा नहीं है (इसमें सामान्य रूप में क्लास इनहेरिटेंस नहीं है), लेकिन इसकी स्वामित्व प्रणाली, traits और generics SOLID के सभी सिद्धांतों को शानदार ढंग से लागू करने की अनुमति देते हैं। Rust के संदर्भ में इन सिद्धांतों को समझने से ऐसा कोड लिखने में मदद मिलती है जिसका परीक्षण, रिफैक्टर और विस्तार करना आसान होता है।

इस लेख में हम Rust पर व्यावहारिक उदाहरणों के साथ SOLID के पाँचों सिद्धांतों का विश्लेषण करेंगे। आप देखेंगे कि कैसे trait इंटरफेस की जगह लेता है, कैसे Box<dyn Trait> डिपेंडेंसी इनवर्जन में मदद करता है, और सामान्य गलतियों से कैसे बचा जाए।

1. Rust में एकल उत्तरदायित्व सिद्धांत (SRP)

Single Responsibility Principle (SRP): प्रत्येक मॉड्यूल, स्ट्रक्चर या फंक्शन में बदलाव का केवल एक ही कारण होना चाहिए। Rust में इसका मतलब है कि एक स्ट्रक्चर को एक ही इकाई के लिए जिम्मेदार होना चाहिए, न कि व्यावसायिक तर्क, डेटा कार्य और आउटपुट को मिलाना चाहिए।

SRP उल्लंघन का उदाहरण

struct User {    name: String,    email: String,}

impl User {    // व्यावसायिक तर्क और भंडारण को मिलाना    fn save_to_db(&self) {        println!("{} को DB में सहेजा जा रहा है", self.name);    }        fn send_email(&self, message: &str) {        println!("{} पर ईमेल भेजा जा रहा है: {}", self.email, message);    }}

यहाँ User स्ट्रक्चर उपयोगकर्ता डेटा, भंडारण और ईमेल भेजने के लिए जिम्मेदार है। यह SRP का उल्लंघन है।

SRP की सही कार्यान्वयन

struct User {    name: String,    email: String,}

struct UserRepository;impl UserRepository {    fn save(&self, user: &User) {        println!("{} को DB में सहेजा जा रहा है", user.name);    }}

struct EmailService;impl EmailService {    fn send(&self, user: &User, message: &str) {        println!("{} पर ईमेल भेजा जा रहा है: {}", user.email, message);    }}

अब प्रत्येक स्ट्रक्चर की एक ही जिम्मेदारी है: User — डेटा, UserRepository — भंडारण, EmailService — भेजना। कोड अधिक मॉड्यूलर और परीक्षण योग्य हो गया है।

2. Traits के माध्यम से खुलापन/बंदपन सिद्धांत (OCP)

Open/Closed Principle (OCP): सॉफ्टवेयर इकाइयाँ विस्तार के लिए खुली होनी चाहिए, लेकिन संशोधन के लिए बंद। Rust में यह trait और डायनामिक डिस्पैच के माध्यम से आदर्श रूप से कार्यान्वित होता है।

OCP के बिना उदाहरण

fn calculate_area(shape: &str, params: &[f64]) -> f64 {    match shape {        "circle" => std::f64::consts::PI * params[0] * params[0],        "rectangle" => params[0] * params[1],        _ => panic!("अज्ञात आकृति"),    }}

नई आकृति (जैसे त्रिभुज) जोड़ने पर फंक्शन को संशोधित करना होगा।

OCP के साथ सही दृष्टिकोण

trait Shape {    fn area(&self) -> f64;}

struct Circle { radius: f64 }impl Shape for Circle {    fn area(&self) -> f64 {        std::f64::consts::PI * self.radius * self.radius    }}

struct Rectangle { width: f64, height: f64 }impl Shape for Rectangle {    fn area(&self) -> f64 {        self.width * self.height    }}

// फंक्शन संशोधन के लिए बंद है, लेकिन विस्तार के लिए खुला हैfn print_area(shape: &dyn Shape) {    println!("क्षेत्रफल: {}", shape.area());}

अब त्रिभुज जोड़ने के लिए बस एक नया स्ट्रक्चर बनाना और trait Shape को लागू करना होगा। print_area फंक्शन में बदलाव की आवश्यकता नहीं है।