javascript - हरण - हिंदी में जावास्क्रिप्ट परिचय




जावास्क्रिप्ट का उच्चतम पूर्णांक मान क्या है कि कोई संख्या सटीकता खोए बिना जा सकती है? (14)

क्या यह भाषा द्वारा परिभाषित किया गया है? क्या एक परिभाषित अधिकतम है? क्या यह विभिन्न ब्राउज़रों में अलग है?


सुरक्षित रहने के लिए

var MAX_INT = 4294967295;

विचार

मैंने सोचा कि मैं चालाक हो जाऊंगा और उस मूल्य को x + 1 === x जिस पर x + 1 === x अधिक व्यावहारिक दृष्टिकोण के साथ।

मेरी मशीन केवल 10 मिलियन प्रति सेकंड या तो गिनती कर सकती है ... इसलिए मैं 28.56 वर्षों में निश्चित उत्तर के साथ वापस पोस्ट करूंगा।

यदि आप उस लंबे समय तक इंतजार नहीं कर सकते हैं, तो मैं शर्त लगा सकता हूं

  • आपके अधिकांश लूप 28.56 साल तक नहीं चलते हैं
  • 9007199254740992 === Math.pow(2, 53) + 1 पर्याप्त प्रमाण है
  • आपको 4294967295 Math.pow(2,32) - 1 चाहिए जो कि Math.pow(2,32) - 1 -स्थानांतरण के साथ अपेक्षित मुद्दों से बचने के लिए Math.pow(2,32) - 1

x + 1 === x ढूँढना:

(function () {
  "use strict";

  var x = 0
    , start = new Date().valueOf()
    ;

  while (x + 1 != x) {
    if (!(x % 10000000)) {
      console.log(x);
    }

    x += 1
  }

  console.log(x, new Date().valueOf() - start);
}());

Google Chrome अंतर्निहित जावास्क्रिप्ट में, संख्या को अनंतता कहा जाने से पहले आप लगभग 2 ^ 1024 तक जा सकते हैं।


अन्य ने पहले ही सामान्य जवाब दिया हो सकता है, लेकिन मैंने सोचा कि इसे निर्धारित करने का तेज़ तरीका देना एक अच्छा विचार होगा:

for (var x = 2; x + 1 !== x; x *= 2);
console.log(x);

जो मुझे Chrome71 में मिलीसेकंड से कम के भीतर 9007199254740992 देता है।

यह 2 की शक्तियों का परीक्षण करेगा, यह जानने के लिए कि कौन सा, 'जोड़ा' 1, खुद को बराबर करता है।


ईसीएमएस्क्रिप्ट 6:

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;

जावास्क्रिप्ट में, Infinity नामक एक संख्या है।

उदाहरण:

(Infinity>100)
=> true

// Also worth noting
Infinity - 1 == Infinity
=> true

Math.pow(2,1024) === Infinity
=> true

यह इस विषय के बारे में कुछ प्रश्नों के लिए पर्याप्त हो सकता है।


प्रयत्न:

maxInt = -1 >>> 1

फ़ायरफ़ॉक्स 3.6 में यह 2 ^ 31 - 1 है।


बिटवाई ऑपरेशंस के लिए आप जो कुछ भी उपयोग करना चाहते हैं, वह 0x80000000 (-2147483648 या -2 ^ 31) और 0x7fffffff (2147483647 या 2 ^ 31 - 1) के बीच होना चाहिए।

कंसोल आपको बताएगा कि 0x80000000 +2147483648 के बराबर है, लेकिन 0x80000000 और 0x80000000 बराबर -2147483648।


मूल रूप से जावास्क्रिप्ट लंबे समय तक समर्थन नहीं करता है।
इसलिए सामान्य मानों के लिए यह 32 बिट से कम प्रतिनिधित्व कर सकता है, यह इंट टाइप कंटेनर का उपयोग करेगा। पूर्णांक मानों के लिए 32 बिट से अधिक इसका उपयोग डबल होता है। डबल पुनर्स्थापन में पूर्णांक भाग 53 बिट है और बाकी मंटिसा है (फ़्लोटिंग पॉइंट जानकारी रखने के लिए)।
तो आप 2^53 - 1 उपयोग कर सकते हैं जो मान 9007199254740991
आप Number.MAX_SAFE_INTEGER द्वारा अपने कोड में उपयोग करने के लिए मूल्य तक पहुंच सकते हैं


मैंने फॉर्मूला, एक्स- (एक्स + 1) = - 1 के साथ एक सरल परीक्षण किया, और एक्सआई का सबसे बड़ा मूल्य सफारी, ओपेरा और फ़ायरफ़ॉक्स (ओएस एक्स पर परीक्षण) पर काम कर सकता है 9e15 है। यहां कोड है जिसका उपयोग मैंने परीक्षण के लिए किया था:

javascript: alert(9e15-(9e15+1));

यह 2 53 == 9 007 199 254 740 992 है। ऐसा इसलिए है क्योंकि Number को 52-बिट मंटिसा में फ़्लोटिंग-पॉइंट के रूप में संग्रहीत किया जाता है।

न्यूनतम मूल्य -2 53 है

यह कुछ मजेदार चीजें हो रहा है

Math.pow(2, 53) == Math.pow(2, 53) + 1
>> true

और खतरनाक भी हो सकता है :)

var MAX_INT = Math.pow(2, 53); // 9 007 199 254 740 992
for (var i = MAX_INT; i < MAX_INT + 2; ++i) {
    // infinite loop
}

आगे पढ़ने: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html


स्काटो wrotes:

बिटवाई ऑपरेशंस के लिए आप जो कुछ भी उपयोग करना चाहते हैं, वह 0x80000000 (-2147483648 या -2 ^ 31) और 0x7fffffff (2147483647 या 2 ^ 31 - 1) के बीच होना चाहिए।

कंसोल आपको बताएगा कि 0x80000000 +2147483648 के बराबर है, लेकिन 0x80000000 और 0x80000000 बराबर -2147483648

हेक्स-डेसीमल्स अप्रमाणित सकारात्मक मान हैं, इसलिए 0x80000000 = 2147483648 - गणितीय रूप से सही है। यदि आप इसे एक हस्ताक्षरित मूल्य बनाना चाहते हैं तो आपको सही बदलाव करना होगा: 0x80000000 >> 0 = -2147483648। आप इसके बजाय 1 << 31 भी लिख सकते हैं।


Number.MAX_VALUE जावास्क्रिप्ट में प्रदर्शित अधिकतम संख्यात्मक मान का प्रतिनिधित्व करता है।

चूंकि ऐसा कोई नहीं कहता है, वी 8 इंजन में 31 bits संख्या और उसके ऊपर की संख्या के लिए व्यवहार में अंतर है।

यदि आपके पास 32 bits तो आप जावास्क्रिप्ट इंजन को बताने के लिए पहले बिट का उपयोग कर सकते हैं कि डेटा किस प्रकार है और शेष बिट्स में वास्तविक डेटा है। यही कारण है कि वी 8 31 bis numbers लिए एक छोटे अनुकूलन के रूप में करता है (या करने के लिए किया जाता है, मेरे स्रोत काफी दिनांकित हैं)। आपके पास अंतिम 31 bits संख्या मान हैं और फिर इंजन को बताते हुए पहली बात यह है कि यह संख्या या ऑब्जेक्ट संदर्भ है।

हालांकि यदि आप 31 bits ऊपर की संख्या का उपयोग करते हैं तो डेटा फिट नहीं होगा, संख्या 64 बिट्स डबल में बॉक्स की जाएगी और अनुकूलन वहां नहीं होगा।

नीचे दी गई वीडियो में नीचे की रेखा है:

संख्यात्मक मानों को प्राथमिकता दें जिन्हें 31 बिट हस्ताक्षरित पूर्णांक के रूप में प्रदर्शित किया जा सकता है।


+/- 9007199254740991

ईसीएमए धारा 8.5 - संख्याएं

ध्यान दें कि सभी सकारात्मक और नकारात्मक पूर्णांक जिनकी परिमाण 2 53 से अधिक नहीं है, संख्या प्रकार (वास्तव में, पूर्णांक 0 में दो प्रतिनिधित्व, +0 और -0) में प्रतिनिधित्व योग्य हैं।

वे 64-बिट फ्लोटिंग पॉइंट मान हैं, सबसे बड़ा सटीक अभिन्न मूल्य 2 53 -1, या 9007199254740991 । ES6 में, इसे Number.MAX_SAFE_INTEGER रूप में परिभाषित किया Number.MAX_SAFE_INTEGER

ध्यान दें कि बिटवाई ऑपरेटरों और शिफ्ट ऑपरेटर 32-बिट इन्सट्स पर काम करते हैं, इसलिए उस स्थिति में, अधिकतम सुरक्षित पूर्णांक 2 31 -1, या 2147483647 है।

इसका परीक्षण करें!

var x = 9007199254740992;
var y = -x;
x == x + 1; // true !
y == y - 1; // also true !
// Arithmetic operators work, but bitwise/shifts only operate on int32:
x / 2;      // 4503599627370496
x >> 1;     // 0
x | 1;      // 1

जिमी का जवाब निरंतर जावास्क्रिप्ट पूर्णांक स्पेक्ट्रम का प्रतिनिधित्व करता है -9007199254740992 से 9007199254740992 समावेशी (क्षमा करें 9007199254740993, आपको लगता है कि आप 9007199254740993 हैं, लेकिन आप गलत हैं! नीचे प्रदर्शन या जेएसफ़िड में )।

document.write(9007199254740993);

हालांकि, ऐसा कोई जवाब नहीं है जो इस प्रोग्रामेटिक रूप से पाता / साबित करता है (एक कूलएजे 86 के अलावा जो उसके जवाब में उल्लिखित है 28.56 वर्षों में खत्म होगा;), इसलिए यह करने के लिए थोड़ा और अधिक प्रभावी तरीका है (सटीक होना, यह अधिक कुशल है लगभग 28.559 99 99 99968312 साल :), एक परीक्षण पहेली के साथ:

/**
 * Checks if adding/subtracting one to/from a number yields the correct result.
 *
 * @param number The number to test
 * @return true if you can add/subtract 1, false otherwise.
 */
var canAddSubtractOneFromNumber = function(number) {
    var numMinusOne = number - 1;
    var numPlusOne = number + 1;
    
    return ((number - numMinusOne) === 1) && ((number - numPlusOne) === -1);
}

//Find the highest number
var highestNumber = 3; //Start with an integer 1 or higher

//Get a number higher than the valid integer range
while (canAddSubtractOneFromNumber(highestNumber)) {
    highestNumber *= 2;
}

//Find the lowest number you can't add/subtract 1 from
var numToSubtract = highestNumber / 4;
while (numToSubtract >= 1) {
    while (!canAddSubtractOneFromNumber(highestNumber - numToSubtract)) {
        highestNumber = highestNumber - numToSubtract;
    }
    
    numToSubtract /= 2;
}        

//And there was much rejoicing.  Yay.    
console.log('HighestNumber = ' + highestNumber);







cross-browser