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

С ссылка: 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

в 2⁵³ == 9 007 199 254 740 992. Это потому что Numberхранятся в виде чисел с плавающей точкой в 52-разрядной мантиссой.

минимальное значение -2⁵³.

Это делает некоторые забавные вещи происходит

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}

в JavaScript есть число под названием Infinity.

примеры:

(Infinity>100)
=> true

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

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

этого может быть достаточно для некоторых вопросов, касающихся этой темы.

Джимми правильно представляет непрерывный целочисленный спектр JavaScript как -9007199254740992 до 9007199254740992 включительно (извините 9007199254740993, вы можете подумать, что вы 9007199254740993, но вы ошибаетесь! демонстрация ниже или в jsfiddle).

document.write(9007199254740993);

однако нет ответа, который находит / доказывает это программно (кроме одного CoolAJ86 говорится в ответ это закончится через 28.56 лет ;), так что вот немного более эффективный способ сделать это (если быть точным, это более эффективно примерно на 28.559999999968312 лет :), а также тест скрипку:

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

на всякий случай

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

ECMAScript 6:

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

короткий ответ: "это зависит."

Если вы используете побитовые операторы в любом месте (или если вы ссылаетесь на длину массива), диапазоны:

без знака:0…(-1>>>0)

подпись: (-(-1>>>1)-1)…(-1>>>1)

(бывает так, что побитовые операторы и максимальная длина массива ограничены 32-разрядными целыми числами.)

Если вы не используете побитовые операторы или рабочие, имеющие длину массива:

подпись: (-Math.pow(2,53))…(+Math.pow(2,53))

эти ограничения накладываются внутренним представлением типа "число", которое обычно соответствует представлению двойной точности с плавающей запятой IEEE 754. (Обратите внимание, что в отличие от типичных целых чисел со знаком, величина отрицательного предела такая же, как и величина положительного предела, из-за характеристик внутреннего представления, которое фактически включает в себя отрицательный 0!)

другие, возможно, уже дали общий ответ, но я подумал, что было бы неплохо дать быстрый способ его определения :

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

что дает мне 9007199254740992 менее чем за миллисекунду в Chrome 30.

он будет проверять полномочия 2, чтобы найти, какой из них, когда "добавлено" 1, равен самому себе.

все, что вы хотите использовать для побитовых операций, должно быть между 0x80000000 (-2147483648 или -2^31) и 0x7fffffff (2147483647 или 2^31 - 1).

консоль скажет вам, что 0x80000000 равно +2147483648, но 0x80000000 & 0x80000000 равно -2147483648.

многие ответы ранее показывают результат 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 have 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 --| 

теперь мы получаем 9 007 199 254 740 992, и с числом больше, чем это, что формат может содержать 2 раза дроби:

                            (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 (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 бит. Полный формат от Wiki: (для более подробной информации, пожалуйста, туда)

поэтому, чтобы получить 2^52 в экспоненциальной части, нам точно нужно установить e = 1075.

Я сделал простой тест с формулой X - (X+1)=-1, и самое большое значение X, которое я могу получить для работы в Safari, Opera и Firefox (протестировано на OS X), - 9e15. Вот код, который я использовал для тестирования:

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

попробуй:

maxInt = -1 >>> 1

в Firefox 3.6 это 2^31 - 1.

Я пишу так:

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;

в Google Chrome встроенный javascript, вы можете перейти к примерно 2^1024, прежде чем число называется бесконечность.

со счето wrotes:

все, что вы хотите использовать для побитовых операций должны быть между 0x80000000 (-2147483648 или -2^31) и 0x7fffffff (2147483647 или 2^31 - 1).

консоль скажет вам, что 0x80000000 равно +2147483648, но 0x80000000 & 0x80000000 равно -2147483648

шестнадцатеричные знаки являются беззнаковыми положительными значениями, поэтому 0x80000000 = 2147483648-это математически правильно. Если вы хотите сделать его подписанным значением, вы придется сдвиг вправо: 0x80000000 > > 0 = -2147483648. Вместо этого вы можете написать 1

количество.Массив представляет максимальное числовое значение, представимое в JavaScript.

поскольку никто, кажется, не сказал так, в v8 двигатель есть разница в поведении 31 bits номер и номер выше.

если у вас 32 bits вы можете использовать первый бит, чтобы сообщить движку javascript, какого типа эти данные, а остальные биты содержат фактические данные. Вот что V8 совсем как маленький оптимизация для 31 bisnumbers (или раньше, Мои источники довольно устарели). У вас есть последний 31 bits будучи числовым значением, а затем первым битом, сообщающим движку, является ли это число или ссылка на объект.

однако, если вы используете номер выше 31 bits тогда данные не будут вписываться, число будет упаковано в 64-битный двойной и оптимизация не будет там.

нижняя строка, в видео ниже, это:

предпочитаю числовые значения, которые могут быть представлен как 31bits подпись целые.

• интересное видео
• другой источник

в основном javascript не поддерживает долго.
поэтому для нормальных значений, которые он может представлять менее 32 бит, он будет использовать контейнер типа int. для целочисленных значений больше, то 32-битная ее использует двойную. В двойной репрезентации целая часть составляет 53 бита, а остальное-мантисса( чтобы сохранить информацию с плавающей запятой).
так что вы можете использовать 2^53 - 1 стоимость которого составляет 9007199254740991
вы можете получить доступ к значению для использования в коде Number.MAX_SAFE_INTEGER

поехали в источник

описание

The MAX_SAFE_INTEGER константа имеет значение 9007199254740991 (9,007,199,254,740,991 или ~9 квадриллионов). Причина этого числа заключается в том, что JavaScript использует двойной точности с плавающей запятой в формате как указано в IEEE 754 и может безопасно представлять только числа между -(253 - 1) и 253 - 1.

Safe в этом контексте относится к возможность точно представлять целые числа и корректно их сравнивать. Например, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 будет оцениваться как true, что математически неверно. Смотрите количество.isSafeInteger () для получения дополнительной информации.

, потому что MAX_SAFE_INTEGER является статическим свойством , вы всегда используете его как Number.MAX_SAFE_INTEGER, а не как свойство объект, который вы создали.

браузер совместимость

Firefox 3, похоже, не имеет проблем с огромными числами.

1e + 200 * 1e + 100 рассчитает штраф до 1e + 300.

Safari, похоже, тоже не имеет проблем с этим. (Для записи, это на Mac, Если кто-то еще решит проверить это.)

Если я потерял мой мозг в это время дня, это намного больше, чем 64-битное целое.

узел.js и Google Chrome, похоже, используют 1024-битные значения с плавающей запятой, поэтому:

Number.MAX_VALUE = 1.7976931348623157e+308