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

Question

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

Comments

आपको जेएस की सीमाओं जैसे कि github.com/MikeMcl/big.js जैसे पुस्तकालयों पर निर्भर होने की आवश्यकता नहीं है , इसकी विश्वसनीयता परीक्षणों के लिए यहां

— दमित्री जैतसेव

उच्चतम पूर्णांक मान क्या आप big.js के साथ उपयोग कर सकते हैं?

— जॉर्ज

@George यहाँ बड़ी है। js API: mikemcl.github.io/big.js/#dp

— simhumileco

सवाल का कोई मतलब नहीं है। इसका क्या अर्थ है कि एक संख्या "एक पूर्णांक मान" जाती है? यदि आप केवल यह पूछना चाहते हैं कि जेएस में आपका प्रतिनिधित्व करने वाला उच्चतम पूर्णांक क्या है, तो उच्चतम (परिमित) संख्या ही पूर्णांक है।

— 3

@DmitriZaitsev हमें किसी भी अधिक (कुछ ब्राउज़रों पर, कम से कम) बाहरी पुस्तकालयों पर निर्भर होने की आवश्यकता नहीं है। 1n << 10000nबिना किसी निर्भरता को खोए, बिना किसी निर्भरता (और कहने की जरूरत नहीं है, एक सीमा के करीब भी नहीं) के बिना वास्तव में वास्तव में बड़ा पूर्णांक है।

— आमदन

Answer 1

जावास्क्रिप्ट के दो प्रकार हैं: Numberऔर BigInt।

सबसे अधिक इस्तेमाल किया जाने वाला नंबर प्रकार, Number64-बिट फ्लोटिंग पॉइंट IEEE 754 नंबर है।

इस प्रकार का सबसे बड़ा अभिन्न मूल्य है Number.MAX_SAFE_INTEGER, जो है:

• 2 ⁵³ -1, या
• +/- 9,007,199,254,740,991, या
• नौ चौदह सात खरब सौ नव्वे नौ दो सौ चौदह दस लाख सात चालीस हजारों नौ नव्वे एक

इसे परिप्रेक्ष्य में रखने के लिए: एक क्वाड्रिलियन बाइट्स एक पेटाबाइट (या एक हजार टेराबाइट्स) है।

इस संदर्भ में "सुरक्षित" पूर्णांक का प्रतिनिधित्व करने और उनकी तुलना करने की क्षमता को संदर्भित करता है।

कल्पना से:

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

इससे बड़े पूर्णांक का सुरक्षित रूप से उपयोग करने के लिए, आपको उपयोग करने की आवश्यकता है BigInt, जिसकी कोई ऊपरी सीमा नहीं है।

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

const log = console.log
var x = 9007199254740992
var y = -x
log(x == x + 1) // true !
log(y == y - 1) // also true !

// Arithmetic operators work, but bitwise/shifts only operate on int32:
log(x / 2)      // 4503599627370496
log(x >> 1)     // 0
log(x | 1)      // 1

---

संख्या 9,007,199,254,740,992 के विषय पर तकनीकी नोट: इस मूल्य का सटीक IEEE-754 प्रतिनिधित्व है, और आप इस मान को एक चर से असाइन कर सकते हैं और पढ़ सकते हैं, इसलिए बहुत सावधानी से पूर्णांकों के डोमेन में अनुप्रयोगों को कम या बराबर के बराबर चुना जाता है। यह मान, आप इसे अधिकतम मूल्य के रूप में मान सकते हैं।

सामान्य स्थिति में, आपको इस IEEE-754 मूल्य को अक्षम मानना ​​चाहिए, क्योंकि यह अस्पष्ट है कि क्या यह तार्किक मान 9,007,199,254,740,992 या 9,007,199-254,740,993 एन्कोडिंग है।

Comments

यह सही लगता है, लेकिन क्या ऐसा कुछ स्थान है जहां इसे परिभाषित किया गया है, यह है ला सी का MAX_INT या जावा का Integer.MAX_AALUE?

— तिलालामा

4294967295 === Math.pow(2,32) - 1;

— CoolAJ86

तो सटीक सटीक आश्वासन देने के लिए हम सबसे छोटे और सबसे बड़े पूर्णांक का क्या उपयोग कर सकते हैं?

— पचेरियर

शायद यह ध्यान देने योग्य है कि जावास्क्रिप्ट में कोई वास्तविक (इंट) नहीं है। संख्या का प्रत्येक उदाहरण (फ्लोट) या NaN है।

— चुकंदर-चुकंदर

9007199254740992 वास्तव में अधिकतम मूल्य नहीं है, यहां अंतिम बिट पहले से ही शून्य माना जाता है और इसलिए आपने 1 बिट सटीक खो दिया है। वास्तविक सुरक्षित संख्या 9007199254740991 (नंबर। MAX_SAFE_INTEGER)

— विलेम डी'हैसेलेर

Answer 2

> = ईएस 6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ईएस 5

से संदर्भ :

Number.MAX_VALUE;
Number.MIN_VALUE;

console.log('MIN_VALUE', Number.MIN_VALUE);
console.log('MAX_VALUE', Number.MAX_VALUE);

console.log('MIN_SAFE_INTEGER', Number.MIN_SAFE_INTEGER); //ES6
console.log('MAX_SAFE_INTEGER', Number.MAX_SAFE_INTEGER); //ES6

Comments

मैंने अधिकतम पूर्णांक मानों के बारे में नहीं, बल्कि अधिकतम संख्या मान के बारे में थोड़ा और सटीक होने के लिए प्रश्न को संपादित किया है। भ्रम के लिए क्षमा करें, यहाँ।

— तल्ललामा

क्या लौटाया गया परिणाम सभी ब्राउज़रों पर समान होने की गारंटी है?

— पेसरियर

ध्यान दें कि Number.MIN_VALUEसबसे छोटी संभव सकारात्मक संख्या है। कम से कम मूल्य (यानी कम किसी और चीज से) शायद है -Number.MAX_VALUE।

— माइकल शीपर

ES6 परिचय Number.MIN_SAFE_INTEGERऔरNumber.MAX_SAFE_INTEGER

— सुपरलुक

तो, इस मामले में, क्या हमें जवाब को वोट देना चाहिए क्योंकि यह अद्यतन प्रश्न के लिए गलत है, या इसे छोड़ दें क्योंकि पीटर बेली उस समय सही था जब इसका उत्तर दिया गया था?

— रॉकेटसेटफेयर

Answer 3

यह 2 ⁵³ == 9 007 199 254 740 992 है। यह इसलिए है क्योंकि Number52-बिट मंटिसा में फ्लोटिंग-पॉइंट के रूप में संग्रहीत हैं।

न्यूनतम मान -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}

Comments

हालांकि, एक समय सीमा में पाश के लिए उस के अंत तक कभी नहीं पहुंचेगा, आप कहना चाह सकते हैंi += 1000000000

— Ninjagecko

@ninjagecko, वह MAX_INT से शुरू होता है इसलिए अंत वहीं है। इसके अलावा i + = 1000000000 का उपयोग करने से यह अनंत लूप नहीं रह जाएगा। कोशिश करो।

— टेड बीघम

@TedBigham: आह उफ़, इसके माध्यम से बहुत जल्दी तैयार था। मुझे दो बार सही करने के लिए धन्यवाद।

— नवजागेको

यहां 9,007,199,254,740,992 के बजाय 9,007,199,254,740,991 के लिए जिमी का तर्क देखें । मेरे अनुवर्ती के साथ संयुक्त, प्रेरक लगता है।

— टीजे क्राउडर

Answer 4

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

उदाहरण:

(Infinity>100)
=> true

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

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

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

Comments

कुछ मुझे बताता है कि अनंत एक पूर्णांक के रूप में योग्य नहीं है। :)

— devios1

minजब आप न्यूनतम मूल्य की तलाश कर रहे हों तो किसी चर को शुरू करना काफी अच्छा होता है ।

— djjeck

ध्यान दें किInfinity - 1 === Infinity

— H.Wolper

भी (इन्फिनिटी <100) => झूठे और Math.pow (2,1024) === इन्फिनिटी

— Sijav

इसके अलावा कुछ भी नहीं है कि यह नकारात्मक इन्फिनिटी को भी संभालता है। तो1 - Infinity === -Infinity

— dmccabe 21

Answer 5

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

console.log(9007199254740993);

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

/**
 * 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);

Comments

@ CoolAJ86: लोल, मैं 15 मार्च, 2040 का इंतजार कर रहा हूं। अगर हमारे नंबर मैच करते हैं तो हमें एक पार्टी

— फेंकनी

var x = Math.pow (2,53) -3; जबकि (x! = x + 1) x ++; -> 9007199254740991

— मिकलेह नोव

@ मिक् एलएच: मुझे उस कोड के साथ 9007199254740992 मिलते हैं । आप परीक्षण करने के लिए किस जावास्क्रिप्ट इंजन का उपयोग कर रहे हैं?

— Briguy37

आपको अपने स्वयं के कोड के साथ 9007199254740992 मिलते हैं, मैंने एक्स के अंतिम मूल्य का उपयोग नहीं किया था, लेकिन पागल कारणों के लिए x ++ का अंतिम निकासी। Google Chrome btw।

— मिकलाह

@ मिक् एल: मूल्यांकन बढ़ने से पहलेx++ आपको x का मान देता है , जिससे शायद विसंगति की व्याख्या हो सके। यदि आप एक्स के अंतिम मूल्य के रूप में उसी चीज़ का मूल्यांकन करने के लिए अभिव्यक्ति चाहते हैं, तो आपको इसे बदलना चाहिए । ++x

— पेट्रिग्नन

Answer 6

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

var MAX_INT = 4294967295;

विचार

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

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

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

• आपके अधिकांश लूप 28.56 वर्षों तक नहीं चलते हैं
• 9007199254740992 === Math.pow(2, 53) + 1 पर्याप्त है
• आप छड़ी चाहिए करने के लिए 4294967295जो है 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);
}());

Comments

कठबोली आप इसे 2 ^ 53 - 2 से शुरू करने के लिए परीक्षण करेंगे? (हाँ आप कर सकते हैं, मैंने इसे अभी भी कोशिश की थी, यहां तक ​​कि -3 के सुरक्षित होने के लिए भी: var x = Math.pow (2,53) -3; जबकि (x = x + 1) x ++;) -> 9007199254740991

— MickLov

अच्छा उत्तर! इसके अलावा, मुझे पता है कि मूल्य तय हो गया है, लेकिन इसकी खोज के लिए द्विआधारी खोज का उपयोग क्यों नहीं किया जाता है?

— हिगारो

उसमें क्या मजा है? इसके अलावा, @ Briguy37 ने मुझे इसे हराया: stackoverflow.com/a/11639621/151312

— CoolAJ86

ध्यान दें कि दिनांक मानों की तुलना करते समय 32 बिट्स पर आधारित यह 'सुरक्षित' MAX_INT काम नहीं करेगा। 4294967295 तो कल है!

— जेरी

जवाब "सुरक्षित होने के लिए: var MAX_INT = 4294967295;" विनोदी नहीं है। यदि आप बिटशिफ्टिंग नहीं कर रहे हैं, तो इसके बारे में चिंता न करें (जब तक कि आपको 4294967295 से बड़े इंट की आवश्यकता न हो, उस स्थिति में आपको शायद इसे एक स्ट्रिंग के रूप में संग्रहीत करना चाहिए और एक बिगिंट लाइब्रेरी का उपयोग करना चाहिए)।

— CoolAJ86

Answer 7

संक्षिप्त उत्तर "यह निर्भर करता है।"

यदि आप कहीं भी बिटवाइज़ ऑपरेटर का उपयोग कर रहे हैं (या यदि आप किसी ऐरे की लंबाई का उल्लेख कर रहे हैं), तो सीमाएँ हैं:

अहस्ताक्षरित: 0…(-1>>>0)

प्रवेश किया गया: (-(-1>>>1)-1)…(-1>>>1)

(ऐसा होता है कि बिटवाइज़ ऑपरेटर और किसी सरणी की अधिकतम लंबाई 32-बिट पूर्णांक तक सीमित होती है।)

यदि आप बिटवाइज़ ऑपरेटर का उपयोग नहीं कर रहे हैं या सरणी लंबाई के साथ काम कर रहे हैं:

प्रवेश किया गया: (-Math.pow(2,53))…(+Math.pow(2,53))

इन सीमाओं को "संख्या" प्रकार के आंतरिक प्रतिनिधित्व द्वारा लगाया जाता है, जो आमतौर पर IEEE 754 डबल-सटीक फ़्लोटिंग-पॉइंट प्रतिनिधित्व से मेल खाती है। (ध्यान दें कि विशिष्ट हस्ताक्षरित पूर्णांकों के विपरीत, नकारात्मक सीमा का परिमाण आंतरिक प्रतिनिधित्व की विशेषताओं के कारण सकारात्मक सीमा के परिमाण के समान है, जिसमें वास्तव में एक नकारात्मक 0 शामिल है !)

Comments

यह वह उत्तर है जो मैं एक्स को 32 बिट पूर्णांक या अहस्ताक्षरित पूर्णांक में परिवर्तित करने के तरीके पर ठोकर खाना चाहता था। उसके लिए अपना उत्तर दिया।

— चार्ली एफ्फिमिगेटो

Answer 8

ECMAScript 6:

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

Comments

खबरदार यह (अभी तक) सभी ब्राउज़रों द्वारा समर्थित नहीं है! आज iOS (क्रोम भी नहीं), सफारी और IE इसे पसंद नहीं करते हैं।

— cregox

कृपया उत्तर को ध्यान से पढ़ें, हम ECMAScript 6 में Number.MAX_SAFE_INTEGER के डिफ़ॉल्ट कार्यान्वयन का उपयोग नहीं कर रहे हैं, हम इसे Math.pow (2, 53) -1 द्वारा परिभाषित कर रहे हैं

— WaiKit Kung

मुझे लगा कि यह ECMA 6 में कैसे लागू किया गया था, यह सिर्फ एक संदर्भ था! : पीआई को लगता है कि मेरी टिप्पणी अभी भी मान्य है, हालांकि। सभी संदर्भ की बात है। ;)

— cregox

क्या MAX_SAFE_INTEGERपीछे की ओर काम करके सभी ब्राउज़रों में गणना करना विश्वसनीय है ? क्या आपको इसके बजाय आगे बढ़ना चाहिए? Ie, नंबर। MAX_SAFE_INTEGER = 2 * (गणित। 2 (52, 52) - 1) + 1;

— kjv

है Math.pow(2, 53)-1एक सुरक्षित संचालन? यह सबसे बड़े सुरक्षित पूर्णांक से एक बड़ा हो जाता है।

— ioquatix

Answer 9

पहले से कई जवाब परिणाम से पता चला है trueकी 9007199254740992 === 9007199254740992 + 1सत्यापित करने के लिए 9 007 199 254 740 991 अधिकतम और सुरक्षित पूर्णांक है।

क्या होगा अगर हम संचय करते रहें:

input: 9007199254740992 + 1  output: 9007199254740992  // expected: 9007199254740993
input: 9007199254740992 + 2  output: 9007199254740994  // expected: 9007199254740994
input: 9007199254740992 + 3  output: 9007199254740996  // expected: 9007199254740995
input: 9007199254740992 + 4  output: 9007199254740996  // expected: 9007199254740996

हम पता लगा है कि तुलना में संख्या के बीच अधिक से अधिक 9 007 199 254 740 992 , केवल भी नंबर दिए गए हैं प्रदर्शनीय ।

यह समझाने के लिए एक प्रवेश द्वार है कि डबल-परिशुद्धता 64-बिट बाइनरी प्रारूप इस पर कैसे काम करता है। आइए देखें कि इस द्विआधारी प्रारूप का उपयोग करके 9 007 199 254 740 992 का आयोजन (प्रतिनिधित्व) कैसे किया जाता है।

4 503 599 627 370 496 से प्रदर्शित करने के लिए एक संक्षिप्त संस्करण का उपयोग करना :

  1 . 0000 ---- 0000  *  2^52            =>  1  0000 ---- 0000.  
     |-- 52 bits --|    |exponent part|        |-- 52 bits --|

तीर के बाईं ओर, हमारे पास बिट मान 1 है , और एक आसन्न मूलांक बिंदु है , फिर गुणा करके 2^52, हम सही मूलांक 52 चरण को स्थानांतरित करते हैं, और यह अंत में जाता है। अब हमें बाइनरी में 4503599627370496 मिलते हैं।

अब हम 1 को इस मान पर जमा करना शुरू करते हैं जब तक कि सभी बिट्स 1 पर सेट नहीं हो जाते हैं, जो दशमलव में 9 007 199 254 740 991 के बराबर है ।

  1 . 0000 ---- 0000  *  2^52  =>  1  0000 ---- 0000.  
                       (+1)
  1 . 0000 ---- 0001  *  2^52  =>  1  0000 ---- 0001.  
                       (+1)
  1 . 0000 ---- 0010  *  2^52  =>  1  0000 ---- 0010.  
                       (+1)
                        . 
                        .
                        .
  1 . 1111 ---- 1111  *  2^52  =>  1  1111 ---- 1111. 

अब, क्योंकि दोहरे-सटीक 64-बिट बाइनरी प्रारूप में , यह कड़ाई से अंश के लिए 52 बिट्स आवंटित करता है , एक और 1 को जोड़ने के लिए और अधिक बिट उपलब्ध नहीं है, इसलिए हम क्या कर सकते हैं सभी बिट्स को 0 पर सेट करें, और घातांक भाग में हेरफेर करें:

  |--> This bit is implicit and persistent.
  |        
  1 . 1111 ---- 1111  *  2^52      =>  1  1111 ---- 1111. 
     |-- 52 bits --|                     |-- 52 bits --|

                          (+1)
                                     (radix point has no way to go)
  1 . 0000 ---- 0000  *  2^52 * 2  =>  1  0000 ---- 0000. * 2  
     |-- 52 bits --|                     |-- 52 bits --|

  =>  1 . 0000 ---- 0000  *  2^53 
         |-- 52 bits --| 

अब हमें ९ ०० 199 ९९ २५४ ४ ९९ ९९ २ मिलता है , और इससे अधिक संख्या के साथ, प्रारूप जो पकड़ सकता है वह अंश का २ गुना है , इसका मतलब है कि अब अंश पर हर 1 जोड़ वास्तव में 2 जोड़ के बराबर है, यही कारण है कि डबल -परिचय 64-बिट बाइनरी प्रारूप विषम संख्याओं को धारण नहीं कर सकता है जब संख्या 9 007 199 254 740 992 से अधिक है :

                            (consume 2^52 to move radix point to the end)
  1 . 0000 ---- 0001  *  2^53  =>  1  0000 ---- 0001.  *  2
     |-- 52 bits --|                 |-- 52 bits --|

जब संख्या 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984 से अधिक हो जाती है, तो केवल 4 बार अंश का आयोजन किया जा सकता है:

input: 18014398509481984 + 1  output: 18014398509481984  // expected: 18014398509481985
input: 18014398509481984 + 2  output: 18014398509481984  // expected: 18014398509481986
input: 18014398509481984 + 3  output: 18014398509481984  // expected: 18014398509481987
input: 18014398509481984 + 4  output: 18014398509481988  // expected: 18014398509481988

कैसे [ 2 251 799 813 685 248 के बीच की संख्या , 4 503 599 627 370 496 ) के ?

 1 . 0000 ---- 0001  *  2^51  =>  1 0000 ---- 000.1
     |-- 52 bits --|                |-- 52 bits  --|

मूलांक 1 के बाद का बिट मान 2 ^ -1 है। (= 1/2, = 0.5) इसलिए जब संख्या 4 503 599 627 370 496 से कम हो 1/2 (2 ^ 52) से कम हो, तो पूर्णांक के 1/2 बार का प्रतिनिधित्व करने के लिए एक बिट उपलब्ध है :

input: 4503599627370495.5   output: 4503599627370495.5  
input: 4503599627370495.75  output: 4503599627370495.5  

से कम 2 251 799 813 685 248 (2 ^ 51)

input: 2251799813685246.75   output: 2251799813685246.8  // expected: 2251799813685246.75 
input: 2251799813685246.25   output: 2251799813685246.2  // expected: 2251799813685246.25 
input: 2251799813685246.5    output: 2251799813685246.5

// If the digits exceed 17, JavaScript round it to print it.
//, but the value is held correctly:

input: 2251799813685246.25.toString(2) 
output: "111111111111111111111111111111111111111111111111110.01"
input: 2251799813685246.75.toString(2) 
output: "111111111111111111111111111111111111111111111111110.11"
input: 2251799813685246.78.toString(2)   
output: "111111111111111111111111111111111111111111111111110.11"

और घातांक भाग की उपलब्ध सीमा क्या है ? प्रारूप इसके लिए 11 बिट्स आवंटित करता है। विकी से पूरा प्रारूप : (अधिक जानकारी के लिए कृपया वहां जाएं)

तो घातांक का भाग 2 ^ 52 होने के लिए, हमें वास्तव में e = 1075 सेट करने की आवश्यकता है।

Answer 10

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

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

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

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

Comments

यह आपके एप्लिकेशन को क्रैश कर सकता है, सोचा।

— नीलमणि_क्रिक

Answer 11

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

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

Answer 12

प्रयत्न:

maxInt = -1 >>> 1

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

Comments

@danorton: मुझे यकीन नहीं है कि आप समझ रहे हैं कि आप क्या कर रहे हैं। ^साधन घात । जावास्क्रिप्ट कंसोल में ^है XOR , उठाया-के लिए नहीं

— kumarharsh

क्रोम / फ़ायरफ़ॉक्स कंसोल खोलें। टाइप 5 ^ 2। बाइनरी में, 5 है 101और 2 है 010। अब, अगर आप उन्हें बिटवॉयर XOR करते हैं, तो आप 5(101) ^ 2(010) = 7(111) इस बात को Math.pow()^

— पढ़ेंगे

फिर, मैं बिल्कुल भी भ्रमित नहीं हूं। मैंने जो लिखा है, उस पर टिप्पणी की है और अस्वीकृत किया है । यदि Math.pow () का मतलब क्या है, तो वही लिखा जाना चाहिए। जावास्क्रिप्ट के बारे में एक सवाल के जवाब में, एक अलग भाषा के वाक्यविन्यास का उपयोग करना अनुचित है। यह एक सिंटैक्स का उपयोग करना और भी अनुचित है जो जावास्क्रिप्ट में मान्य है, लेकिन जावास्क्रिप्ट में एक व्याख्या के साथ इसका एक अलग अर्थ है जो इरादा है।

— danorton

2 ^ 31 यह है कि कैसे अंग्रेजी में दो से इकतीसवीं शक्ति लिखता है। यह एक कोड ब्लॉक में नहीं है। क्या आप किसी व्यक्ति के बारे में शिकायत करेंगे; एक उत्तर में, क्योंकि यह जावास्क्रिप्ट में एक अलग अर्थ के साथ एक चरित्र है?

— lmm

भले ही ऐसा करने के लिए किसी को सादे पाठ में 2³¹ और न कि 2 ^ 31 लिखना चाहिए , क्योंकि अधिकांश कीबोर्ड लेआउट में डिफ़ॉल्ट रूप से वे वर्ण नहीं होते हैं। कम से कम मुझे यह समझने में कोई समस्या नहीं थी कि इस उत्तर में क्या था।

— जॉक

Answer 13

लेखन के क्षण में, जावास्क्रिप्ट एक नया डेटा प्रकार प्राप्त कर रहा है BigInt:। यह EcmaScript 2020 में शामिल होने के लिए स्टेज 4 पर TC39 का प्रस्ताव है । क्रोम 67+, फायरफॉक्स 68+, ओपेरा 54 और नोड 10.4.0 में उपलब्ध है। यह सफारी में चल रहा है, एट अल ... यह संख्यात्मक "एन" प्रत्यय होने का परिचय देता है और मनमाने तरीके से अनुमति देता है:BigInt

var a = 123456789012345678901012345678901n;

परिशुद्धता अभी भी खो जाएगी, निश्चित रूप से, जब ऐसी संख्या एक संख्या डेटा प्रकार के लिए (शायद अनजाने में) है।

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

उदाहरण के लिए, सौ हज़ार दशमलव अंकों वाली एक संख्या की पीढ़ी, पूरा होने से पहले ध्यान देने योग्य देरी करेगी:

console.log(BigInt("1".padEnd(100000,"0")) + 1n)

... लेकिन यह काम करता है।

Answer 14

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

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

Comments

ध्यान दें कि 9e15 = 2 ^ 53 (@ जिमी का जवाब देखें)।

— वेज

9e15 = 9000000000000000. 2 ^ 53 = 9007199254740992. इसलिए पांडित्य होने के लिए, 9e15 केवल लगभग 2 ^ 53 (दो महत्वपूर्ण अंकों के साथ) के बराबर है।

— devios1

@chaiguy 90000000000000001 महत्वपूर्ण आंकड़ा है। `9007199254740992` में 15 महत्वपूर्ण आंकड़े हैं।

— रॉय नमिर

@RoyiNamir यहां व्यर्थ तर्क शुरू नहीं करना चाहता, लेकिन 9000000000000000 में 16 महत्वपूर्ण अंक हैं। यदि आप केवल 1 चाहते हैं, तो इसे 9x10 ^ 15 लिखा जाना चाहिए।

— devios1

@chaiguy के 9000000000000000रूप में यह है - 1SF है। जहां 90*10^14है 2. ( sigfigscalculator.appspot.com ) और mathsfirst.massey.ac.nz/Algebra/Decimals/SigFig.htm (नीचे अनुभाग)

— Royi Namir

Answer 15

मैं इसे इस तरह लिखता हूं:

var max_int = 0x20000000000000;
var min_int = -0x20000000000000;
(max_int + 1) === 0x20000000000000;  //true
(max_int - 1) < 0x20000000000000;    //true

Int32 के लिए भी

var max_int32 =  0x80000000;
var min_int32 = -0x80000000;

Answer 16

आइये जाने सूत्रों को

विवरण

MAX_SAFE_INTEGERनिरंतर की एक मूल्य है 9007199254740991(9,007,199,254,740,991 या ~ 9 क्वाड्रिलियन)। उस संख्या के पीछे तर्क यह है कि जावास्क्रिप्ट आईईईई 754 में निर्दिष्ट डबल-सटीक फ़्लोटिंग-पॉइंट प्रारूप संख्याओं का उपयोग करता है और केवल सुरक्षित रूप से और नंबरों के लिए सुरक्षित रूप से उपयोग कर सकता है-(2^53 - 1)2^53 - 1 ।

इस संदर्भ में सुरक्षित पूर्णांक का प्रतिनिधित्व करने और उनकी तुलना सही ढंग से करने की क्षमता को दर्शाता है। उदाहरण के लिए, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2सत्य का मूल्यांकन करेगा, जो गणितीय रूप से गलत है। नंबर देखें .isSafeInteger () अधिक जानकारी के लिए।

क्योंकि संख्याMAX_SAFE_INTEGER की एक स्थिर संपत्ति है , आप हमेशा इसका उपयोग उस संख्या के रूप में करते हैं Number.MAX_SAFE_INTEGER, न कि आपके द्वारा बनाई गई संख्या ऑब्जेक्ट की संपत्ति के रूप में ।

ब्राउज़र संगतता

Answer 17

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

Comments

Math.pow (आधार, घातांक)

— jkdev

Answer 18

जावास्क्रिप्ट में संख्याओं का प्रतिनिधित्व है 2^53 - 1 ।

हालांकि , Bitwise operationपर गणना की जाती है 32 bits ( 4 bytes ), जिसका अर्थ है कि यदि आप 32 बिट्स पार करते हैं तो आप बिट्स खोना शुरू कर देंगे।

Answer 19

स्कोटो वॉट्स:

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

कंसोल आपको बताएगा कि 0x80000000 बराबर [phone], लेकिन 0x80000000 और 0x80000000 बराबर -2147483648

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

Answer 20

फ़ायरफ़ॉक्स 3 में भारी संख्या के साथ कोई समस्या नहीं है।

1e + 200 * 1e + 100 ठीक 1e + 300 की गणना करेगा।

लगता है कि सफारी को इससे कोई समस्या नहीं है। (रिकॉर्ड के लिए, यह एक मैक पर है अगर कोई और इसका परीक्षण करने का फैसला करता है।)

जब तक मैंने दिन के इस समय अपना मस्तिष्क नहीं खो दिया, यह 64-बिट पूर्णांक से बड़ा है।

Comments

इसका 64 बिट पूर्णांक नहीं है, इसकी 64-बिट फ्लोटिंग पॉइंट संख्या है, जिसमें से 52/53 बिट्स पूर्णांक भाग हैं। तो यह 1e300 तक चलेगा, लेकिन सटीक सटीकता के साथ नहीं।

— जिम्मी

जिमी सही है। इसे अपने ब्राउज़र या JS कमांड लाइन में आज़माएँ:100000000000000010 - 1 => 100000000000000020

— रयान

Answer 21

Node.js और Google Chrome दोनों ही 1024 बिट फ्लोटिंग पॉइंट वैल्यू का उपयोग कर रहे हैं:

Number.MAX_VALUE = 1.7976931348623157e+308

Comments

-1: अधिकतम प्रतिनिधित्व योग्य (गैर-सटीक अभिन्न) संख्या ~ 2 ^ 1024 हो सकती है, लेकिन इसका मतलब यह नहीं है कि वे IEEE-754 64 - बिट मानक से भटक रहे हैं ।

— रॉय टिंकर

MAX_INT? क्या आपका मतलब MAX_VALUE है?

— राउल गुईउ

यह एक अस्थायी बिंदु मान की अधिकतम है । इसका मतलब यह नहीं है कि आप एक इंट

— लॉन्ग फुलव्यू

या बात करने के लिए अधिक है, तो आप नहीं कर सकते हैं मज़बूती से एक पूर्णांक है कि लंबे समय तक स्टोर सटीकता की हानि के बिना । 2^53के रूप में संदर्भित किया जाता है MAX_SAFE_INTक्योंकि उस बिंदु के ऊपर मान सन्निकटन बन जाते हैं, उसी तरह से भिन्न होते हैं।

— IMSoP