Was ist der höchste ganzzahlige Wert in JavaScript, den eine Zahl erreichen kann, ohne an Präzision zu verlieren?

Question

Ist dies in der Sprache festgelegt? Gibt es ein bestimmtes Maximum? Ist es in verschiedenen Browsern unterschiedlich?

Answer 1

Jimmys Antwort stellt das kontinuierliche JavaScript-Ganzzahlenspektrum korrekt dar als -9007199254740992 à 9007199254740992 inklusive (sorry 9007199254740993, Sie denken vielleicht, dass Sie 9007199254740993 sind, aber Sie liegen falsch! Demonstration unten oder in jsfiddle ).

console.log(9007199254740993);

Es gibt jedoch keine Antwort, die dies programmatisch findet/beweist (außer der, auf die CoolAJ86 in seine Antwort das würde in 28,56 Jahren enden ;), also hier ist ein etwas effizienterer Weg, das zu tun (um genau zu sein, ist es um etwa 28,559999999968312 Jahre effizienter :), zusammen mit einer Testfiedel :

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

Answer 2

Um sicher zu sein

var MAX_INT = 4294967295;

Begründung

Ich dachte, ich wäre schlau und würde den Wert finden, bei dem x + 1 === x mit einem eher pragmatischen Ansatz.

Meine Maschine kann nur 10 Millionen pro Sekunde oder so zählen... also werde ich mich in 28,56 Jahren mit der endgültigen Antwort zurückmelden.

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

• Die meisten Ihrer Schleifen laufen nicht 28,56 Jahre lang
• 9007199254740992 === Math.pow(2, 53) + 1 ist Beweis genug
• Sie sollten sich an 4294967295 das ist Math.pow(2,32) - 1 um zu erwartende Probleme mit der Bitverschiebung zu vermeiden

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

Answer 3

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

Wenn Sie irgendwo bitweise Operatoren verwenden (oder wenn Sie sich auf die Länge eines Arrays beziehen), sind die Bereiche:

Unsigniert: 0…(-1>>>0)

Unterschrieben: (-(-1>>>1)-1)…(-1>>>1)

(Zufällig sind die bitweisen Operatoren und die maximale Länge eines Arrays auf 32-Bit-Ganzzahlen beschränkt).

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

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

Diese Einschränkungen ergeben sich aus der internen Darstellung des Typs "Zahl", die im Allgemeinen der IEEE 754-Doppelpräzisions-Gleitkommadarstellung entspricht. (Beachten Sie, dass im Gegensatz zu typischen vorzeichenbehafteten Ganzzahlen der Betrag der negativen Grenze derselbe ist wie der Betrag der positiven Grenze, was auf die Eigenschaften der internen Darstellung zurückzuführen ist, die tatsächlich eine negativ 0!)

Answer 4

ECMAScript 6:

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

Answer 5

Andere haben vielleicht schon die allgemeine Antwort gegeben, aber ich dachte, es wäre eine gute Idee, eine schnelle Möglichkeit zur Bestimmung zu geben:

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

Damit erhalte ich 9007199254740992 in weniger als einer Millisekunde in Chrome 30.

Er testet Potenzen von 2, um herauszufinden, welche Potenz, wenn man 1 "addiert", sich selbst entspricht.