ये TypeScript के प्रकार-स्तर प्रोग्रामिंग उपकरण हैं — वे मौजूदा लोगों से नए प्रकार की गणना करते हैं।
एक मैप किया गया प्रकार एक प्रकार की कुंजियों पर पुनरावृत्ति करता है और प्रत्येक को रूपांतरित करता है:
<T> = { [K keyof T]: T[K] };
<T> = { [K keyof T]?: T[K] };
{ : ; : ; }
= <>;
[K in keyof T] प्रत्येक कुंजी K पर पुनरावृत्ति करता है; T[K] उस कुंजी का मान प्रकार है। यह है कि Partial, Readonly, और Required कैसे लागू किए जाते हैं। आप कुंजियों को फिर से मैप कर सकते हैं और संशोधक जोड़ सकते हैं (-readonly, -? उन्हें हटाते हैं)।
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"
T extends U ? X : Y एक प्रकार-स्तर if/else है। infer के साथ आप शर्त में प्रकारों को निकाल सकते हैं:
type ElementOf<T> = T extends (infer U)[] ? U : never;
type E = ElementOf<string[]>; // string
// Make only the function-valued properties optional
type PartialMethods<T> = {
[K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K];
};
मैप किए गए प्रकार भी शर्तों में संघों पर वितरित करते हैं, शक्तिशाली परिवर्तन सक्षम करते हैं।
मैप किए गए और शर्तीय प्रकार लाइब्रेरीज़ को सटीक प्रकार संबंधों को व्यक्त करने देते हैं — वे उपयोगिता प्रकारों को लागू करते हैं, फॉर्म/सत्यापन लाइब्रेरीज़ को शक्ति देते हैं, ORM क्वेरी बिल्डर्स, और API क्लाइंट्स जो प्रतिक्रिया आकार का अनुमान लगाते हैं।
वे उन्नत हैं, लेकिन उन्हें समझने से समझ आता है कि कैसे TypeScript की प्रकार प्रणाली इतनी अभिव्यक्ति हो सकती है, और आपको हाथ से लिखे गए वेरिएंट के बजाय पुन: प्रयोज्य प्रकार परिवर्तन बनाने देता है।