Frage Was ist der höchste Integer-Wert von JavaScript, zu dem eine Zahl gehen kann, ohne die Genauigkeit zu verlieren?


Ist das durch die Sprache definiert? Gibt es ein definiertes Maximum? Ist es in verschiedenen Browsern anders?


798
2017-11-20 22:47


Ursprung


Antworten:


+/- 9007199254740991

ECMA Abschnitt 8.5 - Nummern

Beachten Sie, dass alle positiven und negativen ganzen Zahlen, deren Größe nicht größer als 2 ist53 sind im Number-Typ darstellbar (tatsächlich hat die Integer-Zahl 0 zwei Repräsentationen, +0 und -0).

Sie sind 64-Bit Fließkommawerte, der größte exakte Integralwert ist 253-1 oder 9007199254740991. In ES6 ist dies definiert als Nummer.MAX_SAFE_INTEGER.

Beachten Sie, dass die bitweisen Operatoren und Shift-Operatoren mit 32-Bit-Ints arbeiten. In diesem Fall ist die maximale sichere Ganzzahl also 231-1 oder 2147483647.


Probieren Sie es aus!

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

727
2017-11-20 22:53



> = ES6: Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER;

<= ES5

Von die Referenz: 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


404
2017-11-20 22:52



Es ist 253 == 9 007 199 254 740 992. Dies ist, weil Numbers werden als Fließkomma in einer 52-Bit-Mantisse gespeichert.

Der Mindestwert ist -253.

Dies macht einige lustige Dinge passieren

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

Und kann auch gefährlich sein :)

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
}

Weiterführende Literatur: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html


101
2017-12-07 10:40



In JavaScript gibt es eine Nummer namens Infinity.

Beispiele:

(Infinity>100)
=> true

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

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

Dies kann für einige Fragen zu diesem Thema ausreichend sein.


53
2018-01-20 21:42



Jimmys Antwort stellt das kontinuierliche JavaScript-Ganzzahlspektrum als korrekt dar -9007199254740992 zu 9007199254740992 inklusive (Entschuldigung 9007199254740993, Sie könnten denken, Sie sind 9007199254740993, aber Sie haben sich geirrt!   Demonstration unter oder in jsfiddle).

document.write(9007199254740993);

Es gibt jedoch keine Antwort, die dies programmatisch findet / beweist (abgesehen von der, auf die in CoolAJ86 hingewiesen wird) seine Antwort das würde in 28,56 Jahren enden;), also hier ist eine etwas effizientere Art und Weise zu tun (um genau zu sein, es ist effizienter um etwa 28.559999999968312 Jahre :), zusammen mit einem Testgeige:

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


37
2017-07-24 21:30



Sicher sein

var MAX_INT = 4294967295;

Argumentation

Ich dachte, ich wäre schlau und finde den Wert, an dem es liegt x + 1 === x mit einem pragmatischeren Ansatz.

Mein Rechner kann nur 10 Millionen pro Sekunde zählen ... also werde ich in 28,56 Jahren mit der definitiven Antwort antworten.

Wenn Sie nicht so lange warten können, bin ich bereit, darauf zu wetten

  • Die meisten Ihrer Loops laufen nicht für 28,56 Jahre
  • 9007199254740992 === Math.pow(2, 53) + 1 ist Beweis genug
  • Sie sollten dabei bleiben 4294967295 welches ist Math.pow(2,32) - 1 um zu erwartende Probleme mit Bit-Shifting zu vermeiden

Finden 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);
}());

32
2017-08-24 17:29



ECMAScript 6:

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

28
2018-03-31 05:52



Die kurze Antwort lautet: "Es kommt darauf an."

Wenn Sie an beliebiger Stelle bitweise Operatoren verwenden (oder wenn Sie die Länge eines Arrays angeben), lauten die Bereiche:

Ohne Vorzeichen: 0…(-1>>>0)

Unterzeichnet: (-(-1>>>1)-1)…(-1>>>1)

(Es kommt vor, dass die bitweisen Operatoren und die maximale Länge eines Arrays auf 32-Bit-Ganzzahlen beschränkt sind.)

Wenn Sie keine bitweisen Operatoren verwenden oder mit Array-Längen arbeiten:

Unterzeichnet: (-Math.pow(2,53))…(+Math.pow(2,53))

Diese Einschränkungen werden durch die interne Darstellung des "Zahl" -Typs auferlegt, die im Allgemeinen einer IEEE 754-Gleitkomma-Darstellung mit doppelter Genauigkeit entspricht. (Beachten Sie, dass im Gegensatz zu typischen Ganzzahlen mit Vorzeichen die Größe der negativen Grenze aufgrund der Merkmale der internen Darstellung, die tatsächlich a enthält, der Größe der positiven Grenze entspricht Negativ 0!)


27
2017-07-17 07:13