संख्याएँ में

संख्याएँ के बारे में

JavaScript में संख्याओं के दो अलग-अलग प्रकार होते हैं: संख्याएँ और "bigint"।

संख्याएँ सबसे ज़्यादा इस्तेमाल होती हैं और डबल-प्रेसिजन 64-बिट फ्लोटिंग-पॉइंट फॉर्मैट में संख्यात्मक डेटा टाइप को दर्शाती हैं।

• number: डबल-प्रेसिजन 64-बिट फ्लोटिंग-पॉइंट फॉर्मैट (IEEE 754) में एक संख्यात्मक डेटा टाइप। उदाहरण हैं -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 और 500000.
• bigint: एक संख्यात्मक डेटा टाइप जो पूर्णांकों को आर्बिट्ररी प्रेसिजन फॉर्मैट में दर्शा सकता है। उदाहरण हैं -12n, 0n, 4n, और 9007199254740991n.

let numericValue = 42;
// => 42

JavaScript कोड में 42 जैसा संख्या लिटरल एक फ्लोटिंग-पॉइंट वैल्यू होता है, पूर्णांक नहीं। आम रोज़मर्रा के इस्तेमाल के लिए कोई अलग पूर्णांक टाइप नहीं होता। bigint टाइप को रोज़मर्रा के इस्तेमाल में number टाइप की जगह लेने के लिए नहीं बनाया गया है। 42 अब भी एक Number ही है, BigInt नहीं।

संख्याएँ 0b101, 0o13, 0x0A जैसे लिटरल रूपों में भी लिखी जा सकती हैं। संख्यात्मक लेक्सिकल ग्रामर के बारे में यहाँ और जानिए।

विशेष संकेतन

एक्सपोनेंशियल संकेतन

E-संकेतन ऐसी संख्या दर्शाता है जिसे 10 की किसी दी गई घात से गुणा करना होता है। E-संकेतन का रूप यह होता है कि पहले एक संख्या, उसके बाद e या E, और फिर 10 की वह घात जिससे गुणा करना है।

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

E-संकेतन का इस्तेमाल बहुत छोटी संख्याएँ दर्शाने के लिए भी किया जा सकता है:

const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

अंडरस्कोर संकेतन

बड़ी संख्याओं को पढ़ने में आसान बनाने के लिए अंडरस्कोर का इस्तेमाल किया जा सकता है। कंपाइलर इन अंडरस्कोर पर बिल्कुल ध्यान नहीं देता।

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

बिल्ट-इन ऑब्जेक्ट

संख्याओं से काम करते समय दो बिल्ट-इन ऑब्जेक्ट काम आते हैं:

• Number: आम और काम की वैल्यू के लिए स्टैटिक प्रॉपर्टी, टाइप जाँच और टाइप रूपांतरण के लिए स्टैटिक मेथड, तथा टाइप रूपांतरण और संख्याओं को स्ट्रिंग के रूप में फॉर्मैट करने के लिए इंस्टेंस मेथड।
• Math: गणितीय स्थिरांकों और फंक्शनों के लिए प्रॉपर्टी और मेथड। यह BigInt के साथ काम नहीं करता।

Math में संख्याओं को राउंड करने के मेथड भी होते हैं। उपलब्ध राउंडिंग विकल्पों के बारे में आप राउंडिंग पर इस javascript.info लेख में और पढ़ सकते हैं।

Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235

बिल्ट-इन ग्लोबल object Number भी एक ग्लोबल function है, जिसका इस्तेमाल संख्या जैसी लगभग किसी भी चीज़ को number में बदलने के लिए किया जा सकता है। किसी string को number में पार्स करने की तुलना में यह कम छूट देता है।

const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);

unix;
// => 819199440000

JavaScript में संख्याओं के लिए अधिकतम (और न्यूनतम / अधिकतम ऋणात्मक) वैल्यू के तीन प्रकार होते हैं:

• VALUE: Number.MAX_VALUE और Number.MIN_VALUE से मिलती है
• INFINITY: Number.POSITIVE_INFINITY और Number.NEGATIVE_INFINITY से मिलती है
• SAFE_INTEGER: Number.MAX_SAFE_INTEGER और Number.MIN_SAFE_INTEGER से मिलती है

JavaScript में संख्याएँ जिस तरह लागू की गई हैं, उसकी वजह से Number.MIN_VALUE और Number.MAX_VALUE के बीच की हर संख्या को दर्शाया नहीं जा सकता। लेकिन Number.MIN_SAFE_INTEGER - 1 और Number.MAX_SAFE_INTEGER + 1 के बीच की हर संख्या को दर्शाया जा सकता है।

संख्याओं की विशेष वैल्यू

JavaScript में संख्याओं की कई विशेष वैल्यू होती हैं:

• दो एरर वैल्यू, NaN और Infinity.
• शून्य की दो वैल्यू, +0 और -0.

NaN - कोई संख्या नहीं

एरर वैल्यू NaN (यानी "कोई संख्या नहीं") इन स्थितियों में बनती है।

• किसी संख्या को पार्स नहीं किया जा सका:

  Number('123'); // => 123
  Number('Hello, World!'); // => NaN
  

• कोई ऑपरेशन असफल रहा:

  Math.sqrt(-64); // => NaN
  

• कोई एक ऑपरेंड NaN है:

  NaN + 69; // => NaN
  

NaN ही अकेली ऐसी वैल्यू है जो खुद के बराबर नहीं होती:

NaN === NaN; // => false

अगर आप जाँचना चाहते हैं कि कोई वैल्यू NaN है या नहीं, तो आपको ग्लोबल फंक्शन isNaN() का इस्तेमाल करना होगा:

isNaN(NaN); // => true
isNaN(123); // => false

Infinity

Infinity एक एरर वैल्यू है जो दो समस्याओं में से एक की ओर इशारा करती है:

• किसी संख्या को दर्शाया नहीं जा सकता, क्योंकि उसका परिमाण बहुत बड़ा है।

  Math.pow(2, 1024); // => Infinity
  

• शून्य से भाग हुआ है।

  6 / 0; // => Infinity
  -6 / 0; // => -Infinity
  

Infinity किसी भी अन्य संख्या से बड़ी है (NaN को छोड़कर)। इसी तरह, -Infinity किसी भी अन्य संख्या से छोटी है (NaN को छोड़कर)

ग्लोबल फंक्शन isFinite() से आप जाँच सकते हैं कि कोई वैल्यू वास्तविक संख्या है या नहीं (न अनंत, न NaN):

isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false

दो शून्य

JavaScript में +0 और -0 अलग-अलग संख्याएँ हैं। ये तब बन सकती हैं जब आप ऐसी संख्या दर्शाते हैं जो इतनी छोटी हो कि 0 से अलग पहचानी ही न जा सके। चिह्नित शून्य से आप दर्ज कर सकते हैं कि आप शून्य की ओर “किस दिशा से” पहुँचे थे, यानी शून्य माने जाने से पहले उस संख्या का चिह्न क्या था। बेहतर यही है कि आप मान लें कि शून्य सिर्फ एक ही है।

तुलना

अगर दो संख्याओं की वैल्यू एक ही हो, तो वे बराबर मानी जाती हैं।

1 == 1.0;
// => true

1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.

1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.

सामान्य रूप से तुलना करने और JavaScript में संख्यात्मक वैल्यू की तुलना करने के बारे में अधिक जानकारी के लिए तुलना देखिए।

आम गलतियाँ

चूँकि JavaScript में संख्याएँ फ्लोटिंग-पॉइंट संख्याएँ होती हैं, इसलिए इन वैल्यू से होने वाला हर गणित फ्लोटिंग-पॉइंट गणित होता है। इसलिए, JavaScript में:

0.1 + 0.2 === 0.3;
// => false

संक्षिप्त समझ के लिए 0.30000000000000004.com देखिए, और गहराई से समझने के लिए Oracle की Numerical Computation Guide के परिशिष्ट D यानी “What Every Computer Scientist Should Know About Floating-Point Arithmetic” देखिए।