TypeScript में Clean Code: डेवलपर्स के लिए सिद्धांत और उदाहरण

TypeScript में Clean Code: ऐसा कोड कैसे लिखें जो दिखाने में शर्म न आए

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

1. वेरिएबल्स, फंक्शन्स और क्लासेस का नामकरण

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

// बुराconst d = new Date();const fn = (a: number, b: number) => a + b;

// अच्छाconst currentDate = new Date();const sum = (firstNumber: number, secondNumber: number): number => firstNumber + secondNumber;

क्लासेस के लिए संज्ञा का प्रयोग करें, फंक्शन्स के लिए क्रिया या क्रिया संरचनाओं का प्रयोग करें। बूलियन वेरिएबल्स is, has, should से शुरू होने चाहिए।

// बुराconst flag = true;function validate() { /* ... */ }

// अच्छाconst isUserActive = true;function validateEmail(email: string): boolean { /* ... */ }

2. फंक्शन्स के लिए एकल जिम्मेदारी का सिद्धांत (SRP)

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

// बुरा: फंक्शन उपयोगकर्ता खोजता है, पासवर्ड जांचता है और ईमेल भेजता हैasync function loginUser(email: string, password: string): Promise<void> {    const user = await findUserByEmail(email);    if (user && user.password === password) {        await sendLoginEmail(user.email);        console.log('Login successful');    }}

// अच्छा: जिम्मेदारी को विभाजित करेंasync function findUserByEmail(email: string): Promise<User | null> { /* ... */ }function isPasswordValid(inputPassword: string, storedHash: string): boolean { /* ... */ }async function notifyUserLogin(email: string): Promise<void> { /* ... */ }

async function loginUser(email: string, password: string): Promise<boolean> {    const user = await findUserByEmail(email);    if (!user || !isPasswordValid(password, user.passwordHash)) {        return false;    }    await notifyUserLogin(user.email);    return true;}

3. any के बजाय टाइप्स और इंटरफेसेस का उपयोग

TypeScript की मुख्य विशेषताओं में से एक इसकी टाइप सिस्टम है। किसी भी कीमत पर any से बचें। यदि टाइप पहले से ज्ञात नहीं है, तो unknown, generics या यूनियन टाइप्स का उपयोग करें। यह कोड को स्व-दस्तावेजीकरण बनाता है और त्रुटियों से बचाता है।

// बुराfunction getData(id: any): any {    return fetch(`/api/${id}`);}

// अच्छाinterface ApiResponse<T> {    data: T;    error?: string;}

async function getData<T>(id: string): Promise<ApiResponse<T>> {    const response = await fetch(`/api/${id}`);    return response.json();}

ऑब्जेक्ट्स की संरचना का वर्णन करने के लिए सख्त इंटरफेसेस का उपयोग करें। यह रिफैक्टरिंग को सरल बनाता है और IDE को प्रॉपर्टीज सुझाने में मदद करता है।

interface User {    readonly id: number;    name: string;    email: string;    role: 'admin' | 'user';}

function updateUserName(user: User, newName: string): User {    return { ...user, name: newName };}

4. त्रुटि प्रबंधन और सुरक्षात्मक प्रोग्रामिंग