TypeScript में क्लीन कोड: अभ्यासकर्ताओं के लिए सिद्धांत और उदाहरण

TypeScript में क्लीन कोड: सिद्धांत और व्यवहार में उदाहरण

क्लीन कोड सिर्फ एक फैशनेबल शब्द नहीं है, बल्कि एक पेशेवर डेवलपर का मूलभूत कौशल है। TypeScript के संदर्भ में, जो JavaScript की गतिशील दुनिया में स्थैतिक टाइपिंग जोड़ता है, क्लीन कोड के सिद्धांत और भी महत्वपूर्ण हो जाते हैं। TypeScript हमें कोड को स्व-दस्तावेजीकरण करने के लिए शक्तिशाली उपकरण देता है, लेकिन सही दृष्टिकोण के बिना वे अव्यवस्था में बदल सकते हैं।

इस लेख में, हम TypeScript पर लागू क्लीन कोड के प्रमुख सिद्धांतों पर चर्चा करेंगे और व्यावहारिक उदाहरण देखेंगे जो आपको अधिक पठनीय, रखरखाव योग्य और विश्वसनीय कोड लिखने में मदद करेंगे।

1. नामकरण: व्यवसाय की भाषा में बोलें

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

खराब उदाहरण:

// यह फ़ंक्शन क्या करता है? इसे समझने में कितना समय लगता है?\nfunction d(a: number, b: number): number {\n    return a * b - (a + b);\n}\n\n// और यह इंटरफ़ेस क्या है?\ninterface I {\n    n: string;\n    a: number;\n    e: string;\n}

अच्छा उदाहरण:

// सीमा के साथ छूट की गणना करने का फ़ंक्शन\nfunction calculateDiscountedPrice(price: number, discountPercent: number): number {\n    const discountAmount = price * (discountPercent / 100);\n    return price - discountAmount;\n}\n\n// स्पष्ट फ़ील्ड वाला उपयोगकर्ता इंटरफ़ेस\ninterface UserProfile {\n    name: string;\n    age: number;\n    email: string;\n}

TypeScript के लिए नियम:

\n
• इंटरफ़ेस — बिना I उपसर्ग के संज्ञाओं का उपयोग करें (जैसे, User, IUser नहीं)। आधुनिक TypeScript और ESLint इसी दृष्टिकोण की सलाह देते हैं।
\n
• प्रकार — जटिल संयोजनों के लिए | यूनियन और सार्थक नामों का उपयोग करें: StatusType, ApiResponse।
\n
• बूलियन चर — is, has, should से शुरू करें: isActive, hasPermission।
\n
• फ़ंक्शन — क्रियाओं का उपयोग करें: getUserData, validateEmail, processOrder।
\n

2. TypeScript में SOLID: व्यावहारिक अनुप्रयोग

SOLID सिद्धांत (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) इंटरफ़ेस, एब्सट्रैक्ट क्लास और जेनेरिक के समर्थन के कारण TypeScript पर पूरी तरह से लागू होते हैं।

एकल उत्तरदायित्व का सिद्धांत (SRP): एक क्लास में बदलाव का केवल एक ही कारण होना चाहिए।

// SRP का उल्लंघन: क्लास बहुत अधिक करता है\nclass UserService {\n    createUser(data: any) { /* ... */ }\n    sendEmail(email: string) { /* ... */ }\n    generateReport() { /* ... */ }\n}\n\n// सही दृष्टिकोण: उत्तरदायित्व का विभाजन\nclass UserRepository {\n    save(user: User): void { /* ... */ }\n}\n\nclass EmailService {\n    sendWelcomeEmail(email: string): void { /* ... */ }\n}\n\nclass ReportGenerator {\n    generateUserReport(users: User[]): Report { /* ... */ }\n}

बारबरा लिस्कोव का प्रतिस्थापन सिद्धांत (LSP): उपवर्गों को आधार वर्ग के साथ विनिमेय होना चाहिए। TypeScript में यह विरासत के साथ काम करते समय विशेष रूप से प्रासंगिक है।

// LSP का उल्लंघन: उपवर्ग अनुबंध को संकुचित करता है\nclass Bird {\n    fly(): void { console.log('Flying'); }\n}\n\nclass Penguin extends Bird {\n    fly(): void {\n        throw new Error('Penguins cannot fly!');\n    }\n}\n\n// सही: इंटरफ़ेस को अलग करना\ninterface Flyable {\n    fly(): void;\n}\n\nclass Bird implements Flyable {\n    fly(): void { console.log('Flying'); }\n}\n\nclass Penguin {\n    s