लेगसी JavaScript कोड का रिफैक्टरिंग: A से Z तक

परिचय: लेगसी कोड सजा क्यों नहीं है

हर डेवलपर को देर-सबेर JavaScript में लेगसी कोड का सामना करना पड़ता है। यह 5 साल पहले "जल्दी-जल्दी" लिखे गए Node.js के मोनोलिथिक स्क्रिप्ट हो सकते हैं, या उलझे हुए callback-फंक्शन जिन्हें senior-डेवलपर भी छूने से डरते हैं। हालाँकि, लेगसी कोड का रिफैक्टरिंग सिर्फ "सब कुछ फिर से लिखना" नहीं है, बल्कि बाहरी व्यवहार को बदले बिना आर्किटेक्चर को बेहतर बनाने का एक व्यवस्थित कार्य है।

इस लेख में हम JavaScript (Node.js) पर रिफैक्टरिंग की चरण-दर-चरण योजना पर चर्चा करेंगे: विश्लेषण और परीक्षण से लेकर आधुनिक पैटर्न को लागू करने तक। आप सीखेंगे कि वास्तविक उदाहरणों का उपयोग करके "दलदल" को बनाए रखने योग्य कोड में कैसे सुरक्षित रूप से बदला जाए।

1. लेगसी कोड का विश्लेषण और मैपिंग

कोड बदलने से पहले, इसकी वर्तमान स्थिति को समझना आवश्यक है। निर्भरता का नक्शा बनाकर और "हॉट स्पॉट" की पहचान करके शुरू करें।

1.1. विश्लेषण के लिए उपकरण

JavaScript/Node.js के लिए उपयोग करें:

• ESLint complexity और max-lines नियमों के साथ — जटिल फंक्शन की पहचान करने के लिए।
• Plato या CodeClimate — साइक्लोमैटिक जटिलता को विज़ुअलाइज़ करने के लिए।
• Madge — मॉड्यूल निर्भरता ग्राफ बनाने के लिए।

1.2. "कोड की बदबू" की पहचान

लेगसी JS की सामान्य समस्याएँ:

• 100 से अधिक पंक्तियों वाले फंक्शन।
• ग्लोबल वेरिएबल और स्टेट म्यूटेशन।
• Callback hell (नेस्टेड एसिंक्रोनस कॉल)।
• मॉड्यूलरिटी का अभाव (2000+ पंक्तियों वाली एक फ़ाइल)।

// "बदबू" का उदाहरण: फंक्शन सब कुछ एक साथ करता हैfunction processUserData(userId) {    // 100 पंक्तियाँ: वैलिडेशन, DB क्वेरी, फ़ॉर्मेटिंग, ईमेल भेजना    // ... परीक्षण और रखरखाव करना मुश्किल}

2. "सुरक्षा जाल" तैयार करना: परीक्षण

परीक्षणों के बिना रिफैक्टरिंग "रूसी रूलेट" है। Characterization Tests (वर्तमान व्यवहार को रिकॉर्ड करने वाले परीक्षण) बनाएँ।

2.1. यूनिट टेस्ट जोड़ना

Jest या Mocha का उपयोग करें। क्रिटिकल पथों से शुरू करें:

// मौजूदा फंक्शन का परीक्षण, इसे बदले बिनाconst { processUserData } = require('./legacy');

describe('processUserData (legacy)', () => {    it('should process user with ID 1', () => {        const result = processUserData(1);        expect(result).toHaveProperty('email');        expect(result.status).toBe('processed');    });});

2.2. Node.js के लिए इंटीग्रेशन टेस्ट

यदि कोड DB या API के साथ काम करता है, तो HTTP अनुरोधों के लिए supertest का उपयोग करें:

const request = require('supertest');const app = require('../app');

describe('POST /api/users', () => {    it('should create user (legacy behavior)', async () => {        const res = await request(app)            .post('/api/users')            .send({ name: 'Test' });        expect(res.status).toBe(200);        expect(res.body.id).toBeDefined();    });});

3. चरण-दर-चरण रिफैक्टरिंग: मोनोलिथ से मॉड्यूल तक

प्रक्रिया को 3 चरणों में विभाजित करें: अलगाव, विघटन, अनुकूलन।

3.1. अलगाव और रैपर (Wrapper)

अंदरूनी हिस्से को न छुएं — लेगसी फंक्शन को एक नए इंटरफ़ेस में लपेटें:

// लेगसी फंक्शनfunction oldFormatDate(date) {    // ... म्यूटेशन के साथ 50 पंक्तियाँ    return formattedDate;}

// नया रैपरfunction formatDateSafe(date) {    if (!(date instanceof Date)) {        throw new Error('Invalid date');    }    return oldFormatDate(date);}

3.2. Extract Function के साथ विघटन

तार्किक ब्लॉक को अलग-अलग फंक्शन में निकालें:

// पहले: 80 पंक्तियों वाला एक फंक्शनfunction handleOrder(order) {    // 1. वैलिडेशन    if (!order.id || !order.total) { ... }    // 2. छूट की गणना