जब मैंने पहली बार सॉफ्टवेयर विकास की दुनिया में कदम रखना शुरू किया, तो मैं अक्सर खुद को चारों ओर उड़ने वाले सभी प्रचलित शब्दों और अवधारणाओं से अभिभूत पाता था। एक अवधारणा जो विशेष रूप से कठिन लगती थी वह थी ठोस सिद्धांत। ऐसा महसूस हुआ कि केवल "गंभीर" डेवलपर्स को ही इस बारे में चिंता करने की ज़रूरत है। लेकिन जैसे-जैसे मैं कोडिंग के साथ अधिक सहज होता गया, मुझे एहसास हुआ कि ये सिद्धांत फैंसी होने के बारे में कम और कोड लिखने के बारे में अधिक हैं जो आपको कुछ महीनों के बाद अपने बाल खींचने की इच्छा नहीं होने देते।

तो, यहां जावास्क्रिप्ट में SOLID सिद्धांतों पर मेरी राय है - एक बकवास रहित, व्यावहारिक मार्गदर्शिका जो मैं चाहता हूं कि जब मैंने शुरू किया था तब मेरे पास होती।

1. एकल उत्तरदायित्व सिद्धांत (एसआरपी): एक काम, अच्छा किया

यह क्या है?

एकल जिम्मेदारी सिद्धांत कहता है कि एक वर्ग के पास बदलाव का केवल एक ही कारण होना चाहिए, जिसका अर्थ है कि उसके पास केवल एक ही नौकरी या जिम्मेदारी होनी चाहिए।

वास्तविक जीवन सादृश्य

अपनी पसंदीदा कॉफ़ी शॉप में एक बरिस्ता के बारे में सोचें। इनका काम कॉफ़ी बनाना है. अगर उन्हें अचानक एस्प्रेसो मशीन ठीक करना, पेस्ट्री परोसना और कचरा बाहर निकालना शुरू करना पड़े, तो चीजें अस्त-व्यस्त हो जाएंगी। ठीक उसी तरह जैसे बरिस्ता को कॉफ़ी बनाने पर ध्यान केंद्रित करना चाहिए, आपकी कक्षा को एक काम अच्छे से करने पर ध्यान देना चाहिए।

जावास्क्रिप्ट में उदाहरण:

कल्पना करें कि आपके पास एक उपयोगकर्ता वर्ग है जो उपयोगकर्ता प्रमाणीकरण, डेटा सत्यापन और डेटाबेस भंडारण को संभालता है। यह बहुत ज्यादा कर रहा है! इन ज़िम्मेदारियों को अलग-अलग वर्गों में विभाजित करके, आप अपने कोड को प्रबंधित करना और बनाए रखना आसान बनाते हैं।

class UserAuthenticator {
  login(user) {
    // handle login
  }
}

class UserDataValidator {
  validate(user) {
    // validate user data
  }
}

class UserDatabase {
  save(user) {
    // save user to the database
  }
}

2. खुला/बंद सिद्धांत (ओसीपी): विस्तार करें, संशोधित न करें

यह क्या है?

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

वास्तविक जीवन सादृश्य:

अपने पसंदीदा गेमिंग कंसोल की कल्पना करें। आप नए गेम, कंट्रोलर और एक्सेसरीज़ जोड़ सकते हैं, लेकिन ऐसा करने के लिए आपको इसे खोलने या फिर से तार लगाने की ज़रूरत नहीं है। इसी प्रकार, आपको अपने कोड की मूल संरचना को बदले बिना उसमें नई सुविधाएँ जोड़ने में सक्षम होना चाहिए।

जावास्क्रिप्ट में उदाहरण:

मान लें कि आपके पास क्षेत्रफल की गणना करने की विधि के साथ एक आकार वर्ग है। यदि आपको त्रिभुज जैसी कोई नई आकृति जोड़ने की आवश्यकता है, तो आपको मौजूदा वर्ग को संशोधित नहीं करना होगा। इसके बजाय, इसे बढ़ाएँ।

class Shape {
  area() {
    throw "Area method not implemented";
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  area() {
    return this.width * this.height;
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }

  area() {
    return Math.PI * this.radius * this.radius;
  }
}

3. लिस्कोव प्रतिस्थापन सिद्धांत (एलएसपी): इसे प्रतिस्थापन योग्य रखें

यह क्या है?

लिस्कोव प्रतिस्थापन सिद्धांत में कहा गया है कि एक सुपरक्लास की वस्तुओं को कार्यक्रम की शुद्धता को प्रभावित किए बिना एक उपवर्ग की वस्तुओं के साथ प्रतिस्थापित किया जाना चाहिए।

वास्तविक जीवन सादृश्य:

एक कार किराए पर लेने की कल्पना करें। चाहे आपको सेडान मिले या एसयूवी, आप उम्मीद करते हैं कि इसमें एक कार की बुनियादी कार्यक्षमताएं हों: इसे चलाना, चलाना और रुकना चाहिए। यदि आपकी किराये की कार को नियंत्रण के बिल्कुल अलग सेट की आवश्यकता है, तो आप मुसीबत में पड़ जाएंगे! इसी तरह, उपवर्गों को इस तरह व्यवहार करना चाहिए जिससे उनके मूल वर्ग द्वारा निर्धारित अपेक्षाएं न टूटे।

जावास्क्रिप्ट में उदाहरण:

यदि आपके पास एक पक्षी वर्ग और एक पेंगुइन वर्ग है जो इसका विस्तार करता है, तो पेंगुइन को अभी भी एक पक्षी की तरह व्यवहार करना चाहिए, भले ही वह उड़ न सके। इसे अभी भी चलना, खाना और शायद तैरना भी चाहिए।

class Bird {
  move() {
    console.log("Flies in the sky");
  }
}

class Penguin extends Bird {
  move() {
    console.log("Swims in the water");
  }
}

const myBird = new Bird();
const myPenguin = new Penguin();

myBird.move(); // Flies in the sky
myPenguin.move(); // Swims in the water

4. इंटरफ़ेस पृथक्करण सिद्धांत (आईएसपी): दर्जी-निर्मित इंटरफ़ेस

यह क्या है?

इंटरफ़ेस पृथक्करण सिद्धांत सुझाव देता है कि ग्राहकों को उन इंटरफ़ेस को लागू करने के लिए बाध्य नहीं किया जाना चाहिए जिनका वे उपयोग नहीं करते हैं। एक बड़ा इंटरफ़ेस रखने के बजाय, आपको छोटे, अधिक विशिष्ट इंटरफ़ेस बनाने चाहिए।

वास्तविक जीवन सादृश्य:

एक ऐसे रेस्तरां की कल्पना करें जहां शेफ को वेटर, बारटेंडर और डिशवॉशर भी बनना पड़े। यह जबरदस्त और अप्रभावी है! इसके बजाय, प्रत्येक भूमिका के अपने विशिष्ट कार्य होने चाहिए। इसी तरह, आपका इंटरफ़ेस विशिष्ट और केंद्रित होना चाहिए।

जावास्क्रिप्ट में उदाहरण:

यदि आपके पास एक वर्कर इंटरफ़ेस है जिसमें बिल्डहाउस, पेंटहाउस और डिज़ाइनहाउस जैसी विधियां शामिल हैं, तो एक कार्यकर्ता जो केवल घरों को पेंट करता है उसे अन्य सभी तरीकों को लागू नहीं करना चाहिए। इसे छोटे-छोटे इंटरफ़ेस में तोड़ें।

class Builder {
  build() {
    console.log("Building house...");
  }
}

class Painter {
  paint() {
    console.log("Painting house...");
  }
}

class Designer {
  design() {
    console.log("Designing house...");
  }
}

5. निर्भरता व्युत्क्रम सिद्धांत (डीआईपी): अमूर्त पर भरोसा करें

यह क्या है?

निर्भरता व्युत्क्रम सिद्धांत बताता है कि उच्च-स्तरीय मॉड्यूल को निम्न-स्तरीय मॉड्यूल पर निर्भर नहीं होना चाहिए। दोनों को अमूर्त पर निर्भर होना चाहिए।

वास्तविक जीवन सादृश्य:

इस बारे में सोचें कि आप अपने फ़ोन चार्जर को दीवार के सॉकेट में कैसे प्लग करते हैं। आपको दीवारों के अंदर बिजली के तारों का विवरण जानने की ज़रूरत नहीं है - आपको बस अपने डिवाइस को बिजली देने के लिए इंटरफ़ेस (सॉकेट) की आवश्यकता है। इसी तरह, आपका कोड अमूर्त (इंटरफ़ेस) पर निर्भर होना चाहिए, न कि ठोस कार्यान्वयन पर।

जावास्क्रिप्ट में उदाहरण:

यदि आपके पास एक लाइटबल्ब क्लास है जो सीधे स्विच क्लास को नियंत्रित करती है, तो आप एक टाइट कपलिंग बना रहे हैं। इसके बजाय, दोनों को पॉवरसोर्स जैसे इंटरफ़ेस पर निर्भर रहना चाहिए।

class LightBulb {
  turnOn(powerSource) {
    powerSource.provideElectricity();
    console.log("Light is on");
  }
}

class Switch {
  constructor(powerSource) {
    this.powerSource = powerSource;
  }

  operate() {
    this.powerSource.togglePower();
  }
}

class PowerSource {
  provideElectricity() {
    console.log("Providing electricity");
  }

  togglePower() {
    console.log("Toggling power");
  }
}

निष्कर्ष

SOLID सिद्धांतों में महारत हासिल करना सिद्ध व्यंजनों के एक सेट के साथ खाना बनाना सीखने जैसा है। एक बार जब आप उन्हें समझ लेते हैं, तो आप ऐसे कोड तैयार कर सकते हैं जो न केवल कार्यात्मक हों बल्कि सुरुचिपूर्ण और बनाए रखने में आसान हों। तो अगली बार जब आप खुद को कोडिंग पहेली में पाएं, तो याद रखें: इसके लिए एक सिद्धांत है!

हैप्पी कोडिंग! ?