TypeScript में इंटरफ़ेस प्रकार की जाँच: सामान्य प्रश्न और उत्तर

परिचय: इंटरफ़ेस runtime के दौरान काम क्यों नहीं करते?

नमस्ते दोस्त! यदि आपने कभी TypeScript में लिखा है, तो आपने निश्चित रूप से इस स्थिति का सामना किया होगा: आप एक आदर्श इंटरफ़ेस बनाते हैं, सभी फ़ील्ड का वर्णन करते हैं, संकलन चरण में प्रकारों की जाँच करते हैं - और अचानक आपको पता चलता है कि runtime में आपका कोड ऐसा व्यवहार करता है जैसे कोई इंटरफ़ेस मौजूद ही नहीं है। परिचित लगता है? 🎯

यह Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है: "Interface type check with TypeScript" - हज़ारों बार देखा गया, सैकड़ों उत्तर। और कोई आश्चर्य नहीं, क्योंकि TypeScript संकलन के दौरान इंटरफ़ेस को मिटा देता है। कक्षाओं के विपरीत, इंटरफ़ेस डेवलपर और कंपाइलर के लिए पूरी तरह से घोषणात्मक निर्माण हैं। JavaScript में वे मौजूद नहीं हैं।

इस लेख में, हम समझेंगे कि इस सीमा को कैसे दूर किया जाए, runtime में किसी ऑब्जेक्ट के इंटरफ़ेस से मेल खाने की जाँच करना सीखेंगे, और सबसे सामान्य प्रश्नों के उत्तर देंगे। चलिए शुरू करते हैं! 🚀

हम इंटरफ़ेस की जाँच क्यों करना चाहते हैं?

कल्पना करें: आप API, फ़ॉर्म या WebSocket से डेटा प्राप्त करते हैं। आपको विश्वास है कि वे User इंटरफ़ेस से मेल खाते हैं, लेकिन अचानक एक ऑब्जेक्ट बिना email फ़ील्ड के या गलत प्रकार के साथ आता है। यदि जाँच नहीं की गई - तो आपका कोड त्रुटि के साथ क्रैश हो जाएगा। TypeScript इंटरफ़ेस केवल विकास चरण में जाँच करते हैं, उत्पादन में नहीं। इसलिए, runtime जाँच की आवश्यकता है।

समस्या: इंटरफ़ेस runtime में मौजूद नहीं हैं

TypeScript में, इंटरफ़ेस स्थिर टाइपिंग के लिए "सिंटैक्टिक शुगर" हैं। जब आप कोड संकलित करते हैं, तो इंटरफ़ेस गायब हो जाते हैं। यहाँ एक सरल उदाहरण है:

interface User {\n  name: string;\n  age: number;\n}\n\nconst data: unknown = JSON.parse('{"name": "अलीसा"}');\nif (data instanceof User) { // ❌ त्रुटि! User एक इंटरफ़ेस है, क्लास नहीं\n  console.log(data.name);\n}

कंपाइलर कहेगा: 'User' only refers to a type, but is being used as a value here. यह शुरुआती लोगों के लिए मुख्य जाल है। लेकिन चिंता न करें - इसे दूर करने के कई सिद्ध तरीके हैं।

विधि 1: कस्टम टाइप गार्ड (User-Defined Type Guards)

सबसे लोकप्रिय और सुरुचिपूर्ण तरीका एक टाइप गार्ड फ़ंक्शन लिखना है। यह ऑब्जेक्ट की संरचना की जाँच करता है और true/false लौटाता है, और TypeScript "समझता है" कि true वाले ब्लॉक के अंदर ऑब्जेक्ट निश्चित रूप से इंटरफ़ेस से मेल खाता है।

interface User {\n  name: string;\n  age: number;\n  email?: string; // वैकल्पिक फ़ील्ड\n}\n\nfunction isUser(obj: unknown): obj is User {\n  if (typeof obj !== 'object' || obj === null) return false;\n\n  const user = obj as Record<string, unknown>;\n  return (\n    typeof user.name === 'string' &&\n    typeof user.age === 'number' &&\n    (user.email === undefined || typeof user.email === 'string')\n  );\n}\n\n// उपयोग का उदाहरण\nconst data: unknown = JSON.parse('{"name": "बॉब", "age": 30}');\n\nif (isUser(data)) {\n  // अब TypeScript जानता है कि data एक User है\n  console.log(data.name.toUpperCase()); // ✅ काम करता है\n}

लाभ: पूर्ण नियंत्रण, प्रकार सही ढंग से निकाले जाते हैं, विस्तार करना आसान है।
\nनुकसान: प्रत्येक इंटरफ़ेस के लिए मैन्युअल रूप से लिखना पड़ता है (लेकिन लाइब्रेरीज़ मौजूद हैं!)

obj is User क्या है?

यह टाइप गार्ड का सिंटैक्स है। यह TypeScript को बताता है: "यदि फ़ंक्शन true लौटाता है, तो तर्क obj को User प्रकार माना जा सकता है"। यह वह जादू है जो स्थिर विश्लेषण के लिए runtime जाँच को उपयोगी बनाता है।

विधि 2: इंटरफ़ेस के बजाय कक्षाओं का उपयोग करना

कक्षाएँ एकमात्र TypeScript निर्माण हैं जो JavaScript में संरक्षित रहती हैं। यदि आपको runtime में प्रकार की जाँच करने की आवश्यकता है, तो आप instanceof के माध्यम से जाँच के साथ इंटरफ़ेस को एक क्लास से बदल सकते हैं।

class User {\n  constructor(\n    public name: string,\n    public age: number,\n    public email?: string\n  ) {}\n}\n\nconst data = new User('चार्ली', 25);\nif (data instanceof User) {\n  consol