TypeScript: Interfaces vs Types — 2024 में क्या चुनें?

परिचय: TypeScript डेवलपर्स की शाश्वत बहस

यदि आपने कभी TypeScript में लिखा है, तो आपने निश्चित रूप से इस प्रश्न का सामना किया होगा: "कब interface का उपयोग करें, और कब type का?" यह प्रश्न Stack Overflow पर हज़ारों बार देखा जा चुका है और शुरुआती लोगों के लिए एक वास्तविक बाधा बन गया है। आइए इस दुविधा को एक बार और हमेशा के लिए समझ लें।

TypeScript, JavaScript के ऊपर एक परत है जो स्थिर टाइपिंग (static typing) जोड़ता है। और हमारे पास डेटा संरचना का वर्णन करने के लिए दो मुख्य उपकरण हैं: Interface और Type Alias। पहली नज़र में वे एक ही काम करते हैं, लेकिन असली अंतर विवरण में छिपा है। इस लेख में हम केवल अंतरों को सूचीबद्ध नहीं करेंगे - हम उन्हें वास्तविक उदाहरणों के साथ दिखाएंगे और स्पष्ट सिफारिशें देंगे।

Interface क्या है?

Interface किसी ऑब्जेक्ट की संरचना का वर्णन करने का एक तरीका है। यह डेटा के लिए एक ब्लूप्रिंट की तरह है: आप TypeScript को बताते हैं कि ऑब्जेक्ट में कौन से गुण (properties) और विधियाँ (methods) होनी चाहिए।

// बेसिक इंटरफ़ेस\ninterface User {\n    name: string;\n    age: number;\n    email?: string; // वैकल्पिक गुण\n    readonly id: number; // केवल पढ़ने के लिए\n}\n\n// उपयोग\nconst user: User = {\n    name: "अन्ना",\n    age: 25,\n    id: 1\n};

इंटरफ़ेस एक दूसरे से विरासत प्राप्त कर सकते हैं, जो उन्हें पदानुक्रम (hierarchies) का वर्णन करने के लिए आदर्श बनाता है:

interface Animal {\n    name: string;\n    sound(): void;\n}\n\ninterface Dog extends Animal {\n    breed: string;\n    wagTail(): void;\n}\n\n// अब Dog में Animal के सभी फ़ील्ड + अपने फ़ील्ड शामिल हैं\nconst myDog: Dog = {\n    name: "रेक्स",\n    breed: "शेफर्ड",\n    sound() { console.log("भौं!"); },\n    wagTail() { console.log("पूंछ हिलाता है"); }\n};

Type Alias क्या है?

Type Alias (प्रकार का उपनाम) एक अधिक लचीला उपकरण है। यह न केवल ऑब्जेक्ट, बल्कि प्रिमिटिव (primitives), यूनियन (unions) और इंटरसेक्शन (intersections) का भी वर्णन कर सकता है।

// प्रिमिटिव के लिए प्रकार\ntype ID = string | number;\n\n// ऑब्जेक्ट के लिए प्रकार\ntype UserType = {\n    name: string;\n    age: number;\n};\n\n// फ़ंक्शन के लिए प्रकार\ntype Greeting = (name: string) => string;\n\n// Union Type (संघ)\ntype Status = "active" | "inactive" | "pending";\n\n// Intersection Type (प्रतिच्छेदन)\ntype Person = { name: string };\ntype Employee = Person & { salary: number };

प्रकारों की मुख्य सुपरपावर union types है। इंटरफ़ेस ऐसा नहीं कर सकते:

// ❌ interface के साथ ऐसा नहीं किया जा सकता\n// interface Status = "active" | "inactive"; // त्रुटि!\n\n// ✅ लेकिन type के साथ आसान है!\ntype Status = "active" | "inactive" | "pending";\n\nfunction processStatus(status: Status) {\n    switch (status) {\n        case "active":\n            console.log("सक्रिय");\n            break;\n        case "inactive":\n            console.log("निष्क्रिय");\n            break;\n        case "pending":\n            console.log("लंबित");\n            break;\n    }\n}

मुख्य अंतर: Interface vs Type

आइए व्यवहार में वे कैसे भिन्न हैं, इसे विस्तार से समझें।

1. प्रकारों का संघ और प्रतिच्छेदन

Type सीधे union (|) और intersection (&) का समर्थन करता है। Interface केवल extends के माध्यम से।

// Union — केवल type\ntype Success = { data: string };\ntype Error = { error: string };\ntype Result = Success | Error; // संभव है!\n\n// Intersection\ntype Full = Success & Error; // संभव है!\n\n// Interface के लिए अलग-अलग इंटरफ़ेस बनाने होंगे\ninterface IResult extends Success, Error {} // काम करता है, लेकिन बोझिल है

2. Declaration merging (घोषणाओं का विलय)

यह इंटरफ़ेस की एक अनूठी विशेषता है। यदि आप एक ही नाम से दो इंटरफ़ेस घोषित करते हैं, तो TypeScript उन्हें मिला देगा।

// पहला इंटरफ़ेस\ninterface User {\n    name: string;\n}\n\n// उसी नाम से दूसरा इंटरफ़ेस\ninterface User {\n    age: number;\n}\n\n// परिणाम: User = { name: string; age: number; }\nconst user: User = {\n