TypeScript में SOLID सिद्धांत: पूर्ण गाइड (कोड के साथ)

TypeScript में SOLID सिद्धांत: सिद्धांत और व्यवहार (A से Z तक)

SOLID पाँच मूलभूत ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग सिद्धांतों का संक्षिप्त नाम है, जिन्हें रॉबर्ट मार्टिन (अंकल बॉब) ने प्रतिपादित किया था। ये सिद्धांत लचीला, रखरखाव योग्य और स्केलेबल कोड बनाने में मदद करते हैं। इस लेख में, हम TypeScript में उदाहरणों के साथ SOLID के प्रत्येक सिद्धांत को सरल परिभाषाओं से लेकर वास्तविक उपयोग परिदृश्यों तक विस्तार से समझेंगे।

1. Single Responsibility Principle (SRP) — एकल उत्तरदायित्व का सिद्धांत

परिभाषा: प्रत्येक क्लास में बदलाव का केवल एक ही कारण होना चाहिए। दूसरे शब्दों में, एक क्लास को केवल एक स्पष्ट रूप से परिभाषित कार्य के लिए जिम्मेदार होना चाहिए।

समस्या: जब कोई क्लास कई जिम्मेदारियाँ ले लेता है, तो उसका परीक्षण, विस्तार और रखरखाव करना मुश्किल हो जाता है। एक फंक्शन में बदलाव दूसरे को तोड़ सकता है।

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

// ❌ SRP का उल्लंघन: क्लास स्टोर, फॉर्मेट और भेजने का काम कर रहा है\nclass UserService {\n    saveUser(user: User): void {\n        // डेटाबेस में सेव करना\n        console.log('User saved');\n    }\n\n    formatUserData(user: User): string {\n        return `Name: ${user.name}, Email: ${user.email}`;\n    }\n\n    sendWelcomeEmail(user: User): void {\n        // ईमेल भेजना\n        console.log('Email sent');\n    }\n}

SRP के साथ समाधान:

// ✅ प्रत्येक क्लास अपने काम के लिए जिम्मेदार है\nclass UserRepository {\n    save(user: User): void {\n        console.log('User saved');\n    }\n}\n\nclass UserFormatter {\n    format(user: User): string {\n        return `Name: ${user.name}, Email: ${user.email}`;\n    }\n}\n\nclass EmailService {\n    sendWelcome(user: User): void {\n        console.log('Email sent');\n    }\n}

2. Open-Closed Principle (OCP) — खुले/बंद का सिद्धांत

परिभाषा: क्लासेस विस्तार के लिए खुले होने चाहिए, लेकिन संशोधन के लिए बंद होने चाहिए। इसका मतलब है कि आपको मौजूदा कोड को बदले बिना नई कार्यक्षमता जोड़ने में सक्षम होना चाहिए।

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

// ❌ नई आकृति जोड़ने पर calculateArea मेथड को बदलना होगा\nclass AreaCalculator {\n    calculateArea(shape: any): number {\n        if (shape.type === 'circle') {\n            return Math.PI * shape.radius ** 2;\n        } else if (shape.type === 'rectangle') {\n            return shape.width * shape.height;\n        }\n        throw new Error('Unknown shape');\n    }\n}

OCP के साथ समाधान (पॉलीमॉर्फिज़्म का उपयोग):

// ✅ इंटरफ़ेस और इनहेरिटेंस का उपयोग\ninterface Shape {\n    area(): number;\n}\n\nclass Circle implements Shape {\n    constructor(private radius: number) {}\n    area(): number {\n        return Math.PI * this.radius ** 2;\n    }\n}\n\nclass Rectangle implements Shape {\n    constructor(private width: number, private height: number) {}\n    area(): number {\n        return this.width * this.height;\n    }\n}\n\nclass AreaCalculator {\n    calculateArea(shape: Shape): number {\n        return shape.area(); // नई आकृतियाँ जोड़ने पर इसमें बदलाव की ज़रूरत नहीं\n    }\n}

3. Liskov Substitution Principle (LSP) — लिस्कोव प्रतिस्थापन का सिद्धांत

परिभाषा: प्रोग्राम में ऑब्जेक्ट्स को उनके सबटाइप्स के इंस्टेंस से बदला जाने योग्य होना चाहिए, बिना प्रोग्राम की शुद्धता को बदले। चाइल्ड क्लास को पैरेंट क्लास के अनुबंध का उल्लंघन नहीं करना चाहिए।

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

// ❌ उल्लंघन: सबक्लास पूर्वज के व्यवहार को बदल रहा है\nclass Bird {\n    fly(): void {\n        console.log('Flying');\n    }\n}\n\nclass Penguin extends Bird {\n    fly(): void {\n        throw new Error('Penguins cannot fly!'); // अनुबंध का उल्लंघन\n    }\n}

LSP के साथ समाधान:

// ✅ अलग