TypeScript Academy · पाठ

प्रकार-स्तरीय तुलना

संख्याओं की तुलना पूरी तरह प्रकार स्तर पर करें।

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

प्रकार-स्तरीय तुलना, CoddyKit पर TypeScript Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 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]>;

लिटरल की समानता

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

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

छोटा करते हुए अधिकता जाँचना

A > B के लिए दोनों के टपल बनाइए और हर चरण में दोनों से एक-एक तत्व हटाइए। यदि B पहले खाली हो जाए, जबकि A में अभी भी तत्व हों, तो A बड़ी है।

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

पैटर्न को कैसे पढ़ें

पैटर्न [...BuildTuple<B>, unknown, ...unknown[]] का अर्थ है: लंबाई B वाला पूर्वांश, फिर कम-से-कम एक और तत्व। यदि A इसमें फिट होता है, तो A में B से अधिक तत्व हैं, इसलिए A > B।

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

LessThan

LessThan केवल GreaterThan ही है, जिसमें तर्कों का क्रम उलट दिया गया है। दोबारा व्युत्पन्न करने के बजाय उसका पुनः उपयोग कीजिए।

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

बड़ी या बराबर

तुलना को समानता के साथ मिलाइए। A >= B तब सत्य होती है जब A > B या A == B हो।

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

पुनरावर्ती तुलना

एक विकल्प यह है कि दोनों को घटाते हुए तुलना की जाए, जब तक कि उनमें से एक शून्य तक न पहुँच जाए। इससे एक साथ आगे बढ़ने का विचार स्पष्ट रूप से दिखता है: जो पहले शून्य तक पहुँचता है, वही छोटा है।

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

घटाव-सहायक पर निर्भरता

पुनरावर्ती संस्करण को पिछले पाठ के Dec की आवश्यकता होती है। प्रत्येक चरण में दोनों ओर से एक निशान हटाया जाता है। जब दोनों शून्य हों, तो वे समान होते हैं; यदि केवल एक शून्य हो, तो दूसरा बड़ा होता है।

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

समानता बनाम असाइन-योग्यता

सावधान रहें: number extends number सत्य है, लेकिन यह लिटरल समानता नहीं है। यहाँ की तुलनाएँ 3 और 5 जैसे विशिष्ट लिटरल प्रकारों पर आधारित हैं, व्यापक number प्रकार पर नहीं।

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

क्रमबद्धता कुंजी बनाना

तुलना के साथ आप क्रम निर्धारण के नियम व्यक्त कर सकते हैं। उदाहरण के लिए, प्रकार-स्तर पर यह तय कीजिए कि दो संख्याओं वाला टपल आरोही क्रम में व्यवस्थित है या नहीं।

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

सीमित उपयोग करें

तुलनाओं में पुनरावर्तन का खर्च आता है। वे छोटी सीमित संख्याओं की सुरक्षा के लिए अच्छी हैं (अनुक्रमिकाएँ, स्थिर सीमाएँ), लेकिन सामान्य संख्यात्मक पुस्तकालय नहीं हैं। मान छोटे रखें और पूर्ण एक-साथ पुनरावर्तन की तुलना में पूर्वांश-पैटर्न को प्राथमिकता दें, क्योंकि वह कम गहराई वाला होता है।

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

त्वरित जाँच

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

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

पुनरावलोकन

अब आप प्रकार प्रणाली में संख्याओं का क्रम निर्धारित कर सकते हैं।

लिटरल की पारस्परिक असाइन-योग्यता द्वारा समानता।
GreaterThan द्वारा B-लंबाई वाला पूर्वांश और एक अतिरिक्त तत्व।
LessThan तर्कों का क्रम उलटता है; Gte समानता जोड़ता है।
यह छोटी लिटरल संख्याओं पर काम करता है, व्यापक number प्रकार पर नहीं।

अगला विषय: इन सबको व्यावहारिक उपयोगिताओं में बदलना।

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

एआई शिक्षक के साथ 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 पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

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

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