सॉफ़्टवेयर सिस्टम बनाते समय, कोडबेस जटिलता को प्रबंधित करना महत्वपूर्ण है।

क्लीन कोड का अध्याय 11 ऐसे मॉड्यूलर सिस्टम को डिजाइन करने पर चर्चा करता है जिन्हें समय के साथ बनाए रखना और अनुकूलित करना आसान होता है।

हम इन अवधारणाओं को स्पष्ट करने के लिए जावास्क्रिप्ट उदाहरणों का उपयोग कर सकते हैं।

? बड़ी प्रणालियों के साथ समस्या

जैसे-जैसे सिस्टम बढ़ते हैं, वे स्वाभाविक रूप से अधिक जटिल हो जाते हैं। यह जटिलता इसे कठिन बना सकती है:

• सिस्टम को समग्र रूप से समझें।
• अनपेक्षित दुष्प्रभाव पैदा किए बिना परिवर्तन करें।
• नई सुविधाओं या आवश्यकताओं के साथ सिस्टम को स्केल करें।

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

? मॉड्यूलैरिटी: बांटो और राज करो

स्वच्छ सिस्टम डिज़ाइन के केंद्र में मॉड्यूलरिटी का सिद्धांत है। आप एक बड़े सिस्टम को छोटे, स्वतंत्र मॉड्यूल में तोड़कर, प्रत्येक को स्पष्ट जिम्मेदारी के साथ, सिस्टम को अधिक प्रबंधनीय बनाते हैं।

प्रत्येक मॉड्यूल को एक विशिष्ट कार्यक्षमता को समाहित करना चाहिए, जिससे समग्र प्रणाली को समझना और बदलना आसान हो जाएगा।

उदाहरण: शॉपिंग कार्ट सिस्टम का आयोजन

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

// cart.js
export class Cart {
    constructor() {
        this.items = [];
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        return this.items.reduce((total, item) => total   item.price, 0);
    }
}

// item.js
export class Item {
    constructor(name, price) {
        this.name = name;
        this.price = price;
    }
}

// order.js
import { Cart } from './cart.js';
import { Item } from './item.js';

const cart = new Cart();
cart.addItem(new Item('Laptop', 1000));
cart.addItem(new Item('Mouse', 25));

console.log(`Total: $${cart.getTotal()}`);

जिम्मेदारियां यहां विभाजित हैं: कार्ट आइटम का प्रबंधन करता है, आइटम एक उत्पाद का प्रतिनिधित्व करता है, और order.js इंटरैक्शन को व्यवस्थित करता है।

यह पृथक्करण सुनिश्चित करता है कि प्रत्येक मॉड्यूल स्व-निहित है और स्वतंत्र रूप से परीक्षण करना और बदलना आसान है।

? एनकैप्सुलेशन: कार्यान्वयन विवरण छुपाएं

मॉड्यूलैरिटी के लक्ष्यों में से एक एनकैप्सुलेशन है - एक मॉड्यूल के आंतरिक कामकाज को सिस्टम के बाकी हिस्सों से छिपाना।

बाहरी कोड को केवल अपने सुपरिभाषित इंटरफ़ेस के माध्यम से एक मॉड्यूल के साथ इंटरैक्ट करना चाहिए।

यह सिस्टम के अन्य हिस्सों को प्रभावित किए बिना मॉड्यूल के आंतरिक कार्यान्वयन को बदलना आसान बनाता है।

उदाहरण: इनकैप्सुलेटिंग कार्ट लॉजिक

मान लें कि हम कार्ट में कुल की गणना करने के तरीके को बदलना चाहते हैं। शायद अब हमें बिक्री कर का हिसाब देना होगा। हम इस तर्क को कार्ट क्लास के अंदर समाहित कर सकते हैं:

// cart.js
export class Cart {
    constructor(taxRate) {
        this.items = [];
        this.taxRate = taxRate;
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        const total = this.items.reduce((sum, item) => sum   item.price, 0);
        return total   total * this.taxRate;
    }
}

// Now, the rest of the system does not need to know about tax calculations.

सिस्टम के अन्य हिस्से (जैसे order.js) कुल गणना के तरीके में बदलाव से अप्रभावित रहते हैं। यह आपके सिस्टम को अधिक लचीला और रखरखाव में आसान बनाता है।

? चिंताओं को अलग करना: जिम्मेदारियों को स्पष्ट रखें

बड़े सिस्टम में एक आम समस्या यह है कि सिस्टम के विभिन्न हिस्से आपस में उलझ जाते हैं।

जब कोई मॉड्यूल बहुत अधिक जिम्मेदारियां लेना शुरू कर देता है, तो विभिन्न संदर्भों में इसे बदलना या पुन: उपयोग करना कठिन हो जाता है।

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

उदाहरण: भुगतान को अलग से संभालना

शॉपिंग कार्ट उदाहरण में, भुगतान प्रसंस्करण को एक अलग मॉड्यूल में नियंत्रित किया जाना चाहिए:

// payment.js
export class Payment {
    static process(cart) {
        const total = cart.getTotal();
        console.log(`Processing payment of $${total}`);
        // Payment logic goes here
    }
}

// order.js
import { Cart } from './cart.js';
import { Payment } from './payment.js';

const cart = new Cart(0.07); // 7% tax rate
cart.addItem(new Item('Laptop', 1000));
cart.addItem(new Item('Mouse', 25));

Payment.process(cart);

अब, भुगतान तर्क को कार्ट प्रबंधन से अलग कर दिया गया है। इससे शेष सिस्टम को प्रभावित किए बिना बाद में भुगतान प्रक्रिया को संशोधित करना आसान हो जाता है (उदाहरण के लिए, एक अलग भुगतान प्रदाता के साथ एकीकृत करना)।

? मॉड्यूल का स्वतंत्र रूप से परीक्षण करना

मॉड्यूलैरिटी का सबसे बड़ा लाभ यह है कि आप प्रत्येक मॉड्यूल का स्वतंत्र रूप से परीक्षण कर सकते हैं।

उपर्युक्त उदाहरण में, आप भुगतान कैसे संसाधित किए जाते हैं इसके बारे में चिंता किए बिना कार्ट क्लास के लिए यूनिट परीक्षण लिख सकते हैं।

उदाहरण: कार्ट का परीक्षण करने वाली इकाई

// cart.test.js
import { Cart } from './cart.js';
import { Item } from './item.js';

test('calculates total with tax', () => {
    const cart = new Cart(0.05); // 5% tax
    cart.addItem(new Item('Book', 20));

    expect(cart.getTotal()).toBe(21);
});

चिंताओं के स्पष्ट पृथक्करण के साथ, प्रत्येक मॉड्यूल का अलग-अलग परीक्षण किया जा सकता है, जिससे डिबगिंग आसान हो जाती है और विकास तेज हो जाता है।

? निर्भरता को संभालना: टाइट कपलिंग से बचें

जब मॉड्यूल एक-दूसरे पर बहुत अधिक निर्भर होते हैं, तो सिस्टम के एक हिस्से में परिवर्तन के अन्यत्र अप्रत्याशित परिणाम हो सकते हैं।

इसे कम करने के लिए, मॉड्यूल के बीच ढीले युग्मन का लक्ष्य रखें।

यह प्रत्येक मॉड्यूल को स्वतंत्र रूप से विकसित करने की अनुमति देता है।

उदाहरण: निर्भरता इंजेक्ट करना

मॉड्यूल के अंदर हार्डकोडिंग निर्भरता के बजाय, उन्हें तर्क के रूप में पास करें:

// cart.js
export class Cart {
    constructor(taxRateCalculator) {
        this.items = [];
        this.taxRateCalculator = taxRateCalculator;
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        const total = this.items.reduce((sum, item) => sum   item.price, 0);
        return total   this.taxRateCalculator(total);
    }
}

यह दृष्टिकोण कार्ट क्लास को अधिक लचीला और विभिन्न कर गणनाओं के साथ परीक्षण करना आसान बनाता है।

निष्कर्ष: सिस्टम को मॉड्यूलर, लचीला और बदलने में आसान रखें

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