JavaScript
में निर्मित लगातार

संचालन जो NaN लौटाता है

संख्याओं के अलावा अन्य मूल्यों पर गणितीय संचालन NaN लौटाता है।

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

एक अपवाद: एकल-संख्या सरणियाँ।

[2] * [3]  // Returns 6

यह भी याद रखें कि + ऑपरेटर स्ट्रिंग्स को समाप्‍त करता है।

"a" + "b"  // Returns "ab"

शून्य को शून्य से विभाजित करना NaN देता है।

0 / 0         // NaN

नोट: गणित में (जावास्क्रिप्ट प्रोग्रामिंग के विपरीत) आम तौर पर, शून्य से विभाजित करना संभव नहीं है।

गणित पुस्तकालय फ़ंक्शंस जो NaN लौटाता है

आम तौर पर, Math फ़ंक्शंस जो गैर-संख्यात्मक तर्क दिए जाते हैं, NaN वापस कर देंगे।

Math.floor("a")

एक नकारात्मक संख्या का वर्गमूल NaN देता है, क्योंकि Math.sqrt काल्पनिक या जटिल संख्याओं का समर्थन नहीं करता है।

Math.sqrt(-1)

NaN का उपयोग करके NaN के लिए परीक्षण ()

window.isNaN()

वैश्विक फ़ंक्शन isNaN() का उपयोग यह जांचने के लिए किया जा सकता है कि क्या कोई निश्चित मान या अभिव्यक्ति NaN मूल्यांकन करता है। यह फ़ंक्शन (संक्षेप में) पहले जांचता है कि क्या मान एक संख्या है, यदि इसे (*) बदलने की कोशिश नहीं करता है, और फिर जांचता है कि परिणामी मान NaN । इस कारण से, यह परीक्षण विधि भ्रम पैदा कर सकती है ।

^{(*) "रूपांतरण" विधि इतनी सरल नहीं है, एल्गोरिथ्म के विस्तृत विवरण के लिए ECMA-262 18.2.3 देखें।}

ये उदाहरण आपको isNaN() व्यवहार को बेहतर ढंग से समझने में मदद करेंगे:

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

यह आखिरी एक मुश्किल सा है: अगर एक Array NaN है तो जाँच करना। ऐसा करने के लिए, Number() निर्माता पहले सरणी को एक स्ट्रिंग में परिवर्तित करता है, फिर एक नंबर पर; यही कारण है कि isNaN([]) और isNaN([34]) दोनों false , लेकिन isNaN([1, 2]) और isNaN([true]) दोनों ही true : क्योंकि वे "" , "34" "" परिवर्तित हो गए हैं "34" , "1,2" और "true" क्रमशः। सामान्य तौर पर, एक सरणी को isNaN() द्वारा NaN माना जाता है जब तक कि यह केवल एक तत्व नहीं रखता है जिसके स्ट्रिंग प्रतिनिधित्व को एक वैध संख्या में परिवर्तित किया जा सकता है ।

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

शून्य

null का उपयोग वस्तु मूल्य के जानबूझकर अनुपस्थिति का प्रतिनिधित्व करने के लिए किया जाता है और यह एक आदिम मूल्य है। undefined विपरीत, यह वैश्विक वस्तु की संपत्ति नहीं है।

यह undefined बराबर है लेकिन इसके समान नहीं है।

null == undefined; // true
null === undefined; // false

CAREFUL : typeof null 'object' ।

typeof null; // 'object';

किसी मान के null ठीक से जांच करने के लिए, इसकी तुलना सख्त समानता ऑपरेटर से करें

var a = null;

a === null; // true

अपरिभाषित और अशक्त

पहली नज़र में यह प्रतीत हो सकता है कि null और undefined मूल रूप से एक ही हैं, हालांकि सूक्ष्म लेकिन महत्वपूर्ण अंतर हैं।

undefined संकलक में एक मूल्य की अनुपस्थिति है, क्योंकि जहां इसका मूल्य होना चाहिए, वहां एक नहीं दिया गया है, जैसे कि एक अप्रमाणित चर के मामले में।

• undefined एक वैश्विक मूल्य है जो एक निर्दिष्ट मूल्य की अनुपस्थिति का प्रतिनिधित्व करता है।
  • typeof undefined === 'undefined'
• null एक ऐसी वस्तु है जो इंगित करती है कि एक चर को स्पष्ट रूप से "कोई मूल्य नहीं" दिया गया है।
  • typeof null === 'object'

undefined लिए एक चर सेट करने का मतलब है कि चर प्रभावी रूप से मौजूद नहीं है। कुछ प्रक्रियाएँ, जैसे JSON क्रमांकन, वस्तुओं से undefined गुणों को undefined सकती हैं। इसके विपरीत, null गुणों को इंगित किया जाएगा ताकि आप "खाली" संपत्ति की अवधारणा को स्पष्ट रूप से बता सकें।

undefined लिए निम्नलिखित मूल्यांकन:

• एक चर जब इसे घोषित किया जाता है लेकिन एक मान नहीं दिया जाता है (यानी परिभाषित)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• उस प्रॉपर्टी की वैल्यू एक्सेस करना जो मौजूद नहीं है

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• किसी फ़ंक्शन का रिटर्न मान जो मान वापस नहीं करता है

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• एक फ़ंक्शन तर्क का मान घोषित किया गया है लेकिन फ़ंक्शन कॉल से हटा दिया गया है

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined भी वैश्विक window ऑब्जेक्ट की एक संपत्ति है।

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

इन्फिनिटी और -इनफिनिटी

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity वैश्विक वस्तु का एक गुण है (इसलिए एक वैश्विक चर) जो गणितीय अनंत का प्रतिनिधित्व करता है। यह Number.POSITIVE_INFINITY संदर्भ है

यह किसी भी अन्य मूल्य से अधिक है, और आप इसे 0 से विभाजित करके या किसी संख्या की अभिव्यक्ति का मूल्यांकन करके प्राप्त कर सकते हैं जो इतना बड़ा है कि ओवरफ्लो होता है। इसका वास्तव में मतलब है कि जावास्क्रिप्ट में 0 त्रुटियों से कोई विभाजन नहीं है, इन्फिनिटी है!

इसमें -Infinity भी है जो गणितीय नकारात्मक अनंत है, और यह किसी भी अन्य मूल्य से कम है।

प्राप्त करने के लिए -Infinity आप Infinity नकारते हैं, या Number.NEGATIVE_INFINITY में इसका संदर्भ प्राप्त Number.NEGATIVE_INFINITY । Number.NEGATIVE_INFINITY ।

- (Infinity); // -Infinity

आइए अब कुछ उदाहरणों के साथ मज़े करें:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

NaN

NaN अर्थ है "नॉट ए नंबर।" जब एक गणितीय फ़ंक्शन या जावास्क्रिप्ट में ऑपरेशन एक विशिष्ट संख्या नहीं लौटा सकता है, तो इसके बजाय मान NaN लौटाता है।

यह वैश्विक वस्तु का गुण है, और Number.NaN संदर्भ है

window.hasOwnProperty('NaN'); // true
NaN; // NaN

शायद भ्रमित, NaN को अभी भी एक नंबर माना जाता है।

typeof NaN; // 'number'

समानता ऑपरेटर का उपयोग करके NaN लिए जाँच न करें। इसके बजाय isNaN देखें।

NaN == NaN  // false
NaN === NaN // false

संख्या स्थिरांक

Number कंस्ट्रक्टर ने कुछ स्थिरांक बनाए हैं जो उपयोगी हो सकते हैं

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

कई मामलों में जावास्क्रिप्ट के विभिन्न ऑपरेटरों की सीमा के बाहर के मूल्यों के साथ टूट जाएगा ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

ध्यान दें कि Number.EPSILON एक और सबसे छोटी Number बीच एक से अधिक का प्रतिनिधित्व करता है, और इस प्रकार दो भिन्न Number मानों के बीच सबसे छोटा संभव अंतर है। इसका उपयोग करने का एक कारण यह है कि जावास्क्रिप्ट द्वारा संख्याओं को कैसे संग्रहीत किया जाता है इसकी प्रकृति के कारण दो संख्याओं की समानता देखें