मैप्ड टाइप्स और की-रीमैपिंग: टाइप्स को रूपांतरित करना

समझें कि होमोमॉर्फिक मैप्ड टाइप्स मॉडिफ़ायर्स को कैसे संरक्षित करते हैं और as क्लॉज़ कैसे कीज़ को नाम बदलता या छानता है।

8 मिनट · 3 प्रश्न

एक मैप्ड टाइप कीज़ के एक सेट पर पुनरावृत्ति करके एक नया ऑब्जेक्ट टाइप उत्पन्न करता है। [K in keyof T] रूप को होमोमॉर्फिक कहा जाता है: कंपाइलर जानता है कि संरचना T से आती है और प्रत्येक मूल प्रॉपर्टी के readonly और ? मॉडिफ़ायर्स को स्वचालित रूप से कॉपी कर लेता है। + और - उपसर्ग आपको इन मॉडिफ़ायर्स को स्पष्ट रूप से जोड़ने या हटाने देते हैं: यही वह आंतरिक मशीनरी है जो Partial, Required, और Readonly के पीछे है।

type Mutable<T> = {
  -readonly [K in keyof T]-?: T[K];
};

interface Config {
  readonly host?: string;
  readonly port?: number;
}

type Draft = Mutable<Config>;
// { host: string; port: number }

TypeScript 4.1 से, as क्लॉज़ की-रीमैपिंग को सक्षम करता है: प्रत्येक की को उड़ते-उड़ते नाम बदला जा सकता है, आमतौर पर एक टेम्पलेट लिटरल टाइप के माध्यम से। और यदि क्लॉज़ never उत्पन्न करता है, तो की को परिणाम से बस हटा दिया जाता है: यही आधिकारिक प्रॉपर्टी-फ़िल्टरिंग तंत्र है। उदाहरण में & string पर ध्यान दें: keyof T में symbol या number कीज़ हो सकती हैं, जो एक टेम्पलेट लिटरल के साथ असंगत हैं।

type Getters<T> = {
  [K in keyof T & string as `get${Capitalize<K>}`]:
    () => T[K];
};

interface User { name: string; age: number }
type UserGetters = Getters<User>;
// { getName: () => string; getAge: () => number }

type OnlyMethods<T> = {
  [K in keyof T as
    T[K] extends (...args: never[]) => unknown
      ? K : never]: T[K];
};

एक विनिर्देश की बारीकी जिसे अक्सर अनदेखा किया जाता है: किसी ऐरे या ट्यूपल पर लागू होने पर, एक होमोमॉर्फिक मैप्ड टाइप कीज़ 0, 1, और length वाला ऑब्जेक्ट नहीं बनाता। कंपाइलर टाइप की प्रकृति को संरक्षित करता है: यह तत्वों को रूपांतरित करता है और ऐरे या ट्यूपल का आकार बनाए रखता है। यही वह चीज़ है जो Readonly<[number, string]> को एक ट्यूपल बने रहने देती है। यह संरक्षण उसी क्षण गायब हो जाता है जब मैप्ड टाइप अब होमोमॉर्फिक नहीं रहता, उदाहरण के लिए [P in K] के साथ जहां K कीज़ का एक मनमाना यूनियन हो।

type Immutable<T> = {
  readonly [K in keyof T]: T[K];
};

type Pair = Immutable<[number, string]>;
// readonly [number, string]: the tuple survives

type List = Immutable<string[]>;
// readonly string[]

ज्ञान जांच

सुनिश्चित करें कि आपको इस पाठ के मुख्य बिंदु याद हैं।

1. एक की-रीमैपिंग में, जब as क्लॉज़ किसी की के लिए never उत्पन्न करता है तो क्या होता है?
   • प्रॉपर्टी को never टाइप मिलता है
   • की को परिणामी टाइप से हटा दिया जाता है
   • कंपाइलर एक त्रुटि जारी करता है
2. ट्यूपल [number, string] पर लागू होने पर { readonly [K in keyof T]: T[K] } क्या उत्पन्न करता है?
   • कीज़ 0, 1, और length वाला एक ऑब्जेक्ट
   • readonly [number, string]
   • readonly (number | string)[]
   • एक कंपाइलेशन त्रुटि
3. एक मैप्ड टाइप में -? मॉडिफ़ायर का प्रभाव क्या है?
   • यह प्रॉपर्टी को वैकल्पिक बना देता है
   • यह वैकल्पिकता और उसके द्वारा प्रस्तुत किए गए undefined को हटा देता है
   • यह readonly मॉडिफ़ायर को हटा देता है
   • यह प्रॉपर्टी को टाइप से हटा देता है