TypeScript Academy · पाठ

प्रकार-स्तरीय सशर्त

सशर्त प्रकार एक्सप्रेशन के साथ प्रकारों के आधार पर शाखाएँ बनाएँ।

पाठ 2, कुल 4 में से13 चरण

प्रकार-स्तरीय सशर्त, CoddyKit पर TypeScript Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह TypeScript Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। TypeScript Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

प्रकार-स्तरीय शर्त

प्रकार-भाषा को सशर्त प्रकारों के साथ शाखाएँ मिलती हैं। T extends U ? X : Y का अर्थ है: यदि T को U की अपेक्षा वाली जगह पर असाइन किया जा सकता है, तो परिणाम X होगा, अन्यथा Y।

यह प्रकार-स्तर पर if / else अभिव्यक्ति के समकक्ष है।

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

extends का अर्थ है असाइन किया जा सकना

यह परीक्षण समानता का परीक्षण नहीं है। T extends U तब सत्य होता है जब T प्रकार के मान का उपयोग वहाँ किया जा सकता हो जहाँ U अपेक्षित है। शाब्दिक प्रकार अपने आधार प्रकार को असाइन किए जा सकते हैं।

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

परिणाम प्रकार चुनना

सशर्त प्रकार एक सामान्य प्रकार को प्रवेश के आधार पर अलग-अलग संरचनाएँ लौटाने देते हैं। यहाँ Wrap सरणियों को एकल मानों से अलग ढंग से लपेटता है।

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

कोई मान नहीं तक छँटाई

एक सामान्य युक्ति यह है कि एक शाखा में never लौटाया जाए। never का अर्थ है "कोई मान नहीं", और बाद में संघों से सदस्यों को हटाने के लिए यह उपयोगी है।

type OnlyStrings<T> = T extends string ? T : never;

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

infer के साथ अनुमान लगाना

वास्तविक शक्ति infer कीवर्ड के साथ दिखाई देती है। किसी सशर्त प्रकार के भीतर infer एक नया प्रकार चर प्रस्तुत करता है, जो मिलान किए गए प्रकार के किसी भाग को ग्रहण करता है।

यहाँ हम किसी सरणी का तत्व प्रकार ग्रहण करते हैं।

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

फ़ंक्शन परिणामों का अनुमान लगाना

आप प्रतिरूप में कहीं भी infer रख सकते हैं। किसी फ़ंक्शन का वापसी प्रकार निकालने के लिए, तीर के बाद वाले भाग का अनुमान लगाइए। अंतर्निर्मित ReturnType इसी तरह काम करता है।

type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

कई भागों का अनुमान लगाना

एक ही सशर्त प्रकार एक साथ कई infer चर प्रस्तुत कर सकता है। यहाँ हम टपल का पहला भाग और शेष भाग दोनों निकालते हैं।

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

नेस्टेड सशर्त प्रकार

सशर्त प्रकार उसी तरह एक-दूसरे के भीतर रखे जा सकते हैं जैसे जुड़े हुए else if। किसी सशर्त प्रकार की अन्यथा शाखा स्वयं एक और सशर्त प्रकार हो सकती है, जिससे निर्णयों की एक सीढ़ी बनती है।

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

शर्तों के रूप में सुरक्षा-रक्षक

किसी संरचना से कुछ निकालने से पहले उसकी जाँच करने के लिए सशर्त प्रकार का उपयोग कीजिए। यदि प्रवेश मान प्रतिरूप से मेल नहीं खाता, तो never पर लौट जाइए, ताकि गलत उपयोग दिखाई दे।

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

शर्तों को संयोजित करना

आप शर्तों को एक-दूसरे के भीतर रखकर कई शर्तें आवश्यक बना सकते हैं। यहाँ किसी प्रकार को आगे बढ़ने के लिए ऑब्जेक्ट होना और उसमें id होना, दोनों आवश्यक हैं।

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

सशर्त प्रकार हर जगह हैं

अधिकांश अंतर्निर्मित उपयोगिता प्रकार अंदर से सशर्त प्रकार ही हैं: NonNullable, Extract, Exclude, Parameters और ReturnType। extends ? : को समझ लेने से ये सभी स्पष्ट हो जाते हैं।

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

त्वरित जाँच

सशर्त प्रकारों और infer की अपनी समझ का परीक्षण कीजिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

सशर्त प्रकार प्रकार-भाषा में यदि/अन्यथा और प्रतिरूप मिलान की सुविधा देते हैं।

T extends U ? X : Y असाइन किए जा सकने के आधार पर शाखाएँ चुनता है।
infer मिलान किए गए भागों को नए चरों में ग्रहण करता है।
सशर्त प्रकार एक-दूसरे के भीतर रखकर निर्णयों की सीढ़ियाँ बनाई जा सकती हैं।
never लौटाने से सदस्य छँट जाते हैं।

अगला विषय: किसी सशर्त प्रकार को स्वयं में वापस भेजकर पुनरावृत्ति करना।

शुरुआत निःशुल्क

एआई शिक्षक के साथ TypeScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 101
पाठ: 352

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “प्रकार-स्तरीय सशर्त” पाठ निःशुल्क है?

हाँ—“प्रकार-स्तरीय सशर्त” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और TypeScript Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। TypeScript Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“प्रकार-स्तरीय सशर्त” में मैं क्या सीखूँगा?

सशर्त प्रकार एक्सप्रेशन के साथ प्रकारों के आधार पर शाखाएँ बनाएँ। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ TypeScript Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या TypeScript Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर TypeScript Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“प्रकार-स्तरीय सशर्त” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस TypeScript Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर TypeScript Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← TypeScript Academy पर वापस जाएँ