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

याद रखें, आपका कोड बाद में किसी अन्य डेवलपर या यहां तक ​​कि स्वयं द्वारा पढ़ा जाएगा। जब वह समय आएगा, तो आपका कोड स्व-व्याख्यात्मक होना चाहिए। प्रत्येक चर, फ़ंक्शन और टिप्पणी सटीक, साफ़ और समझने में आसान होनी चाहिए। यह दृष्टिकोण न केवल आसान रखरखाव की सुविधा देता है बल्कि आपकी विकास टीम के भीतर सहयोग और दक्षता को भी बढ़ावा देता है।

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

क्लीन कोड क्या है?

क्लीन कोड मूल रूप से उस कोड को संदर्भित करता है जो

1. समझने में आसान
2. डीबग करना आसान
3. बनाए रखना आसान है
4. टिप्पणियाँ अच्छी तरह से लिखी गई हैं, संक्षिप्त और समझने योग्य हैं
5. कोई डुप्लिकेट (अनावश्यक) कोड नहीं है और KISS नियम का पालन करता है (इसे सरल रखें, मूर्ख!)

इसके साथ ही स्वच्छ कोड लिखने के लिए डेवलपर को कोड में निरंतरता बनाए रखनी होगी और डेवलपर को विशेष भाषा के लिए सर्वोत्तम प्रथाओं का पालन करना होगा।

क्लीन कोड क्यों महत्वपूर्ण है?

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

1. पठनीयता और रखरखाव: जब कोड अच्छी तरह से लिखा गया हो, उसमें अच्छी टिप्पणियाँ हों और सर्वोत्तम प्रथाओं का पालन किया गया हो तो उसे पढ़ना और समझना आसान होता है। एक बार समस्या या बग आने पर आपको ठीक-ठीक पता चल जाता है कि इसे कहां खोजना है।

2. डिबगिंग: स्वच्छ कोड को स्पष्टता और सरलता के साथ डिज़ाइन किया गया है, जिससे कोडबेस के विशिष्ट अनुभागों का पता लगाना और समझना आसान हो जाता है। स्पष्ट संरचना, सार्थक चर नाम और अच्छी तरह से परिभाषित कार्य मुद्दों की पहचान करना और उनका समाधान करना आसान बनाते हैं।

3. बेहतर गुणवत्ता और विश्वसनीयता: स्वच्छ कोड विशेष भाषाओं की सर्वोत्तम प्रथाओं का पालन करता है और अच्छी तरह से संरचित कोड को प्राथमिकता देता है। यह गुणवत्ता जोड़ता है और विश्वसनीयता में सुधार करता है। इसलिए यह उन त्रुटियों को समाप्त कर देता है जो छोटी गाड़ी और असंरचित कोड के कारण हो सकती हैं।

अब जब हम समझ गए हैं कि क्लीन कोड क्यों महत्वपूर्ण है, तो आइए क्लीन कोड लिखने में आपकी मदद करने के लिए कुछ सर्वोत्तम प्रथाओं और सिद्धांतों पर गौर करें।

स्वच्छ संहिता के सिद्धांत

महान कोड बनाने के लिए, किसी को स्वच्छ कोड के सिद्धांतों और प्रथाओं का पालन करना होगा, जैसे कि छोटे, अच्छी तरह से परिभाषित तरीकों का उपयोग करना।

आइए इसे विवरण में देखें।

1. हार्ड-कोडित नंबरों से बचें

सीधे मूल्य का उपयोग करने के बजाय हम स्थिरांक का उपयोग कर सकते हैं और उस मूल्य को निर्दिष्ट कर सकते हैं। ताकि भविष्य में अगर हमें उस वैल्यू को अपडेट करना हो तो हमें उसे एक ही स्थान पर अपडेट करना होगा।

उदाहरण

function getDate() {
  const date = new Date();
  return "Today's date: "   date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return "Today's date: "   date;
}

इस कोड में, कुछ बिंदु पर परिवर्तन होता है कि "आज की तारीख:" के बजाय "दिनांक:" की आवश्यकता हो जाती है। उस स्ट्रिंग को एक वेरिएबल में निर्दिष्ट करके इसे बेहतर बनाया जा सकता है।

बेहतर कोड:

const todaysDateLabel = "Today's date: ";

function getDate() {
  const date = new Date();
  return todaysDateLabel   date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return todaysDateLabel   date;
}

उपरोक्त कोड में जरूरत पड़ने पर दिनांक स्ट्रिंग को बदलना आसान हो जाता है। यह रख-रखाव में सुधार करता है।

2. अर्थपूर्ण और वर्णनात्मक नामों का प्रयोग करें
हर जगह सामान्य चर नामों का उपयोग करने के बजाय हम थोड़ा अधिक वर्णनात्मक नामों का उपयोग कर सकते हैं जो स्वयं व्याख्यात्मक हैं। वेरिएबल नाम से ही उसके उपयोग को परिभाषित किया जाना चाहिए।

नाम नियम

1. वर्णनात्मक और स्पष्ट नाम चुनें।
2. अर्थपूर्ण भेद करें।
3. उच्चारण योग्य नामों का उपयोग करें।
4. खोजे जाने योग्य नामों का उपयोग करें।
5. जादुई संख्याओं को नामित स्थिरांक से बदलें।
6. एन्कोडिंग से बचें। उपसर्ग न जोड़ें या जानकारी टाइप न करें।

उदाहरण

// Calculate the area of a rectangle
function calc(w, h) {
    return w * h;
}

const w = 5;
const h = 10;
const a = calc(w, h);
console.log(`Area: ${a}`);

यहाँ कोड सही है लेकिन कोड में कुछ अस्पष्टता है। आइए उस कोड को देखें जहां वर्णनात्मक नामों का उपयोग किया जाता है।

बेहतर कोड

// Calculate the area of a rectangle
function calculateRectangleArea(width, height) {
    return width * height;
}

const rectangleWidth = 5;
const rectangleHeight = 10;
const area = calculateRectangleArea(rectangleWidth, rectangleHeight);
console.log(`Area of the rectangle: ${area}`);

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

3. केवल वहीं टिप्पणी का उपयोग करें जहां आवश्यक हो
आपको हर जगह टिप्पणियाँ लिखने की ज़रूरत नहीं है। बस वहीं लिखें जहां इसकी आवश्यकता हो और संक्षेप में लिखें और समझने में आसान हो। बहुत अधिक टिप्पणियाँ भ्रम और अव्यवस्थित कोडबेस को जन्म देंगी।

टिप्पणियां नियम

1. हमेशा अपने आप को कोड में समझाने का प्रयास करें।
2. अनावश्यक मत बनो।
3. स्पष्ट शोर न जोड़ें।
4. क्लोजिंग ब्रेस टिप्पणियों का उपयोग न करें।
5. कोड पर टिप्पणी न करें। बस हटाएं।
6. इरादे की व्याख्या के रूप में उपयोग करें।
7. कोड के स्पष्टीकरण के रूप में उपयोग करें।
8. परिणामों की चेतावनी के रूप में उपयोग करें।

उदाहरण

// Function to get the square of a number
function square(n) {
    // Multiply the number by itself
    var result = n * n; // Calculate square
    // Return the result
    return result; // Done
}

var num = 4; // Number to square
var squared = square(num); // Call function

// Output the result
console.log(squared); // Print squared number

यहां हम देख सकते हैं कि टिप्पणियों का उपयोग उन चरणों को परिभाषित करने के लिए किया जाता है जिन्हें कोड पढ़कर आसानी से समझा जा सकता है। ये टिप्पणियाँ अनावश्यक हैं और कोड को अव्यवस्थित बना रही हैं। आइये देखते हैं टिप्पणियों का सही उपयोग।

बेहतर कोड

/**
 * Returns the square of a number.
 * @param {number} n - The number to be squared.
 * @return {number} The square of the input number.
 */
function square(n) {
    return n * n;
}

var num = 4;
var squared = square(num); // Get the square of num

console.log(squared); // Output the result

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

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

कार्य नियम

1. इसे छोटा रखें।
2. एक काम करो।
3. वर्णनात्मक नामों का उपयोग करें।
4. कम तर्कों को प्राथमिकता दें।
5. विधि को कई स्वतंत्र विधियों में विभाजित करें जिन्हें क्लाइंट से बुलाया जा सकता है।

उदाहरण

async function fetchDataAndProcess(url) {
    // Fetches data from an API and processes it in the same function
    try {
        const response = await fetch(url);
        const data = await response.json();

        // Process data (e.g., filter items with value greater than 10)
        const processedData = data.filter(item => item.value > 10);

        console.log(processedData);
    } catch (error) {
        console.error('Error:', error);
    }
}

// Usage
const apiUrl = 'https://api.example.com/data';
fetchDataAndProcess(apiUrl);

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

बेहतर कोड

async function fetchData(url) {
    // Fetches data from an API
    try {
        const response = await fetch(url);
        return await response.json();
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}

function processData(data) {
    // Processes the fetched data (e.g., filter items with value greater than 10)
    return data.filter(item => item.value > 10);
}

// Usage
const apiUrl = 'https://api.example.com/data';

fetchData(apiUrl)
    .then(data => {
        const processedData = processData(data);
        console.log(processedData);
    })
    .catch(error => {
        console.error('Error:', error);
    });

इस उदाहरण में, ज़िम्मेदारियाँ अलग हो गई हैं: फ़ेचडेटा फ़ंक्शन एपीआई कॉल को संभालता है, और प्रोसेसडेटा फ़ंक्शन डेटा प्रोसेसिंग को संभालता है। इससे कोड को समझना, बनाए रखना और परीक्षण करना आसान हो जाता है।

5. कोड दोहराव से बचें (DRY सिद्धांत का पालन करें - अपने आप को न दोहराएं)

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

क्लीन कोड लिखने के अन्य सामान्य नियम

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

क्लीन कोड लिखने के लिए आज से ही इस अभ्यास और सिद्धांत को लागू करें।