ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में कक्षाएं महत्वपूर्ण हैं लेकिन खराब तरीके से डिजाइन की गई कक्षाएं समस्याग्रस्त कोड का कारण बन सकती हैं।

क्लीन कोड अध्याय 10 एकल जिम्मेदारी के साथ एकजुट वर्गों के महत्व पर प्रकाश डालता है।

इस लेख में, हम मुख्य अंतर्दृष्टि साझा करेंगे और जावास्क्रिप्ट में उनके अनुप्रयोग का प्रदर्शन करेंगे।

? वर्ग सामंजस्य क्या है?

सामंजस्य से तात्पर्य है कि किसी वर्ग की जिम्मेदारियाँ कितनी निकटता से संबंधित हैं।

एक सामंजस्यपूर्ण वर्ग एक ही उद्देश्य पर ध्यान केंद्रित करता है और उसकी जिम्मेदारियां स्वाभाविक रूप से एक साथ फिट होती हैं।

यह कक्षा को सरल, पठनीय और रखरखाव में आसान रखता है।

उदाहरण: कम सामंजस्य

class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }

  // Handles user registration
  register() {
    // Registration logic
  }

  // Sends email to user
  sendEmail(message) {
    // Email sending logic
  }

  // Logs activity of the user
  logActivity(activity) {
    console.log(`${this.name} performed: ${activity}`);
  }
}

उपरोक्त उदाहरण में, उपयोगकर्ता वर्ग की तीन असंबंधित जिम्मेदारियां हैं: उपयोगकर्ता पंजीकरण, ईमेल भेजना और लॉगिंग गतिविधि।

इस वर्ग में सामंजस्य का अभाव है क्योंकि यह एक साथ बहुत सारे काम करने की कोशिश करता है।

? एकल उत्तरदायित्व सिद्धांत (एसआरपी)

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

यदि किसी वर्ग की एक से अधिक ज़िम्मेदारियाँ हैं, तो एक क्षेत्र में परिवर्तन दूसरे की कार्यक्षमता को तोड़ सकता है।

⚡️ एसआरपी के लिए रिफैक्टरिंग

आइए एसआरपी का पालन करने के लिए उपरोक्त उदाहरण को दोबारा दोहराएं:

class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
}

class UserRegistrationService {
  register(user) {
    // Registration logic
  }
}

class EmailService {
  sendEmail(user, message) {
    // Email sending logic
  }
}

class ActivityLogger {
  logActivity(user, activity) {
    console.log(`${user.name} performed: ${activity}`);
  }
}

अब, प्रत्येक वर्ग की एक ही जिम्मेदारी है:

• उपयोगकर्ता: उपयोगकर्ता ऑब्जेक्ट का प्रतिनिधित्व करता है और डेटा रखता है।
• UserRegistrationService: उपयोगकर्ता पंजीकरण संभालता है।
• ईमेल सेवा: ईमेल भेजने का प्रबंधन करता है।
• एक्टिविटीलॉगर: उपयोगकर्ता गतिविधि को लॉग करना संभालता है।

इस संरचना के साथ, ईमेल सिस्टम में परिवर्तन उपयोगकर्ता पंजीकरण तर्क को प्रभावित नहीं करेगा, और इसके विपरीत।

? एसआरपी और सामंजस्य के लाभ

• रखरखाव: जब किसी वर्ग की एक ही जिम्मेदारी होती है, तो बग का पता लगाना और उन्हें ठीक करना आसान होता है। आपको असंबंधित तर्क से गुज़रने की ज़रूरत नहीं है।

• स्केलेबिलिटी: जैसे-जैसे आपका प्रोजेक्ट बढ़ता है, एसआरपी का पालन करने से नई सुविधाओं को जोड़ना आसान हो जाता है। मौजूदा कक्षाओं को छुए बिना नई कक्षाओं में नई कार्यक्षमताएँ जोड़ी जा सकती हैं।

• परीक्षणशीलता: एकल जिम्मेदारी वाली कक्षाओं का परीक्षण करना आसान होता है। प्रत्येक वर्ग का दायरा सीमित होता है, इसलिए इकाई परीक्षण कार्यक्षमता के अलग-अलग हिस्सों पर ध्यान केंद्रित कर सकते हैं।

? उत्तरदायित्व ओवरलैप की पहचान करना

यह सुनिश्चित करने के लिए कि आपकी कक्षाएं एकजुट हों, उन क्षेत्रों की तलाश करें जहां कई जिम्मेदारियां संयुक्त हो रही हैं।

अक्सर, एक कक्षा सरल रूप से शुरू होती है, लेकिन जैसे-जैसे सुविधाएँ जोड़ी जाती हैं, इसमें अतिरिक्त कर्तव्य जमा हो सकते हैं।

उदाहरण: भुगतान प्रणाली को दोबारा तैयार करना

मान लें कि हमारे पास एक पेमेंटप्रोसेसर क्लास है जो कई कार्यों को संभालती है:

class PaymentProcessor {
  constructor() {
    this.paymentGateway = new PaymentGateway();
  }

  processPayment(paymentDetails) {
    // Payment processing logic
  }

  validatePaymentDetails(paymentDetails) {
    // Validation logic
  }

  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

यहां, पेमेंटप्रोसेसर भुगतान संसाधित करने, विवरण सत्यापित करने और लेनदेन लॉग करने के लिए जिम्मेदार है।

यह जिम्मेदारियों को दोबारा तय करने और विभाजित करने का एक अवसर है:

class PaymentProcessor {
  constructor(paymentGateway, validator, logger) {
    this.paymentGateway = paymentGateway;
    this.validator = validator;
    this.logger = logger;
  }

  processPayment(paymentDetails) {
    if (this.validator.isValid(paymentDetails)) {
      this.paymentGateway.process(paymentDetails);
      this.logger.logTransaction(paymentDetails);
    }
  }
}

class PaymentValidator {
  isValid(paymentDetails) {
    // Validation logic
    return true; // Simplified for example
  }
}

class PaymentLogger {
  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

अब, पेमेंटप्रोसेसर वर्ग की एक ही जिम्मेदारी है: भुगतान संसाधित करना।

सत्यापन और लॉगिंग को अलग-अलग वर्गों (पेमेंटवैलिडेटर और पेमेंटलॉगर) में ले जाया गया है।

⚡️ निष्कर्ष

सामंजस्य के साथ कक्षाएं डिजाइन करना और एकल जिम्मेदारी सिद्धांत का पालन करना सुनिश्चित करता है कि आपका कोडबेस लचीला, रखरखाव योग्य और समझने में आसान बना रहे।

जिम्मेदारियों को अलग-अलग, केंद्रित वर्गों में विभाजित करके, आप व्यक्तिगत घटकों की जटिलता को कम करते हैं और अपने सिस्टम को अधिक मजबूत बनाते हैं।

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

जैसा कि क्लीन कोड पुस्तक बताती है, स्वच्छ कक्षाएं लिखना केवल कोड को व्यवस्थित करने के बारे में नहीं है - यह एक ऐसी प्रणाली बनाने के बारे में है जिसे बनाए रखना एक दुःस्वप्न बने बिना विकसित हो सकता है।

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