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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)).

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

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

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

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

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

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