TypeScript में स्वच्छ कोड: नियम, उदाहरण और टिप्स

TypeScript में स्वच्छ कोड क्यों एक विलासिता नहीं, बल्कि एक आवश्यकता है

हर डेवलपर कम से कम एक बार ऐसी स्थिति का सामना करता है: आप एक प्रोजेक्ट खोलते हैं, जो कुछ महीने पहले लिखा गया था, और समझ नहीं पाते कि वहाँ क्या हो रहा है। वेरिएबल का नाम a, b, data है, फंक्शन 200 लाइनों के हैं, और टाइप्स बीच-बीच में लगाए गए हैं। परिचित लगता है?

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

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

1. नामकरण — आपके कोड का चेहरा

वेरिएबल, फंक्शन और क्लास का सही नामकरण 50% सफलता है। एक अच्छे नाम को सवालों का जवाब देना चाहिए: "यह क्या है?" या "यह फंक्शन क्या करता है?"।

वेरिएबल और कॉन्स्टेंट

संज्ञा और camelCase का उपयोग करें। एक अक्षर वाले नामों से बचें (लूप को छोड़कर)।

// बुरा\nconst d = new Date();\nconst u = users.find(u => u.id === 5);\n\n// अच्छा\nconst currentDate = new Date();\nconst activeUser = users.find(user => user.id === 5);\n

फंक्शन

फंक्शन के नाम क्रिया से शुरू होने चाहिए। इससे तुरंत पता चलता है कि कौन सी क्रिया की जा रही है।

// बुरा\nfunction data(id: number) { ... }\n\n// अच्छा\nfunction fetchUserData(id: number): Promise<UserData> { ... }\n

क्लास और इंटरफेस

क्लास — PascalCase में संज्ञा। इंटरफेस भी, लेकिन अक्सर I उपसर्ग के साथ (हालांकि समुदाय में बहस है)। बिना उपसर्ग के स्पष्ट नाम देना बेहतर है।

// बुरा\ninterface IUser {\n  name: string;\n}\n\n// अच्छा\ninterface User {\n  name: string;\n  email: string;\n}\n

2. सख्त टाइपिंग — आपका सबसे अच्छा दोस्त

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

any से बचें

// बुरा\nfunction process(data: any) {\n  return data.name;\n}\n\n// अच्छा\ninterface Item {\n  name: string;\n  price: number;\n}\n\nfunction process(data: Item): string {\n  return data.name;\n}\n

Union और Intersection टाइप का उपयोग करें

जब कोई वेरिएबल कई टाइप ले सकता है, तो Union (|) का उपयोग करें। संयोजन के लिए — Intersection (&) का।

type Status = 'active' | 'inactive' | 'pending';\ntype AdminUser = User & { role: 'admin' };\n

Generic — सार्वभौमिक फंक्शन

Generic आपको टाइपिंग खोए बिना लचीला कोड लिखने की अनुमति देते हैं।

function firstElement<T>(arr: T[]): T | undefined {\n  return arr[0];\n}\n\nconst num = firstElement([1, 2, 3]); // number\nconst str = firstElement(['a', 'b']); // string\n

3. SOLID — वयस्कों के लिए सिद्धांत

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

Single Responsibility (SRP)

एक क्लास या फंक्शन में बदलाव का केवल एक ही कारण होना चाहिए।

// बुरा: क्लास सब कुछ करता है\nclass UserService {\n  createUser() { ... }\n  sendEmail() { ... }\n  generateReport() { ... }\n}\n\n// अच्छा: जिम्मेदारी को विभाजित करें\nclass UserCreator { ... }\nclass EmailService { ... }\nclass ReportGenerator { ... }\n

Open/Closed (OCP)

क्लास विस्तार के लिए खुले हैं, लेकिन संशोधन के लिए बंद हैं। इंटरफेस और इनहेरिटेंस का उपयोग करें।

Liskov Substitution (LSP)

उप-क्लास को प्रोग्राम के व्यवहार को बदले बिना बेस क्लास को प्रतिस्थापित करना चाहिए।

Interface Seg