प्रकार-स्तरीय पुनरावृत्ति
पुनरावर्ती सशर्त प्रकारों की सहायता से प्रकारों पर लूप चलाएँ।
प्रकार-स्तरीय पुनरावृत्ति, CoddyKit पर TypeScript Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह TypeScript Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। TypeScript Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
प्रकारों में पुनरावृत्ति
कोई सशर्त प्रकार स्वयं का संदर्भ दे सकता है। इससे प्रकार-भाषा में दोहराव संभव होता है। अधिकांश प्रकार-स्तरीय पुनरावृत्ति एक टपल को एक बार में एक तत्व के हिसाब से पढ़ती है, उसका पहला तत्व अलग करती है और शेष भाग पर पुनरावृत्ति करती है।
type Length<T extends unknown[]> =
T extends [unknown, ...infer Rest]
? Length<Rest>
: 0;
// (this counts down to a base case)मूल स्थिति
हर पुनरावृत्ति के लिए एक रोकने वाली शर्त आवश्यक होती है। टपल के लिए यह सामान्यतः खाली टपल होती है। जब [head, ...rest] प्रतिरूप से मेल नहीं खाता, तब आप अंत तक पहुँच चुके होते हैं और एक निश्चित परिणाम लौटाते हैं।
type IsEmpty<T extends unknown[]> =
T extends [] ? true : false;
type A = IsEmpty<[]>; // true
type B = IsEmpty<[1, 2]>; // falseअग्रभाग और शेषभाग
मुख्य प्रक्रिया यह है कि विस्तारण प्रतिरूप के साथ infer का उपयोग करके टपल को उसके पहले तत्व और बचे हुए टपल में बाँटा जाए।
type Head<T extends unknown[]> = T extends [infer H, ...unknown[]] ? H : never;
type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];
type A = Head<[1, 2, 3]>; // 1
type B = Tail<[1, 2, 3]>; // [2, 3]एक-एक तत्व को संसाधित करना
पूरे टपल को बदलने के लिए अग्रभाग, शेषभाग और पुनरावृत्ति को मिलाइए। ToStrings टपल को फिर से बनाता है और हर तत्व प्रकार को string से बदल देता है।
type ToStrings<T extends unknown[]> =
T extends [infer H, ...infer R]
? [string, ...ToStrings<R>]
: [];
type A = ToStrings<[1, true, 3]>; // [string, string, string]संचायक प्रतिरूप
अक्सर आप परिणाम को एक अतिरिक्त पैरामीटर में बनाते हैं, जिसे संचायक कहा जाता है। यह खाली शुरू होता है और हर चरण में बढ़ता जाता है। इससे संरचना को बार-बार पढ़ने से बचते हैं और यह प्रकार-स्तरीय दोहरावों की मानक तकनीक है।
type Reverse<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer H, ...infer R]
? Reverse<R, [H, ...Acc]>
: Acc;
type A = Reverse<[1, 2, 3]>; // [3, 2, 1]संचायक को आगे बढ़ाना
Reverse<[1,2,3]> का क्रम देखिए:
- चरण 1: H=1, Acc [1] हो जाता है
- चरण 2: H=2, Acc [2,1] हो जाता है
- चरण 3: H=3, Acc [3,2,1] हो जाता है
- टपल खाली है, इसलिए Acc = [3,2,1] लौटता है
संचायक हर पुनरावर्ती कॉल में उत्तर को आगे ले जाता है।
type R = Reverse<["a", "b"]>; // ["b", "a"]संघों पर पुनरावृत्ति
आप स्ट्रिंगों के संघ को जोड़ने के लिए भी पुनरावृत्ति कर सकते हैं। यहाँ हम टपल के तत्वों को एक सीमांकक से अलग करके एक ही स्ट्रिंग शाब्दिक प्रकार में जोड़ते हैं।
संकेतन: वास्तविक TypeScript में टेम्पलेट शाब्दिक प्रकार बैकटिक से सीमांकित स्ट्रिंगों के रूप में लिखे जाते हैं, जिनमें डॉलर-ब्रेस रिक्त स्थान होते हैं। इन अंशों में हम उस प्रतिरूप को Tpl<...> के रूप में दिखाते हैं और हर भाग को क्रम से लिखते हैं; उदाहरण के लिए, शाब्दिक उपसर्ग और फिर Rest से मेल खाने वाला बैकटिक टेम्पलेट Tpl<'prefix', infer Rest> के रूप में दिखता है।
type Join<T extends string[], Sep extends string = ','> =
T extends [infer H extends string, ...infer R extends string[]]
? R extends []
? H
: Tpl<H, Sep, Join<R, Sep>>
: '';
// Tpl<H, Sep, ...> builds a template literal type joining the parts
type A = Join<['a', 'b', 'c']>; // 'a,b,c'पुनरावृत्ति के साथ गिनती
पुनरावृत्ति और संचायक मिलकर गिनती कर सकते हैं। प्रवेश मान जितनी लंबाई का है, उतनी ही लंबाई की unknown वाली एक टपल बनाइए, फिर बाद में उसकी length पढ़िए। अंकगणित वाले पाठ्यक्रम में आप इसका बहुत अधिक उपयोग करेंगे।
type Count<T extends unknown[], Acc extends unknown[] = []> =
T extends [unknown, ...infer R]
? Count<R, [unknown, ...Acc]>
: Acc["length"];
type A = Count<["x", "y", "z"]>; // 3पुनरावृत्ति के साथ छँटाई
टपल को पढ़िए और केवल उन तत्वों को रखिए जो किसी शर्त से मेल खाते हैं; बाकी को हटा दीजिए। किसी तत्व को संचायक में न जोड़कर उसे छोड़ दीजिए।
type KeepStrings<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer H, ...infer R]
? H extends string
? KeepStrings<R, [...Acc, H]>
: KeepStrings<R, Acc>
: Acc;
type A = KeepStrings<[1, "a", 2, "b"]>; // ["a", "b"]पुनरावृत्ति की गहराई की सीमाएँ
कंपाइलर पुनरावृत्ति की गहराई सीमित करता है (पहले यह सीमा लगभग 50 हुआ करती थी, जबकि कुछ प्रतिरूपों में अंतिम-पुनरावृत्ति अनुकूलन के कारण अब अधिक गहराई की अनुमति मिलती है)। बहुत बड़े टपल के लिए आपको प्रकार का इंस्टैंशिएशन अत्यधिक गहरा है जैसी समस्या आ सकती है। सीमा को और बढ़ाने के लिए संचायक वाली शैली, यानी अंतिम-पुनरावृत्ति शैली, का उपयोग कीजिए।
type Repeat<T, N extends number, Acc extends T[] = []> =
Acc["length"] extends N ? Acc : Repeat<T, N, [...Acc, T]>;
type A = Repeat<0, 3>; // [0, 0, 0]सबको एक साथ जोड़ना
अग्रभाग/शेषभाग में विभाजन, मूल स्थिति और संचायक लगभग हर प्रकार-स्तरीय दोहराव के तीन घटक हैं। इनकी सहायता से आप पूरी तरह प्रकार प्रणाली के भीतर टपल का मानचित्रण, छँटाई, उलटना, गिनती और जोड़ना कर सकते हैं।
type MapToPairs<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer H, ...infer R]
? MapToPairs<R, [...Acc, [H, H]]>
: Acc;
type A = MapToPairs<[1, 2]>; // [[1, 1], [2, 2]]त्वरित जाँच
संचायक प्रतिरूप की अपनी समझ का परीक्षण कीजिए।
पुनरावलोकन
अब आप प्रकार-स्तर पर दोहराव लिख सकते हैं।
- स्वयं का संदर्भ देने वाले सशर्त प्रकार पुनरावृत्ति बनाते हैं।
- टपल को
[H, ...R]में बाँटकर शेष भाग पर पुनरावृत्ति कीजिए। - मूल स्थिति (खाली टपल) दोहराव को रोकती है।
- संचायक परिणाम बनाता है और गहरी पुनरावृत्ति संभव करता है।
अगला विषय: संघों पर सशर्त प्रकारों का विशेष व्यवहार।
एआई शिक्षक के साथ TypeScript सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 101
- पाठ
- 352
अक्सर पूछे जाने वाले प्रश्न
क्या “प्रकार-स्तरीय पुनरावृत्ति” पाठ निःशुल्क है?
हाँ—“प्रकार-स्तरीय पुनरावृत्ति” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और TypeScript Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। TypeScript Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“प्रकार-स्तरीय पुनरावृत्ति” में मैं क्या सीखूँगा?
पुनरावर्ती सशर्त प्रकारों की सहायता से प्रकारों पर लूप चलाएँ। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ TypeScript Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या TypeScript Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर TypeScript Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“प्रकार-स्तरीय पुनरावृत्ति” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस TypeScript Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर TypeScript Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- गणना भाषा के रूप में प्रकार
- प्रकार-स्तरीय सशर्त
- प्रकार-स्तरीय पुनरावृत्ति
- वितरक सशर्त प्रकार