Яке найвище ціле значення JavaScript, на яке може перейти число, не втрачаючи точності?


951

Чи визначено це мовою? Чи є визначений максимум? Чи відрізняється вона в різних браузерах?


5
Вам не потрібно залежати від обмежень JS з такими бібліотеками, як github.com/MikeMcl/big.js , дивіться, наприклад, його тести на надійність
Дмитро Зайцев,

2
яке найвище ціле значення, яке ви можете використовувати з big.js?
Джордж

@George Ось API для big.js: mikemcl.github.io/big.js/#dp
simhumileco

Питання не має сенсу. Що означає, що число "переходить до" цілого значення? Якщо ви просто хочете запитати, яке найбільше ціле число ви можете представляти в JS, саме найвище (кінцеве) число - це ціле число.
Векі

@DmitriZaitsev Нам більше не потрібно залежати від зовнішніх бібліотек (принаймні, у деяких браузерах). 1n << 10000nце дійсно, дійсно велике ціле число, не втрачаючи жодної точності, не вимагаючи ніяких залежностей (і, що говорити не потрібно, навіть близько до межі).
Амадан

Відповіді:


867

JavaScript має два типи чисел: Numberі BigInt.

Тип найбільш часто використовуваного числа Number- це 64-бітове число з плаваючою точкою IEEE 754 .

Найбільшим точним інтегральним значенням цього типу Number.MAX_SAFE_INTEGERє:

  • 2 53 -1, або
  • +/- 9,007,199,254,740,991, або
  • дев'ять квадрильйонів сім трильйонів сто дев'яносто дев'ять мільярдів двісті п'ятдесят чотири мільйони сімсот сорок тисяч дев'ятсот дев'яносто один

Якщо говорити про це в перспективі: один квадрильйон байт - це петабайт (або тисяча терабайт).

"Безпечний" у цьому контексті означає здатність точно представляти цілі числа та правильно їх порівнювати.

З специфікації:

Зауважимо, що всі натуральні і від’ємні цілі числа, величина яких не перевищує 2 53, є типовими для Numberвиду (дійсно, ціле число 0 має два подання, +0 та -0).

Для безпечного використання цілих чисел, більших за це, вам потрібно використовувати BigInt, яке не має верхньої межі.

Зауважте, що побітові оператори та оператори зсуву працюють на 32-бітових цілих числах, тому в цьому випадку максимальне безпечне ціле число становить 2 31 -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.


75
Це здається правильним, але чи є де-небудь де це визначено, а-ля MA MA__INT або Java-Integer.MAX_VALUE?
TALlama

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

13
То яке найменше і найбільше ціле число ми можемо використовувати для забезпечення точності?
Pacerier

38
Можливо, варто відзначити, що в JavaScript не існує фактичного (int). Кожен екземпляр числа є (float) або NaN.
Буряк-Буряк

53
9007199254740992 насправді не є максимальним значенням, останній біт тут вже вважається рівним нулю, і тому ви втратили 1 біт точності. Справжній безпечний номер - 9007199254740991 (Number.MAX_SAFE_INTEGER)
Willem D'Haeseleer

461

> = ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

З довідки :

Number.MAX_VALUE;
Number.MIN_VALUE;


23
Я відредагував питання, щоб бути дещо точнішим щодо того, щоб хотіти максимальних значень цілого числа, а не лише значення максимального числа. Вибачте за плутанину тут.
TALlama

5
Чи гарантовано повернутий результат буде рівним для всіх браузерів?
Pacerier

7
Зауважте, що Number.MIN_VALUEце найменше можливе додатне число. Мері значення (тобто менше , ніж все інше), ймовірно -Number.MAX_VALUE.
Майкл Шепер

34
ES6 представляє Number.MIN_SAFE_INTEGERіNumber.MAX_SAFE_INTEGER
superlukas

2
Тож у такому випадку ми повинні проголосувати відповідь, тому що вона не є актуальною для оновленого питання, чи залишити її, оскільки Пітер Бейлі був правильний у той момент, коли на нього відповіли?
ракетапостійний

112

Це 2 53 == 9 007 199 254 740 992. Це тому, що Numbers зберігаються як плаваюча точка у 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


1
хоч ніколи б не доходити до кінця цього циклу у розумний часовий i += 1000000000
проміжок

2
@ninjagecko, він починається в MAX_INT, тому кінець тут. Також використання i + = 1000000000 перетворить його на нескінченний цикл. Спробуй це.
Тед Бігхем

@TedBigham: Ой, ой, занадто швидко був готовий до цього. Дякую, що виправили мене двічі.
ninjagecko

Дивіться аргумент Джиммі щодо 9,007,199,254,740,991 замість 9,007,199,254,740,992 тут . Це, у поєднанні з моїм спостереженням, здається переконливим.
TJ Crowder

60

У JavaScript є номер, який називається Infinity.

Приклади:

(Infinity>100)
=> true

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

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

Це може бути достатньо для деяких питань щодо цієї теми.


25
Щось говорить про те, що нескінченність не сприймається як ціле число. :)
devios1

7
Але це досить добре, щоб ініціалізувати minзмінну, коли ви шукаєте мінімальне значення.
djjeck

9
Зауважимо, щоInfinity - 1 === Infinity
Х.Волпер

2
також (Infinity <100) => false and Math.pow (2,1024) === Infinity
Sijav

6
Крім того, нічого не варто, що він також справляється з негативною Нескінченністю. Отже1 - Infinity === -Infinity
dmccabe

41

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

console.log(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);


8
@ CoolAJ86: Лол, я з нетерпінням чекаю 15 березня 2040 року. Якщо наші номери збігаються, ми повинні організувати вечірку :)
Briguy37

var x = Math.pow (2,53) -3; while (x! = x + 1) x ++; -> 9007199254740991
MickLH

@MickLH: Я отримую 9007199254740992 з цим кодом . Який двигун JavaScript ви використовуєте для тестування?
Briguy37

Ви отримуєте 9007199254740992 з власним кодом, я використовував не кінцеве значення x, а остаточне евакуацію x ++ з параноїдальних причин. Google Chrome btw.
MickLH

@MickLH: оцінка x++дає вам значення x до того, як приріст відбувся, так що, ймовірно, пояснює невідповідність. Якщо ви хочете, щоб вираз оцінювався так само, як кінцеве значення х, слід змінити його на ++x.
peterflynn

32

Щоб бути в безпеці

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

4
хіба ти можеш просто запустити його з 2 ^ 53 - 2 для тестування? (так ви можете, я просто спробував це, навіть з -3, щоб бути безпечним: var x = Math.pow (2,53) -3; в той час, як (x! = x + 1) x ++;) -> 9007199254740991
MickLH

Гарна відповідь! Більше того, я знаю, що значення є врегульованим, але чому б не використати двійковий пошук для його знаходження?
higuaro

1
Що у цьому веселого? Крім того, @ Briguy37 бити мене до нього: stackoverflow.com/a/11639621/151312
CoolAJ86

зауважте, що цей "безпечний" MAX_INT на основі 32 біт не працюватиме при порівнянні зі значеннями дати. 4294967295 так вчора!
Джеррі

1
Відповідь "Безпечно: var MAX_INT = 4294967295;" не жартівлива. Якщо ви не бітсіффітінг, не хвилюйтеся з цього приводу (якщо вам не потрібен внутрішній розмір, більший за 4294967295; в цьому випадку ви, ймовірно, повинні зберігати його як рядок і використовувати бібліотеку bigint).
CoolAJ86

29

Коротка відповідь - "це залежить".

Якщо ви використовуєте побітові оператори де завгодно (або якщо ви маєте на увазі довжину масиву), діапазони:

Без підпису: 0…(-1>>>0)

Підписано: (-(-1>>>1)-1)…(-1>>>1)

(Буває так, що побітові оператори та максимальна довжина масиву обмежені 32-бітовими цілими числами.)

Якщо ви не використовуєте побітові оператори або не працюєте з довжиною масиву:

Підписано: (-Math.pow(2,53))…(+Math.pow(2,53))

Ці обмеження накладаються внутрішнім представленням типу «Число», яке, як правило, відповідає IEEE 754 з подвоєним представленням з плаваючою комою. (Зауважте, що на відміну від типово підписаних цілих чисел, величина від'ємної межі така ж, як і величина позитивної межі, завдяки характеристикам внутрішнього подання, що фактично включає від'ємне 0!)


Це відповідь, яку я хотів натрапити на те, як перетворити X на 32-бітове ціле чи непідписане ціле число. За це відповів.
Charlie Affumigato

29

ECMAScript 6:

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

1
Остерігайтесь, що це не (ще) не підтримується всіма браузерами! Сьогодні iOS (навіть не хром), Safari та IE це не люблять.
Крего

5
Будь ласка, уважно прочитайте відповідь, ми не використовуємо реалізацію за замовчуванням Number.MAX_SAFE_INTEGER в ECMAScript 6, ми визначаємо її Math.pow (2, 53) -1
WaiKit Kung

Я подумав, що це лише посилання на те, як це реалізується в ECMA 6! : Я думаю, що мій коментар все ще дійсний. Все питання контексту. ;)
Крегокс

3
Чи надійно проводити розрахунок MAX_SAFE_INTEGERу всіх браузерах, працюючи назад? Чи замість цього рухатись вперед? Тобто, число.MAX_SAFE_INTEGER = 2 * (Math.pow (2, 52) - 1) + 1;
kjv

Чи Math.pow(2, 53)-1безпечна операція? Це одне велике, ніж найбільше безпечне ціле число.
ioquatix

21

Багато відповідей від раніше показали результат 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 --| 

Тепер ми отримуємо 9 007 199 254 740 992 , і число, яке перевищує його, може містити формат у 2 рази долі , це означає, що кожне 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 (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 : (Детальніше просимо туди)

Формат подвійної плаваючої точки IEEE 754.svg

введіть тут опис зображення

Отже, щоб скласти частину експонента 2 ^ 52, нам точно потрібно встановити e = 1075.


13

Інші, можливо, вже дали загальну відповідь, але я подумав, що було б хорошою ідеєю дати швидкий спосіб її визначення:

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

Що дає мені 9007199254740992 менше, ніж мільйсекунда в Chrome 30.

Він перевірить сили 2, щоб знайти, який із них, коли "додано" 1, дорівнює самому собі.


Це може зламати вашу програму, подумала.
Sapphire_Brick

8

Все, що ви хочете використовувати для побітових операцій, має бути між 0x80000000 (-2147483648 або -2 ^ 31) та 0x7fffffff (2147483647 або 2 ^ 31 - 1).

На консолі буде сказано, що 0x80000000 дорівнює +2147483648, але 0x80000000 & 0x80000000 дорівнює -2147483648.


6

Спробуйте:

maxInt = -1 >>> 1

У Firefox 3.6 це 2 ^ 31 - 1.


2
@danorton: Я не впевнений, що ти розумієш, що ти робиш. ^засоби, підняті до влади . У консолі javascript ^знаходиться XOR , не піднімається до
kumarharsh

2
відкрити консоль Chrome / Firefox. Тип 5 ^ 2. У двійковій 5 є 101і 2 є 010. Тепер, якщо ви їх побіжно XOR, ви отримаєте 5(101) ^ 2(010) = 7(111) ПРОЧИТАТИ ЦЕ, якщо ви збентежені. Що тут обговорюється, це Math.pow()не ^оператор
kumarharsh

3
Знову ж таки, я зовсім не розгублений. Я прокоментував і спростував те, що написано . Якщо Math.pow () - це те, що мається на увазі, то саме так слід писати. У відповіді на запитання про JavaScript недоцільно використовувати синтаксис іншої мови. Ще недоцільніше використовувати синтаксис, який дійсний у JavaScript, але з інтерпретацією в JavaScript, який має інше значення, ніж те, що призначено.
danorton

10
2 ^ 31 - це те, як англійська пише два з тридцять першою силою англійською мовою. Це не в блоці коду. Ви б скаржилися на те, що хтось використовує; у відповідь, тому що це символ з іншим значенням у Javascript?
lmm

3
Навіть незважаючи на те, що в простому тексті слід писати 2³ not, а не 2 ^ 31 , тому що для більшості розкладок клавіатури за замовчуванням немає цих символів. Принаймні у мене не було проблем із розумінням того, що малося на увазі у цій відповіді.
Jocke

6

На момент написання, JavaScript отримує новий тип даних: BigInt. Пропозиція TC39 на етапі 4 повинна бути включена в EcmaScript 2020 . BigIntдоступний у Chrome 67+, FireFox 68+, Opera 54 та Node 10.4.0. Він ведеться в Safari та ін. ... Він вводить числові літерали, що мають суфікс "n", і дозволяє довільну точність:

var a = 123456789012345678901012345678901n;

Точність все одно буде втрачена, звичайно, коли таке число (можливо, ненавмисно) приведене до типу даних про число.

І, очевидно, завжди будуть обмеження точності через обмежену пам’ять і витрати в часі, щоб виділити необхідну пам'ять і виконати арифметику на таких великих числах.

Наприклад, генерація числа зі ста тисячами десяткових цифр затримає помітну затримку до завершення:

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

... але це працює.


4

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

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

1
Зауважте, що 9e15 = 2 ^ 53 (див. Відповідь Джиммі).
Клин

6
9e15 = 9000000000000000. 2 ^ 53 = 9007199254740992. Отже, щоб бути педантичним, 9e15 лише приблизно дорівнює 2 ^ 53 (з двома значущими цифрами).
devios1

@chaiguy В 9000000000000000є 1 значна цифра. у `9007199254740992` є 15 значущих цифр.
Рой Намір

@RoyiNamir Не бажаючи тут починати безглуздий аргумент, але 9000000000000000 має 16 значущих цифр. Якщо ви хочете лише 1, це має бути записано як 9x10 ^ 15.
devios1

1
@chaiguy Ні. 9000000000000000Як є - має 1SF. де 90*10^14є 2. ( sigfigscalculator.appspot.com ) & mathsfirst.massey.ac.nz/Algebra/Decimals/SigFig.htm (нижній розділ)
Royi Namir

3

Я пишу це так:

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;

3

Давайте перейдемо до джерел

Опис

MAX_SAFE_INTEGERКонстанта має значення 9007199254740991(9.007.199.254.740.991 або ~ 9 квадрильйонів). Причина цього числа полягає в тому, що JavaScript використовує подвійну точність цифр формату з плаваючою комою, як зазначено в IEEE 754, і може безпечно представляти числа між -(2^53 - 1)і2^53 - 1 .

Безпечний у цьому контексті означає здатність точно представляти цілі числа та правильно їх порівнювати. Наприклад, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2оцінюватимуть як істинне, що математично неправильно. Для отримання додаткової інформації див. Number.isSafeInteger () .

Оскільки MAX_SAFE_INTEGERстатична властивість Числа , ви завжди використовуєте його як Number.MAX_SAFE_INTEGER, а не як властивість створеного вами об'єкта Числа .

Сумісність браузера

введіть тут опис зображення




-1

Скато розлючений:

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

консоль скаже вам, що 0x80000000 дорівнює +2147483648, але 0x80000000 & 0x80000000 дорівнює -2147483648

Шістнадцяткові десяткові знаки - це непідписані позитивні значення, тому 0x80000000 = 2147483648 - це математично правильно. Якщо ви хочете, щоб це було підписане значення, ви повинні змінити вправо: 0x80000000 >> 0 = -2147483648. Ви також можете написати 1 << 31.


-7

Firefox 3, схоже, не має проблем з величезною кількістю.

1e + 200 * 1e + 100 буде обчислювати штраф до 1e + 300.

Здається, у Сафарі теж немає проблем. (Для запису це на Mac, якщо хтось інший вирішить перевірити це.)

Якщо я не втратив свій мозок в цей час доби, це набагато більше, ніж 64-бітове ціле число.


18
це не 64-бітове ціле число, це 64-бітове число з плаваючою точкою, з яких 52/53 біт - ціла частина. тож він буде обробляти до 1e300, але не з точною точністю.
Джиммі

4
Джиммі правильний. Спробуйте це у своєму браузері або командному рядку JS:100000000000000010 - 1 => 100000000000000020
Райан

-7

Схоже, Node.js та Google Chrome використовують 1024 бітові значення з плаваючою точкою.

Number.MAX_VALUE = 1.7976931348623157e+308

1
-1: максимальне представницьке (неточне інтегральне) число може становити ~ 2 ^ 1024, але це не означає, що вони відхиляються від стандарту IEEE-754 64- біт.
Рой Тінкер

2
MAX_INT? Ви маєте на увазі MAX_VALUE?
Рауль Гую

3
це максимальне значення з плаваючою комою . Це не означає, що можна довго зберігати int
phuclv

1
Або ще більше, ви не зможете надійно зберігати інтернету так довго, не втрачаючи точності . 2^53називається тому, MAX_SAFE_INTщо вище цієї точки значення стають наближеннями, так само як і дроби.
IMSoP
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.