TypeScript Academy · पाठ

प्रकार-स्तरीय जोड़ और घटाव

टपल में हेरफेर करके अंकगणितीय संचालन बनाएँ।

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

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

लंबाई द्वारा अंकगणित

टपल-लंबाई के निरूपण के साथ, जोड़ संयोजन बन जाता है और घटाव पूर्वांश हटाना बन जाता है। आप टपल पर गणना करते हैं, फिर परिणामी लंबाई पढ़ते हैं।

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

जोड़

A + B जोड़ने के लिए: लंबाई A का टपल बनाइए, लंबाई B का दूसरा टपल बनाइए, दोनों को फैलाकर एक नए टपल में रखिए और उसकी लंबाई पढ़िए।

type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]["length"];

type S = Add<3, 4>; // 7

संयोजन से जोड़ क्यों होता है

लंबाई 3 वाले टपल के बाद लंबाई 4 वाला टपल रखने पर लंबाई 7 वाला टपल मिलता है। दो गिनती-पट्टियों के निशानों को जोड़ने पर संयुक्त गिनती मिलती है, इसलिए लंबाइयाँ जुड़ जाती हैं।

type A = Add<2, 2>; // 4
type B = Add<0, 5>; // 5
type C = Add<1, 6>; // 7

पूर्वांश द्वारा घटाव

A - B निकालने के लिए: लंबाई A का टपल बनाइए, फिर उसका अनुमान लगाइए कि वह लंबाई B वाले पूर्वांश के बाद एक शेषांश से बना है। rest की लंबाई A - B होती है।

type Sub<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
    ? Rest["length"]
    : never;

type D = Sub<7, 4>; // 3

क्रमिक घटाव

Sub<7, 4> के लिए: लंबाई 7 का टपल बनाइए, लंबाई 4 वाले पूर्वांश से मिलान कीजिए, Rest को पकड़िए (लंबाई 3), और उसकी लंबाई पढ़िए। हटाया गया पूर्वांश ठीक B निशानों का होता है।

type A = Sub<5, 2>; // 3
type B = Sub<4, 4>; // 0

अधोप्रवाह में कोई परिणाम नहीं

यहाँ प्रकार-स्तरीय संख्याएँ गैर-ऋणात्मक होती हैं। यदि B > A, तो कोई मान्य पूर्वांश मौजूद नहीं होता, पैटर्न विफल हो जाता है और परिणाम never होता है। यदि आप चाहें तो इसका डिफ़ॉल्ट मान 0 रख सकते हैं।

type A = Sub<2, 5>; // never

type SubSafe<A extends number, B extends number> =
  [Sub<A, B>] extends [never] ? 0 : Sub<A, B>;
type B = SubSafe<2, 5>; // 0

बढ़ाना और घटाना

एक से जोड़ने और घटाने के विशेष मामले इतने आम हैं कि उनके अलग नाम रखे जाते हैं। Inc एक तत्व जोड़ता है और Dec एक तत्व हटाता है।

type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];
type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

type A = Inc<4>; // 5
type B = Dec<4>; // 3

पुनरावृत्ति द्वारा गुणा

गुणा बार-बार किया गया जोड़ है। Dec से गिनती घटाते हुए और Add से संचय करते हुए, B को संचायक में A बार जोड़िए।

type Mul<A extends number, B extends number, Acc extends number = 0> =
  A extends 0 ? Acc : Mul<Dec<A>, B, Add<Acc, B>>;

type A = Mul<3, 4>; // 12

BuildTuple सहायक

यहाँ प्रत्येक संक्रिया BuildTuple पर निर्भर करती है। यह एकमात्र पुनः उपयोग योग्य मूलभूत साधन है: इसे एक संख्या दीजिए और उस लंबाई का टपल पाइए। इसे एक ही स्थान पर रखिए और बाकी सब इसके ऊपर बनाइए।

type Five = BuildTuple<5>; // [unknown, unknown, unknown, unknown, unknown]
type N = Five["length"];   // 5

संक्रियाओं का संयोजन

क्योंकि प्रत्येक संक्रिया संख्या लेती और लौटाती है, वे स्वतंत्र रूप से संयोजित हो सकती हैं। आप Add<Mul<2, 3>, 4> जैसे व्यंजक लिख सकते हैं और संकलक उनका मूल्यांकन कर देता है।

type Result = Add<Mul<2, 3>, 4>; // 10

व्यावहारिक सावधानी

ये युक्तियाँ छोटी गिनतियों के लिए बहुत अच्छी हैं: सारणी अनुक्रमिकाएँ, स्थिर आकार और सीमित परास। बड़ी संख्याओं या सामान्य गणित के लिए पुनरावर्तन सीमा और ऋणात्मक संख्याओं की कमी इन्हें अव्यावहारिक बना देती है। इनका उपयोग वहीं कीजिए जहाँ मान छोटे और स्थिर रहें।

type A = Add<8, 7>;  // 15 (fine)
// Add<5000, 5000> would exceed recursion limits

त्वरित जाँच

प्रकार-स्तरीय अंकगणित की अपनी समझ का परीक्षण कीजिए।

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

पुनरावलोकन

आपने प्रकार प्रणाली में अंकगणित लागू कर लिया है।

जोड़: टपल का संयोजन कीजिए और लंबाई पढ़िए।
घटाव: एक पूर्वांश का अनुमान लगाइए और शेषांश की लंबाई पढ़िए।
Inc/Dec एक-चरण वाले संस्करण हैं।
BuildTuple साझा मूलभूत साधन है।

अगला विषय: प्रकार-स्तर पर संख्याओं की तुलना।

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

एआई शिक्षक के साथ 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 पर वापस जाएँ