TypeScript इंटरफ़ेस की कुंजियों को स्ट्रिंग्स की सरणी के रूप में कैसे प्राप्त करें 2025

परिचय: आपको सरणी के रूप में इंटरफ़ेस कुंजियों की आवश्यकता क्यों है?

कल्पना करें: आप TypeScript पर एक बड़े प्रोजेक्ट पर काम कर रहे हैं, और आपको एक जटिल ऑब्जेक्ट के सभी फ़ील्ड्स पर पुनरावृति करनी है, React पर एक डायनामिक फॉर्म बनाना है, डेटा को फ़िल्टर करना है या बस उपलब्ध गुणों की सूची प्रदर्शित करनी है। समस्या यह है कि TypeScript, JavaScript के ऊपर एक ओवरले है, और इसके प्रकार केवल संकलन के समय मौजूद होते हैं। रनटाइम में वे गायब हो जाते हैं। तो क्या करें? वास्तविक कोड में उपयोग करने के लिए TypeScript इंटरफ़ेस की कुंजियों को स्ट्रिंग्स की सरणी के रूप में कैसे प्राप्त करें?

यह वह प्रश्न है जो Stack Overflow पर हज़ारों डेवलपर्स को परेशान करता है। आज, 2025 में, हम सभी संभावित दृष्टिकोणों पर चर्चा करेंगे: सरल और विश्वसनीय से लेकर उन्नत तक। आप सीखेंगे कि TypeScript को अपने लिए कैसे काम में लाएँ, न कि अपने खिलाफ। चलिए शुरू करते हैं!

समस्या: "गायब होने वाले" प्रकार

आइए सीधे समस्या की जड़ पर नज़र डालें। मान लीजिए, आपके पास ऐसा इंटरफ़ेस है:

interface User {\n  id: number;\n  name: string;\n  email: string;\n  isAdmin: boolean;\n}

आपको स्ट्रिंग्स की एक सरणी प्राप्त करनी है: ['id', 'name', 'email', 'isAdmin']। पहली चीज़ जो दिमाग में आती है वह है Object.keys() का उपयोग करना। लेकिन एक बारीकी है। यदि आप इस तरह लिखने का प्रयास करते हैं:

const keys = Object.keys({} as User);\n// प्रकार: string[]\n

TypeScript आपको string[] प्रकार लौटाएगा, न कि ('id' | 'name' | 'email' | 'isAdmin')[]। यह अर्थहीन है — आप विशिष्ट कुंजियों के बारे में सारी जानकारी खो देते हैं।

ऐसा क्यों होता है? क्योंकि JavaScript में Object.keys() हमेशा स्ट्रिंग्स की एक सरणी लौटाता है। TypeScript निश्चित रूप से नहीं जान सकता कि निष्पादन के दौरान ऑब्जेक्ट में कौन सी कुंजियाँ होंगी (उदाहरण के लिए, यदि ऑब्जेक्ट का विस्तार होता है)। इसलिए यह सबसे सुरक्षित, लेकिन बेकार प्रकार देता है।

समाधान 1: "मैन्युअल" सरणी (सरलता और सुरक्षा)

सबसे सरल और 90% मामलों के लिए अनुशंसित तरीका मैन्युअल रूप से एक सरणी बनाना और उससे प्रकार निकालना है। यह कोई मज़ाक नहीं है। यह दृष्टिकोण गारंटी देता है कि आपकी सरणी हमेशा इंटरफ़ेस के साथ सिंक्रोनाइज़ रहेगी।

// 1. कुंजियों की सरणी परिभाषित करें\nexport const USER_KEYS = ['id', 'name', 'email', 'isAdmin'] as const;\n\n// 2. सरणी से प्रकार निकालें\ntype UserKey = typeof USER_KEYS[number]; // 'id' | 'name' | 'email' | 'isAdmin'\n\n// 3. इंटरफ़ेस के लिए उपयोग करें\ninterface User {\n  [key in UserKey]: key extends 'id' ? number \n    : key extends 'name' ? string \n    : key extends 'email' ? string \n    : boolean;\n}\n\n// 4. स्ट्रिंग्स की सरणी प्राप्त करें\nconst keys: string[] = [...USER_KEYS];\nconsole.log(keys); // ['id', 'name', 'email', 'isAdmin']\n

लाभ: पूर्ण टाइपिंग, कोई जादुई ट्रिक नहीं, पढ़ने और बनाए रखने में आसान।

नुकसान: दो स्थानों (इंटरफ़ेस और सरणी) को मैन्युअल रूप से बनाए रखने की आवश्यकता है।

समाधान 2: keyof के साथ उपयोगिता प्रकार (उन्नत, लेकिन शर्तों के साथ)

TypeScript keyof ऑपरेटर प्रदान करता है, जो कुंजियों का एक यूनियन प्रकार (union type) लौटाता है। लेकिन इस यूनियन को स्ट्रिंग्स की सरणी में कैसे बदलें? 2025 में, इसके लिए अभी भी एक छोटी सी ट्रिक की आवश्यकता है।

क्लासिक तरीका एक सहायक फ़ंक्शन का उपयोग करना है जो संकलन के समय प्रकारों की जाँच करता है:

// सहायक फ़ंक्शन\nfunction getKeys<T>(obj: T): (keyof T)[] {\n  return Object.keys(obj) as (keyof T)[];\n}\n\n// उपयोग\ninterface Product {\n  title: string;\n  price: number;\n  inStock: boolean;\n}\n\nconst product: Product = {\n  title: 'Keyboard',\n  price: 100,\n  inStock: true\n};\n\nconst productKeys = getKeys(product);\n// प्रकार: ("title" | "price" | "inStock")[]\nconsole.log(productKeys); // ['title', 'price', 'inStock']\n

महत्वपूर्ण: यह विधि केवल तभी काम करती है जब आपके पास इंटरफ़ेस के अनुरूप एक वास्तविक ऑब्जेक्ट हो। यदि आपके पास केवल इंटरफ़ेस है, लेकिन कोई ऑब्जेक्ट नहीं है, तो आपको बनाना होगा