Dan Levy

क्विज़: क्या आप जावास्क्रिप्ट पर भरोसा कर सकते हैं?

क्या आप parseInt और parseFloat में अंतर जानते हैं?

मेरी JavaScript Numbers चुनौती में आपका स्वागत है!

यह क्विज़ JS की संख्याओं के साथ-साथ parseInt, parseFloat और BigInt का आपका ज्ञान परखेगा।

हम अलग-अलग आधारों में संख्यात्मक अभिव्यक्तियाँ पार्स करना, फ़्लोटिंग-पॉइंट सटीकता संभालना और JavaScript की संख्या प्रणाली की विचित्रताएँ समझना देखेंगे।

बस संख्याएँ ही तो हैं, कितना मुश्किल हो सकता है? 🤓

1. 

वार्म‑अप

parseInt(" 123456.00")

parseInt फ़ंक्शन स्पेसेज़ को नजरअंदाज़ करता है और प्रारंभिक अंकों की श्रृंखला को पूर्णांक के रूप में पार्स करता है। यहाँ यह दशमलव बिंदु पर रुक जाता है, इसलिए केवल 123456 लौटाया जाता है।

2. 

पार्सिंग

parseInt("123,456.00")

आम तौर पर, parseInt गैर‑संख्यात्मक अक्षर मिलने पर पार्सिंग रोक देता है। यहाँ यह कॉमा पर रुकता है, इसलिए केवल 123 ही लौटाया जाता है।

3. 

गणित

0.1 + 0.2 === 0.3

फ़्लोटिंग‑पॉइंट सटीकता त्रुटियों के कारण, 0.1 + 0.2 बिल्कुल 0.3 के बराबर नहीं होता। फ़्लोटिंग‑पॉइंट संख्याएँ मेमोरी में जिस तरह संग्रहीत होती हैं, उसके कारण परिणाम 0.30000000000000004 आता है। फ़्लोटिंग‑पॉइंट अंकगणित को संभालने वाला IEEE 754 मानक ही कारण है, यह कुछ संख्याओं को ठीक‑ठीक दर्शा नहीं सकता। यह सभी प्रोग्रामिंग भाषाओं में आम समस्या है। अंत में आप अनंत दोहराव वाले दशमलव से मिलेंगे, और चाहे भाषा कोई भी हो—कंप्यूटर को अनंत अंकों का पीछा बंद करना पड़ता है।

Python और Java जैसी कुछ भाषाओं में Decimal या BigDecimal होते हैं जो इसे संभालते हैं, लेकिन JavaScript में ऐसा अंतर्निहित नहीं है। आप big.js या decimal.js जैसी लाइब्रेरीज़ का उपयोग करके इन मामलों को हल कर सकते हैं।

(ध्यान दें: कुछ भाषाएँ अंश, काल्पनिक संख्याएँ आदि को उच्च स्तर पर संभालने के लिए डिज़ाइन की गई हैं, जिससे लिटरल अभिव्यक्तियों को संरक्षित रखा जाता है। लेकिन उन्हें भी हार्डवेयर स्तर पर वही फ़्लोटिंग‑पॉइंट सटीकता समस्याओं का सामना करना पड़ता है।)

4. 

ओवरफ़्लो होने वाली संख्याएँ

Number.MAX_VALUE * 2

चूँकि Number.MAX_VALUE जावास्क्रिप्ट में सबसे बड़ी प्रतिनिधित्व योग्य सामान्य संख्या है, इसकी सीमा से ऊपर जाने पर जल्दी ही ओवरफ़्लो हो जाता है – मूलतः आप बेकार परिणाम देख सकते हैं। इसे 2 से गुणा करने पर Infinity मिलता है.

याद रखो, जावास्क्रिप्ट कभी‑कभी ऐसा ही होता है.

5. 

फ़ॉर्मेटिंग

यह क्या कर सकता है?

5..toFixed(2)

.toFixed(2) दो दशमलव स्थानों के साथ 5 का स्ट्रिंग प्रतिनिधित्व लौटाता है, इसलिए परिणाम "5.00" है।

डबल डॉट (5..toFixed(2)) एक ‘ट्रिक’ है जिससे Number Literals का ऑब्जेक्ट मॉडल एक्सेस किया जाता है।

6. 

प्रकारों की तुलना

parseInt("42") === parseFloat("42")

JavaScript में, parseInt और parseFloat दोनों स्ट्रिंग "42" को संख्या 42 के रूप में व्याख्या करेंगे। इसलिए तुलना parseInt("42") === parseFloat("42") true देता है। जबकि parseInt पहला गैर-अंकीय अक्षर मिलने पर पार्सिंग रोक देता है, parseFloat तब तक जारी रखता है जब तक वह फ्लोटिंग‑पॉइंट संख्या का हिस्सा न हो। लेकिन चूँकि "42" में कोई दशमलव बिंदु या अन्य गैर‑संख्यात्मक अक्षर नहीं है, दोनों फ़ंक्शन समान मान लौटाते हैं।

7. 

समानता

BigInt("42") === parseInt("42")

BigInt एक अलग प्रकार है number से, इसलिए parseInt("42") (एक सामान्य संख्या) BigInt("42") के बराबर सख्ती से नहीं है। तुलना करने के लिए, दोनों को एक ही प्रकार में बदलें: BigInt(parseInt("42")) === BigInt("42").

8. 

आधारित

यह क्या परिणाम देगा?

parseInt("0x2A") === parseInt("2a", 16)

कोई भी इनपुट स्ट्रिंग जो 0x से शुरू होती है, स्वचालित रूप से हेक्साडेसिमल (radix 16) माना जाता है। इसलिए यह radix 16 पास करने के बराबर है। तो, parseInt("0x2A") वही है जैसा parseInt("2a", 16)। (यह केस-इन्सेंसिटिव है।)

9. 

आधारित

यहाँ क्या मामला है?

parseInt('0xFF', 16)

parseInt एक हेक्साडेसिमल (16) बेस के साथ "FF" को दशमलव में 255 में बदलता है। आप इसे CSS RGB/Hex रंग कोड में देख सकते हैं।

10. 

Number[]

[24, 'One', 42].map(parseInt)

parseInt का दूसरा तर्क (radix) एरे मेथड के index तर्क के साथ मेल खाता है। इससे अप्रत्याशित परिणाम मिलते हैं, क्योंकि parseInt("One", 1) अवैध इनपुट के कारण NaN लौटाता है.

पहला तत्व, 24, बेस 0 (ऑटो‑डिटेक्ट) में 24 के रूप में पार्स होता है, इसलिए यह 24 ही रहता है। दूसरा तत्व, 'One', बेस 1 में NaN के रूप में पार्स होता है। तीसरा तत्व, 42, बेस 2 में पार्स होता है। बेस 2 में '42' NaN है, इसलिए परिणाम [24, NaN, NaN] मिलता है.

यह parseInt और map के साथ एक सामान्य गड़बड़ी है। यदि आप स्ट्रिंग्स की एरे को नंबर में बदलना चाहते हैं, तो एकमात्र सुरक्षित “बिल्ट‑इन” तरीका .map(Number) है या कॉलबैक/एनक्लोज़र जोड़ें जैसे .map(x => parseInt(x, 10)).

11. 

Number[]

[24, 'Twenty1', 0o42].map(Number)

Number मानों को एक संख्यात्मक प्रकार में parseInt से अधिक कड़ाई से बदलता है। यहाँ, 'Twenty1' NaN बन जाता है, जबकि 0o42 को ऑक्टल लिटरल के रूप में पहचाना जाता है और 34 में बदला जाता है।

12. 

पार्सिंग

इस कोड का परिणाम क्या होगा?

console.log(parseInt(null), Number(null))

parseInt इनपुट को स्ट्रिंग में बदल देता है, इसलिए null “null” बन जाता है। चूँकि “null” में कोई वैध बेस‑10 अंक नहीं होते, यह NaN लौटाता है.

Number(null) 0 लौटाता है। क्योंकि JS आपको चकित रखता है. क्यों? अगर रुचि हो तो मैं और गहराई में जा सकता हूँ.

13. 

पार्सिंग

इस जादू का परिणाम क्या होगा?

parseInt(null, 36)

parseInt हमेशा इनपुट को स्ट्रिंग में बदल देता है, इसलिए null स्ट्रिंग "null" बन जाता है।

बेस 36 (hexatrigesimal, अगर आप गिन रहे हैं) में स्ट्रिंग "null" का मान 1112745 है।

nulk, null, और nulm के क्रमिक मान क्रमशः बेस 36 में 1112744, 1112745, और 1112746 हैं।

तुलना तालिका

फ़ंक्शनparseIntparseFloatNumberBigInt
खाली जगह को अनदेखा करता है✅✅✅✅
.map(FN)❌☑️✅✅
रेडिक्स आर्ग का समर्थन✅❌❌❌
स्ट्रिंग में बाइनरी/ऑक्टल/हेक्स उपसर्गकेवल हेक्स 0x; 0b/0o अपने आप नहीं पहचाने जाते❌✅✅
अवैध अक्षर 42 oh no4242NaNSyntaxError

आपका परिणाम क्या रहा? 🧐

इतने बाइनरी के बाद थोड़ा आराम चाहिए?
पफ़्ट, याद रखें: कौशल के बाद ब्रेक!

और चुनौतियों को तोड़ने के लिए मेरी जिम पर जाएँ! 💪

Loading comments...