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

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

हर डेवलपर ने कभी न कभी यह महसूस किया है कि कोड लिखने के एक महीने बाद, उसका अपना ही स्क्रिप्ट अजनबी और समझ से बाहर लगने लगता है। TypeScript की दुनिया में, जहाँ सख्त टाइपिंग एक बड़ा फायदा देती है, Clean Code के सिद्धांत और भी महत्वपूर्ण हो जाते हैं। Clean Code सिर्फ सुंदरता के लिए नहीं है, बल्कि यह बग कम करने, डेवलपमेंट तेज करने और टीम वर्क को आसान बनाने का एक जरिया है। इस लेख में, हम TypeScript में Clean Code के मुख्य सिद्धांतों को वास्तविक उदाहरणों के साथ समझेंगे, जो आपको ऐसा कोड लिखने में मदद करेंगे जो पढ़ने, टेस्ट करने और मेंटेन करने में आसान हो।

1. नामकरण: वेरिएबल का नाम बताए कि वह क्या करता है

डेवलपर सबसे पहले वेरिएबल, फंक्शन और क्लास के नाम देखता है। खराब नाम पढ़ने वाले को समझने में समय बर्बाद करने पर मजबूर करता है। TypeScript में अपनी टाइप सिस्टम के साथ, नाम को स्वयं-दस्तावेजीकरण करने वाला होना चाहिए।

खराब उदाहरण:

const d = new Date();\nconst arr = [1, 2, 3];\nfunction proc(x: number, y: number) {\n    return x * y;\n}

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

const currentDate = new Date();\nconst userScores: number[] = [1, 2, 3];\nfunction calculateArea(width: number, height: number): number {\n    return width * height;\n}

वेरिएबल के लिए संज्ञा और फंक्शन के लिए क्रिया का उपयोग करें। संक्षिप्ताक्षरों से बचें (सिवाय सामान्य जैसे id या url के)। TypeScript टाइप जोड़ने की सुविधा देता है, लेकिन नाम को फिर भी सार को दर्शाना चाहिए।

2. फंक्शन: छोटे, साफ और पूर्वानुमानित

फंक्शन को केवल एक ही काम करना चाहिए। यदि आप फंक्शन के लिए छोटा नाम नहीं सोच पा रहे हैं, तो संभवतः वह बहुत अधिक काम कर रहा है। साइड इफेक्ट से बचना भी महत्वपूर्ण है।

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

// खराब: फंक्शन सब कुछ एक साथ करता है\nfunction processUserData(user: User): void {\n    // वैलिडेशन\n    if (!user.email) throw new Error('Email required');\n    // डेटाबेस में सेव करना\n    database.save(user);\n    // ईमेल भेजना\n    emailService.sendWelcome(user.email);\n}\n\n// अच्छा: जिम्मेदारी को अलग करना\nfunction validateUser(user: User): boolean {\n    return user.email !== undefined;\n}\n\nfunction saveUser(user: User): void {\n    database.save(user);\n}\n\nfunction sendWelcomeEmail(email: string): void {\n    emailService.send(email);\n}\n\nfunction processUser(user: User): void {\n    if (!validateUser(user)) {\n        throw new Error('Invalid user data');\n    }\n    saveUser(user);\n    sendWelcomeEmail(user.email);\n}

साथ ही, बहुत अधिक पैरामीटर से बचें। यदि दो से अधिक हैं, तो उन्हें एक ऑब्जेक्ट में जोड़ें:

// खराब\nfunction createUser(name: string, email: string, age: number, isAdmin: boolean): void {}\n\n// अच्छा\ninterface CreateUserParams {\n    name: string;\n    email: string;\n    age: number;\n    isAdmin: boolean;\n}\n\nfunction createUser(params: CreateUserParams): void {}

3. टाइपिंग: TypeScript की क्षमताओं का पूरा उपयोग करें

TypeScript का एक मुख्य लाभ सख्त टाइपिंग है। लेकिन कई डेवलपर any का उपयोग एक कच्चे साधन के रूप में करते हैं, जिससे सारा लाभ खत्म हो जाता है। TypeScript में Clean Code वह कोड है जहाँ टाइप स्पष्ट रूप से वर्णित हों, न कि अनुमान लगाए जाएँ।

any से बचें:

// खराब\nfunction getData(): any {\n    return fetch('/api/data');\n}\n\n// अच्छा\ninterface ApiResponse {\n    id: number;\n    title: string;\n}\n\nasync function getData(): Promise<ApiResponse> {\n    const response = await fetch('/api/data');\n    return response.json();\n}

जटिल स्थितियों के लिए discriminated unions का उपयोग करें:

// खराब: ऑब्जेक्ट में क्या है, स्पष्ट नहीं\ntype Status = 'loading' | 'success' | 'error';\n\ninterface State {\n    status: Status;\n    data?: Data;\n    error?: string;\n}\n\n// अच्छा: प्रत्येक