संख्याएं और गणित

docs.scrimba.com

एक शॉपिंग कार्ट कीमतों को जोड़ता है, एक गेम स्कोर को ट्रैक करता है, एक फॉर्म गणना करता है कि कितना कर देना है। यह सब संख्याओं और उनके साथ अंकगणित करने तक आता है। JavaScript संख्याओं को अपने मूल बिल्डिंग ब्लॉक में से एक मानता है, और यह अध्याय इस बारे में है कि आप उनके साथ क्या कर सकते हैं: रोज़मर्रा की गणित, गोलाई और यादृच्छिकता के लिए बिल्ट-इन सहायक, और वह भाग जो लगभग सभी को परेशान करता है, पृष्ठ में टाइप किए गए पाठ को एक संख्या में बदलना जिसे आप जोड़ सकते हैं।

संख्याएं और अंकगणित

JavaScript के पास एक number टाइप है, और यह सब कुछ कवर करता है। 42 जैसी पूरी संख्याएं और 9.99 जैसे दशमलव दोनों एक ही तरह के मूल्य हैं, इसलिए आप कभी उनके बीच चुनाव नहीं करते:

const price = 9.99;
const quantity = 3;
const total = price * quantity;
console.log(total); // 29.97

आप उन प्रतीकों के साथ गणित करते हैं जिन्हें आप पहले से जानते हैं: + जोड़ता है, - घटाता है, * गुणा करता है, और / विभाजित करता है। एक और है जो कम परिचित है, %, शेषफल। यह आपको विभाजन के बाद बचा हुआ बताता है:

const remainder = 7 % 2;
console.log(remainder); // 1

सात को दो से भाग देने पर तीन और एक बचता है, इसलिए 7 % 2 1 है। यह चेक करने का तरीका है कि एक संख्या सम है या नहीं: एक सम संख्या को दो से भाग देने पर कुछ नहीं बचता है, इसलिए number % 2 सम संख्याओं के लिए 0 है और विषम संख्याओं के लिए 1 है।

JavaScript के पास पूरी संख्याओं और दशमलव दोनों के लिए एक एकल number टाइप है, इसलिए 42 और 9.99 एक ही तरह के मूल्य हैं। यह उन भाषाओं के विपरीत है जो पूर्णांक और फ्लोट को अलग-अलग टाइप में विभाजित करती हैं; यहाँ आप कभी घोषित नहीं करते कि आप कौन सा मतलब है।

पाँच अंकगणितीय ऑपरेटर हैं +, -, *, /, और %। शेषफल ऑपरेटर % विभाजन के बाद जो बचता है उसे लौटाता है, और यह अपनी मूल्य से अधिक प्रदर्शन करता है:

const total = 17;
const perRow = 5;
const leftOver = total % perRow;
console.log(leftOver); // 2

17 आइटमों को 5 प्रति पंक्ति में रखने से अंतिम पंक्ति में 2 बचते हैं, और 17 % 5 आपको बताता है। क्लासिक उपयोग सम या विषम का परीक्षण करना है: count % 2 सम संख्याओं के लिए 0 है और विषम संख्याओं के लिए 1 है, यह है कि आप पंक्ति के रंगों को कैसे वैकल्पिक करते हैं या एक सूची को आधे में कैसे विभाजित करते हैं।

ऑपरेटर सामान्य गणित की प्राथमिकता का पालन करते हैं, इसलिए *, /, और % + और - से अधिक जुड़ते हैं, और समान-प्राथमिकता वाले ऑपरेटर बाएं से दाएं पढ़ते हैं। जब क्रम महत्वपूर्ण हो तो कोष्ठक के लिए पहुंचें:

const withTax = (100 + 20) * 1.1;
console.log(withTax); // 132

JavaScript के पास एक number टाइप है, एक 64-बिट फ्लोटिंग-पॉइंट मूल्य (IEEE 754 डबल, समान प्रतिनिधित्व जो अधिकांश भाषाएं double कहती हैं)। इस स्तर पर कोई अलग पूर्णांक टाइप नहीं है, जिसका मतलब है कि 42, 9.99, और -3 सभी एक ही तरह की चीज हैं, और आप जो भी पूर्णांक लिखते हैं वह वास्तव में एक फ्लोट है जिसका कोई भिन्नात्मक भाग नहीं है।

पाँच ऑपरेटर हैं + - * / %। शेषफल % पिन करने लायक है, क्योंकि यह शेषफल है, मॉड्यूलो नहीं: यह बाएं ऑपरेंड का संकेत लेता है, इसलिए -7 % 3 1 नहीं बल्कि -2 है। रोज़मर्रा के मामले के लिए इसका मूल्य स्थिर और उपयोगी है। सम के लिए n % 2 === 0 का परीक्षण करना विहित ट्रिक है, और यह नकारात्मक के लिए भी रहता है क्योंकि -4 % 2 अभी भी 0 है।

const total = 128;
const pageSize = 25;
const onLastPage = total % pageSize;
console.log(onLastPage); // 3

प्राथमिकता मानक गणित का पालन करती है: *, /, और % + और - के ऊपर एक स्तर साझा करते हैं, और एक स्तर के भीतर मूल्यांकन बाएं से दाएं (बाएं सहायक) है। जब तुलना और तर्क प्रवेश करते हैं तो पूरा व्याकरण अधिक स्तरीय होता है, जो operators का विषय है। केवल अंकगणित के लिए आपको जो नियम चाहिए वह सरल है: गुणक योगात्मक से पहले, कुछ भी कोष्ठक में रखें जो एक पाठक को रोकना पड़े। स्पष्टता तीन वर्णों को बचाने को हरा देती है।

const average = (a + b + c) / 3;

Junoसंख्याएं और अंकगणित JavaScript में एक number टाइप है, इसलिए पूरी संख्याएं और दशमलव एक ही चीज हैं और आप कभी उनके बीच चुनाव नहीं करते। ऑपरेटर + - * / हैं और %, शेषफल, जो विभाजन के बाद बचा है। चतुर ट्रिक % 2 है: सम संख्याओं के लिए यह 0 है और विषम संख्याओं के लिए 1 है।

Junoसंख्याएं और अंकगणित एक number टाइप पूरी संख्याओं और दशमलव दोनों को कवर करता है, इसलिए int-बनाम-float का कोई निर्णय नहीं है। पाँच ऑपरेटर हैं + - * / और %, और % याद रखने लायक है: count % 2 आपको सम-या-विषम देता है, और यह बताता है कि आंशिक रूप से भरी पंक्ति में क्या बचा है। प्राथमिकता सामान्य गणित है, इसलिए कुछ भी कोष्ठक में रखें जो पाठक को सोचना पड़े।

Junoसंख्याएं और अंकगणित प्रत्येक संख्या एक 64-बिट फ्लोट है, इसलिए कोई अलग पूर्णांक टाइप नहीं है और 42 एक डबल है बिना अंश के। % में एक नुकसान यह है कि यह शेषफल है, मॉड्यूलो नहीं, इसलिए यह बाएं ओर का संकेत लेता है और -7 % 3 -2 है। सम-या-विषम परीक्षण के लिए जो कभी नहीं काटता है, क्योंकि n % 2 === 0 नकारात्मक के लिए भी रहता है।

Math ऑब्जेक्ट

जब आपको मूल ऑपरेटरों से अधिक की आवश्यकता होती है, तो JavaScript आपको Math देता है, एक बिल्ट-इन गणित सहायकों का संग्रह। आप उन्हें एक डॉट के साथ नाम से कॉल करते हैं:

console.log(Math.round(4.6)); // 5
console.log(Math.floor(4.6)); // 4
console.log(Math.ceil(4.1)); // 5

Math.round निकटतम पूरी संख्या को गोल करता है, Math.floor हमेशा नीचे की ओर गोल करता है, और Math.ceil हमेशा ऊपर की ओर गोल करता है। Math.max और Math.min भी हैं, जो आपको देने वाली संख्याओं में से सबसे बड़ी या सबसे छोटी चुनते हैं:

console.log(Math.max(3, 8, 5)); // 8
console.log(Math.min(3, 8, 5)); // 3

और Math.random, जो 0 से (लेकिन 1 के बिना) एक यादृच्छिक दशमलव देता है। अकेले यह शायद ही कभी वह होता है जो आप चाहते हैं, इसलिए सामान्य रेसिपी इसे गुणा करने और गोल करने के लिए एक यादृच्छिक पूरी संख्या प्राप्त करना है:

const roll = Math.floor(Math.random() * 6) + 1;
console.log(roll); // 4 (हर बार एक अलग संख्या)

Math.random() * 6 0 से 6 तक कहीं आता है, Math.floor इसे 0 से 5 तक की पूरी संख्या में गिराता है, और + 1 इसे 1 से 6 तक के पासे की रोल में बदल देता है।

Math एक बिल्ट-इन ऑब्जेक्ट है जिसमें गणित फंक्शन और स्थिरांक हैं। आप इसे नहीं बनाते; यह हमेशा वहाँ है, और आप इसके तरीकों को एक डॉट के साथ कॉल करते हैं।

गोल करने वाली तिकड़ी वह है जिसके लिए आप सबसे अधिक पहुंचते हैं:

console.log(Math.round(4.5)); // 5, निकटतम पूरी संख्या
console.log(Math.floor(4.9)); // 4, हमेशा नीचे
console.log(Math.ceil(4.1)); // 5, हमेशा ऊपर

Math.max और Math.min अपने तर्कों में से सबसे बड़ा और सबसे छोटा लौटाते हैं, जो मान को एक श्रेणी में रखने के लिए काम आता है:

const clamped = Math.min(Math.max(userValue, 0), 100);
console.log(clamped); // 0 और 100 के बीच रहता है

Math.random [0, 1) श्रेणी में एक फ्लोट लौटाता है, जिसका मतलब 0 संभव है लेकिन 1 कभी नहीं है। इसे 0 से n तक एक यादृच्छिक पूरी संख्या में बदलने के लिए, पैटर्न Math.floor(Math.random() * n) है:

const index = Math.floor(Math.random() * 5);
console.log(index); // 0 से 4 तक की पूरी संख्या

गुणा करने से श्रेणी को [0, n) तक फैलाया जाता है, और फ्लोर दशमलव को काट देता है इसलिए आप पूरी संख्या पर आते हैं। एक ऑफसेट जोड़ें जब आप एक श्रेणी चाहते हैं जो शून्य से शुरू नहीं होती, जैसे एक पासे की रोल के लिए + 1।

Math एक स्थिर नाम स्थान ऑब्जेक्ट है: गणित तरीकों और स्थिरांकों का एक सादा कंटेनर, कुछ नहीं जो आप तत्काल करते हैं। प्रत्येक तरीका Math.something() के रूप में कहा जाता है, और रनटाइम में बिल्कुल एक Math है।

गोल करने के तरीके प्रत्येक एक अलग लक्ष्य की ओर गोल करते हैं: Math.round निकटतम के लिए (टाई ऊपर जाते हैं, इसलिए Math.round(2.5) 3 है लेकिन Math.round(-2.5) -2 है), Math.floor नकारात्मक अनंत की ओर, Math.ceil सकारात्मक अनंत की ओर। यह फ्लोर-is-not-ट्रंकेशन अंतर नकारात्मक के लिए महत्वपूर्ण है, जहाँ Math.floor(-1.2) -2 है, नहीं -1।

console.log(Math.floor(-1.2)); // -2, floor नकारात्मक के लिए भी नीचे जाता है

Math.max और Math.min किसी भी संख्या के तर्कों को लेते हैं और क्लैम्पिंग का स्वच्छ तरीका हैं:

const clamped = Math.min(Math.max(value, min), max);

Math.random [0, 1) में एक समान रूप से वितरित फ्लोट लौटाता है। एक यादृच्छिक पूर्णांक के लिए मुहावरा Math.floor(Math.random() * range) + start है: श्रेणी की चौड़ाई के अनुसार स्केल करें, पूर्णांक के लिए फ्लोर करें, शुरुआत से स्थानांतरित करें। दो सावधानियां ले जाने लायक हैं: यह क्रिप्टोग्राफिक रूप से सुरक्षित नहीं है, इसलिए इसे कभी भी टोकन या कुछ के लिए उपयोग न करें जो एक उपयोगकर्ता अनुमान न लगा सके (crypto.getRandomValues इसके लिए मौजूद है), और off-by-one बग समावेशी और एक्सक्लूसिव सीमाओं को भ्रमित करने से आते हैं, इसलिए पहले से तय करें कि क्या आपका शीर्ष मूल्य प्राप्य है।

const dice = Math.floor(Math.random() * 6) + 1;
console.log(dice); // 1 से 6 समावेशी

JunoMath ऑब्जेक्टMath एक तैयार-निर्मित गणित सहायकों का टूलबॉक्स है जिसे आप एक डॉट के साथ कॉल करते हैं: Math.round, Math.floor (नीचे), Math.ceil (ऊपर), और Math.max / Math.min सबसे बड़े और सबसे छोटे के लिए। Math.random 0 से 1 तक एक दशमलव देता है, और याद रखने लायक रेसिपी Math.floor(Math.random() * n) एक यादृच्छिक पूरी संख्या के लिए है। मुझे उस पैटर्न पर विश्वास करने में कुछ कोशिशें लगीं, इसलिए इसे कॉपी करें और धीरे-धीरे पढ़ें।

JunoMath ऑब्जेक्टMath हमेशा वहाँ है, कोई सेटअप आवश्यक नहीं है, और आप इसके तरीकों को एक डॉट के साथ कॉल करते हैं। गोल करने वाली तिकड़ी को सीधा रखें: निकटतम के लिए round, नीचे के लिए floor, ऊपर के लिए ceil, और एक मान को एक श्रेणी में रखने के लिए min और max को एक साथ उपयोग करें। यादृच्छिकता के लिए, Math.floor(Math.random() * n) 0 से n तक एक पूरी संख्या देता है, और एक ऑफसेट श्रेणी को स्थानांतरित करता है।

JunoMath ऑब्जेक्टMath एक स्थिर नाम स्थान है, इसलिए इसका एक है और निर्माण के लिए कुछ नहीं है। नकारात्मक पर गोल करने के लक्ष्यों को देखें: Math.floor(-1.2) -2 है, ट्रंकेशन नहीं, और Math.round बराबरी को ऊपर की ओर तोड़ता है। Math.floor(Math.random() * range) + start पूर्णांक मुहावरा है, लेकिन Math.random सुरक्षित नहीं है, इसलिए कुछ के लिए crypto.getRandomValues उपयोग करें जो एक उपयोगकर्ता को अनुमान नहीं लगाना चाहिए।

स्ट्रिंग्स को संख्याओं में बदलना

कुछ भी एक व्यक्ति एक पृष्ठ में टाइप करता है टेक्स्ट के रूप में आता है, भले ही यह एक संख्या की तरह दिखे। एक बॉक्स में 5 टाइप करें और आपको संख्या 5 नहीं, स्ट्रिंग "5" मिलता है। यह महत्वपूर्ण है क्योंकि दो स्ट्रिंग्स पर + उन्हें जोड़ता है न कि जोड़ता है:

const a = "5";
const b = "3";
console.log(a + b); // "53", 8 नहीं

गणित करने के लिए, आप पहले पाठ को संख्या में बदलते हैं। सबसे स्पष्ट तरीका Number() है:

const count = Number("5");
console.log(count + 3); // 8

दो और हैं जो आप देखेंगे: parseInt एक पूरी संख्या पढ़ता है और किसी भी दशमलव को गिराता है, और parseFloat दशमलव रखता है:

console.log(parseInt("42px")); // 42
console.log(parseFloat("9.99")); // 9.99

ये दोनों कुछ पाठ की शुरुआत में बैठी एक संख्या को पढ़ सकते हैं, जैसे "42px", जो Number नहीं कर सकता। एक शॉर्टकट भी है, एक स्ट्रिंग के सामने +, जो इसे Number के समान तरीके से बदलता है:

console.log(+"7"); // 7

एक पृष्ठ से इनपुट हमेशा एक string है। एक फॉर्म फील्ड, एक URL, एक डेटा एट्रिब्यूट: सब कुछ पाठ, भले ही "5" हो। चूंकि + स्ट्रिंग्स को जोड़ता है, दो पाठ मान जोड़ने से उन्हें जोड़ने के बजाय जोड़ा जाता है, जो शुरुआत करने वालों के लिए सबसे सामान्य संख्या बग है:

const price = "10";
const shipping = "5";
console.log(price + shipping); // "105", स्ट्रिंग संयोजन

गणना करने से पहले बदलें। Number() कठोर, पठनीय विकल्प है: यह एक स्वच्छ संख्यात्मक स्ट्रिंग को संख्या में बदल देता है और पूरी तरह से संख्यात्मक न होने वाली किसी भी चीज़ के लिए NaN देता है।

console.log(Number("42")); // 42
console.log(Number("42px")); // NaN, पूरी तरह से संख्यात्मक नहीं

parseInt और parseFloat अधिक क्षमाशील हैं। वे स्ट्रिंग के सामने से एक संख्या पढ़ते हैं और पहले वर्ण पर रुकते हैं जो फिट नहीं है, यही कारण है कि parseInt("42px") 42 है। parseInt किसी भी आंशिक भाग को त्यागता है; parseFloat इसे रखता है:

console.log(parseInt("42px", 10)); // 42
console.log(parseFloat("3.14 radians")); // 3.14

parseInt को दूसरे तर्क के रूप में 10 पास करें ताकि यह हमेशा दस आधार पढ़े। यूनरी + एक संक्षिप्त कनवर्टर है जो Number की तरह व्यवहार करता है: पूरे मान के लिए Number() उपयोग करें, पाठ में एम्बेड की गई संख्याओं के लिए parseInt/parseFloat।

बाहरी दुनिया से पाठ हमेशा एक string है, और चूंकि + संयोजन के लिए अतिभारित है, "10" + "5" "105" है। + को छोड़कर हर अंकगणितीय ऑपरेटर अपने ऑपरेंड को संख्याओं में कोष करता है, इसलिए "10" * 1 10 है, लेकिन उस पर झुकना एक पठनीयता जाल है। जानबूझकर कनवर्ट करें।

Number() पूरी-स्ट्रिंग कोर्सन है: यह केवल तभी सफल होता है जब पूरी ट्रिम की गई स्ट्रिंग एक वैध संख्यात्मक शाब्दिक हो, अन्यथा NaN। यह हेक्स (Number("0x1f") 31 है), एक्सपोनेंट्स, और अग्रणी या अनुगामी व्हाइटस्पेस को समझता है, और यह "" को 0 के रूप में मानता है, जो जानने लायक एक तीव्र किनारा है।

console.log(Number("")); // 0, एक तीव्र वह
console.log(Number("  12 ")); // 12, व्हाइटस्पेस ट्रिम किया गया
console.log(Number("12abc")); // NaN

parseInt और parseFloat एक उपसर्ग को पार्स करते हैं: वे जितना दूर कर सकते हैं उतना पढ़ते हैं और बाकी को अनदेखा करते हैं, इसलिए parseInt("12abc") 12 है। हमेशा parseInt को इसका रेडिक्स (parseInt(str, 10)) दें; इसके बिना, "0x10" जैसा इनपुट हेक्स के रूप में पढ़ा जाता है। यूनरी + Number कोर्सन का सबसे छोटा रूप है और तर्स कोड में अक्सर दिखाई देता है (+"3.5" 3.5 है), समान नियमों के साथ और समान "" 0 में बदल जाता है आश्चर्य।

व्यावहारिक नियम: Number (या +) जब पूरा मान संख्यात्मक होना चाहिए और कुछ और एक त्रुटि है जो आप पकड़ना चाहते हैं, parseInt/parseFloat जब एक संख्या पाठ में एम्बेड की गई हो जिसकी आप अपेक्षा करते हैं। जो भी आप चुनते हैं, परिणाम NaN हो सकता है, जो अगला भाग है। इस से परे तुलना और कोर्सन operators में रहते हैं, और स्ट्रिंग पक्ष की कहानी strings में है।

Junoस्ट्रिंग्स को संख्याओं में बदलना कुछ भी एक पृष्ठ में टाइप किया गया पाठ है, इसलिए "5" संख्या 5 नहीं है, और "5" + "3" 8 के बजाय "53" देता है। पहले कनवर्ट करें: Number("5") सबसे स्पष्ट है, parseInt एक पूरी संख्या पढ़ता है, parseFloat दशमलव रखता है, और एक स्ट्रिंग के सामने + एक त्वरित शॉर्टकट है। जोड़ने के बजाय जोड़ने का जाल देखें, यह सभी को एक बार पकड़ता है।

Junoस्ट्रिंग्स को संख्याओं में बदलना पृष्ठ इनपुट हमेशा एक string है, और चूंकि + स्ट्रिंग्स को जोड़ता है, "10" + "5" "105" है, सबसे सामान्य संख्या बग। Number() उपयोग करें जब पूरा मान संख्यात्मक होना चाहिए, और parseInt या parseFloat जब एक संख्या "42px" जैसे पाठ के अंदर बैठी हो। parseInt को अपना base-ten तर्क दें और यह आपको आश्चर्यचकित नहीं करेगा।

Junoस्ट्रिंग्स को संख्याओं में बदलना+ को छोड़कर हर ऑपरेटर संख्या में कोर्स करता है, इसलिए "10" * 1 काम करता है, लेकिन इसके बजाय जानबूझकर कनवर्ट करें। Number() माँग करता है कि पूरी स्ट्रिंग संख्यात्मक हो और शांति से "" को 0 में बदल देता है, जबकि parseInt और parseFloat एक उपसर्ग को पार्स करते हैं और बाकी को अनदेखा करते हैं, इसलिए हमेशा parseInt को 10 का एक रेडिक्स पास करें। उनमें से कोई भी आपको NaN दे सकता है, जो अगली चीज़ है जिसे सहज होना है।

संख्याओं के तीव्र किनारे

JavaScript में संख्याएं एक आश्चर्य रखती हैं जो एक बार देखने लायक है। दो सरल दशमलव जोड़ें और आप एक अजीब उत्तर पा सकते हैं:

console.log(0.1 + 0.2); // 0.30000000000000004

यह आपके कोड में बग नहीं है। कंप्यूटर दशमलव को इस तरह संग्रहीत करते हैं कि हर मान को बिल्कुल प्रतिनिधित्व नहीं कर सकते, इसलिए एक छोटी सी त्रुटि आ जाती है। यह शायद ही कभी महत्वपूर्ण है, और जब यह करता है, तो आप प्रदर्शन के लिए परिणाम को गोल करते हैं:

const sum = 0.1 + 0.2;
console.log(Math.round(sum * 100) / 100); // 0.3

आप एक मान भी पूरा करेंगे जिसे NaN कहा जाता है, जिसका अर्थ है "संख्या नहीं"। आप इसे प्राप्त करते हैं जब एक गणित संचालन का कोई समझदारी से उत्तर नहीं होता, जैसे बेतुका पाठ को एक संख्या में बदलने की कोशिश करना:

console.log(Number("hello")); // NaN

आपके आउटपुट में NaN देखना आमतौर पर मतलब है कि एक कनवर्सन कहीं गलत हो गया, इसलिए यह भय के लिए कुछ के बजाय एक उपयोगी सुराग है।

दो संख्या मान आपको अंततः आश्चर्यचकित करेंगे, और इसे उद्देश्य से पूरा करना बेहतर है।

पहला है फ्लोटिंग-पॉइंट अनुचितता। चूंकि दशमलव बाइनरी में संग्रहीत हैं, कुछ मान बिल्कुल से नहीं रखे जा सकते, इसलिए 0.1 + 0.2 बिल्कुल 0.3 नहीं है:

console.log(0.1 + 0.2 === 0.3); // false

व्यावहारिक फिक्स प्रदर्शन के लिए गोल करना है, या पूरी इकाइयों में काम करना है। पैसा क्लासिक मामला है: पूर्णांक सेंट (1099 के बजाय 10.99) में राशि रखें और केवल तभी विभाजित करें जब आप उन्हें दिखाएं, जो त्रुटि को पूरी तरह से रोकता है।

const cents = 1099;
console.log(cents / 100); // 10.99, प्रदर्शन के लिए सटीक

दूसरा है NaN, "संख्या नहीं", एक संचालन का परिणाम जिसका कोई संख्यात्मक उत्तर नहीं है जैसे Number("hello") या 0 / 0। इसका सबसे विचित्र गुण यह है कि यह अपने आप के बराबर नहीं है:

console.log(NaN === NaN); // false

तो आप इसे === के साथ परीक्षण नहीं कर सकते। Number.isNaN(value) उपयोग करें, जो केवल NaN के लिए true लौटाता है:

console.log(Number.isNaN(Number("hello"))); // true

Infinity भी है, जो आप शून्य से विभाजित करने (1 / 0) या संख्या श्रेणी से अतिप्रवाहित करने से प्राप्त करते हैं। यह तुलना में एक वास्तविक मान की तरह व्यवहार करता है लेकिन संकेत देता है कि एक गणना किनारे से भाग गई है।

तीन मान संख्या टाइप के किनारों पर बैठते हैं, और एक पेशेवर को तीनों को सजगता में चाहिए।

फ्लोटिंग-पॉइंट अनुचितता प्रसिद्ध है। IEEE 754 बाइनरी में संख्याओं को संग्रहीत करता है, और 0.1 जैसे मान के पास कोई सटीक बाइनरी प्रतिनिधित्व नहीं है, इसलिए अंकगणित गोलाई त्रुटि जमा करता है:

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false

कभी भी फ्लोट की तुलना === के साथ न करें जब कोई भी पक्ष अंकगणित से आया हो। दो फिक्स उत्पादन में पकड़ते हैं: प्रदर्शन और तुलना के लिए एक निश्चित सटीकता के लिए गोल करें, या, कुछ भी जहाँ सटीकता एक आवश्यकता है जैसे मुद्रा, सबसे छोटी पूर्णांक इकाई में काम करें और केवल सीमा पर कनवर्ट करें। पूर्णांक सेंट (1099) में पैसे को संग्रहीत करना और आउटपुट पर प्रारूपित करना बग के वर्ग को हटाता है के बजाय इसका एक उदाहरण पैच करने के लिए।

const totalCents = 1099 + 250;
console.log(totalCents); // 1349, सटीक पूर्णांक अंकगणित

NaN संख्या टाइप की त्रुटि मान है, 0 / 0, Number("x"), और एक अपरिभाषित संख्यात्मक परिणाम वाले किसी भी संचालन द्वारा निर्मित। इसमें स्पेक द्वारा अनिवार्य एक अद्वितीय संपत्ति है: यह एकमात्र मान है जो अपने आप के बराबर नहीं है, इसलिए NaN === NaN false है। यही कारण है कि पहचान की जाँच इस पर विफल हो जाती है और क्यों Number.isNaN(x) विश्वसनीय परीक्षण के रूप में मौजूद है। पुरानी वैश्विक isNaN पर Number.isNaN फॉर्म को प्राथमिकता दें, जो पहले अपने तर्क को कोर्स करता है और इसलिए "hello" जैसी चीजों के लिए true रिपोर्ट करता है जो वास्तव में NaN नहीं हैं।

console.log(NaN === NaN); // false, NaN कभी अपने आप के बराबर नहीं है
console.log(Number.isNaN(0 / 0)); // true, विश्वसनीय परीक्षण

Infinity (और -Infinity) वह है जो आप 1 / 0 से या प्रतिनिधित्व योग्य श्रेणी से अतिप्रवाहित करने से प्राप्त करते हैं। यह एक वास्तविक, तुलनीय मान है (Infinity > 1e308 true है), जो इसे "अभी कोई सीमा नहीं" के लिए एक सुविधाजनक प्रहरीदूत बनाता है जब एक न्यूनतम खोजता है, लेकिन एक आश्चर्य अगर यह एक प्रदर्शन या डेटाबेस तक पहुँचता है। जब एक परिणाम अतिप्रवाहित हो सकता है या शून्य से विभाजित हो सकता है, Infinity से आगे लीक करने से पहले एक समझदारी पूर्ण फॉलबैक तय करें।

Junoसंख्याओं के तीव्र किनारे दशमलव को थोड़ा ढीले से संग्रहीत किया जाता है, इसलिए 0.1 + 0.2 0.30000000000000004 के रूप में आता है, जो सामान्य है, आपके कोड में बग नहीं है। जब यह महत्वपूर्ण हो तो इसे दिखाने से पहले परिणाम को गोल करें। और NaN का अर्थ है "संख्या नहीं", उत्तर जो आप प्राप्त करते हैं जब कनवर्सन विफल हो जाता है, इसलिए इसे एक सुराग मानें कि कुछ पाठ आपकी अपेक्षा के अनुसार संख्या में नहीं बदला।

Junoसंख्याओं के तीव्र किनारे फ्लोटिंग-पॉइंट का अर्थ है 0.1 + 0.2 बिल्कुल 0.3 नहीं है, इसलिए प्रदर्शन के लिए गोल करें या पूर्णांक सेंट जैसी पूरी इकाइयों में काम करें। NaN "कोई संख्यात्मक उत्तर" मान है, और इसका जाल यह है कि NaN === NaN false है, इसलिए Number.isNaN के बजाय परीक्षा करें। Infinity शून्य से विभाजित करने से दिखाई देता है और मतलब है एक गणना किनारे से चली गई।

Junoसंख्याओं के तीव्र किनारे अंकगणित फ्लोट को कभी भी === के साथ तुलना न करें; एक सटीकता के लिए गोल करें या पूर्णांक सेंट में पैसा रखें ताकि त्रुटि वर्ग गायब हो जाए। NaN एकमात्र मान है जो अपने आप के बराबर नहीं है, जो बिल्कुल है कि Number.isNaN क्यों मौजूद है, और कोर्स करने वाली वैश्विक isNaN पर इसे पहुँचें। Infinity divide-by-zero या अतिप्रवाहित करने से एक वास्तविक तुलनीय मान है, इसलिए इसे एक प्रदर्शन या डेटाबेस तक पहुँचने से पहले एक समझदारी पूर्ण फॉलबैक दें।

संख्याएं अगले कहां जाती हैं

संख्याएं JavaScript में कुछ मुख्य data types में से एक हैं, पाठ और true/false मानों के साथ बैठती हैं। अधिकांश वास्तविक प्रोग्राम उन्हें मिश्रित करते हैं, एक स्ट्रिंग से एक संख्या निकालते हैं, इसकी तुलना करते हैं, variable में परिणाम संग्रहीत करते हैं, और ऑपरेटर जो उस तुलना और संयोजन को करते हैं वह अगले operators का विषय है।