これは言語によって定義されていますか？定義された最大値はありますか？ブラウザによって異なりますか？

JavaScriptにはNumber、およびの2つの数値タイプがありBigIntます。

最も頻繁に使用される数値タイプNumberは、64ビット浮動小数点IEEE 754数値です。

このタイプの最大の正確な積分値はNumber.MAX_SAFE_INTEGERです。

• 2 ⁵³ -1、または
• +/- 9,007,199,254,740,991、または
• 9兆7兆999億9400万254億7400万999 911

これを全体的に見ると、1兆バイトは1ペタバイト（または1000テラバイト）です。

この文脈での「安全」とは、整数を正確に表し、それらを正しく比較する機能を指します。

スペックから：

絶対値が2 ⁵³以下のすべての正および負の整数は、Number型で表現可能であることに注意してください（実際、整数0には+0と-0の2つの表現があります）。

これより大きい整数を安全に使用するに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のどちらをエンコードしているかが不明確であるため、不正確なものとして扱う必要があります。

> = ES6：

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

参照から：

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です。これは、Numbersが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のデモ）。

console.log(9007199254740993);

ただし、これをプログラムで発見/証明する回答はありません（28.56 年で終了する彼の回答で言及された CoolAJ86以外は）;したがって、これを行うには少し効率的な方法があります（正確には、より効率的です）約28.55999999996 8312年までに:)、テストフィドルとともに：

/**
 * 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、より実用的なアプローチでその価値を見つけました。

私のマシンは1秒あたり1,000万個しかカウントできません。そのため、私は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);
}());

簡単に言えば、「状況によります」です。

ビット演算子をどこかで使用している場合（または配列の長さを参照している場合）、範囲は次のとおりです。

署名なし： 0…(-1>>>0)

署名： (-(-1>>>1)-1)…(-1>>>1)

（たまたま、ビットごとの演算子と配列の最大長が32ビット整数に制限されています。）

ビットごとの演算子を使用していない場合、または配列の長さを使用していない場合：

署名： (-Math.pow(2,53))…(+Math.pow(2,53))

これらの制限は、「Number」タイプの内部表現によって課せられます。これは、一般にIEEE 754倍精度浮動小数点表現に対応しています。（通常の符号付き整数とは異なり、実際には負の 0を含む内部表現の特性により、負の制限の大きさは正の制限の大きさと同じであることに注意してください。）

ECMAScript 6：

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

以前の多くの回答は、9 007 199 254 740 991が最大かつ安全な整数trueである9007199254740992 === 9007199254740992 + 1ことを確認するという結果を示しています。

蓄積を続けたらどうなるでしょう：

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を累積し始めます。これは、10進数で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より多くの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倍で、それはなぜだと、今小数部分、実際に2加算に等しい上のすべての1件の追加を意味し、二重-precision 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分の1の分数だけです。

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倍を表すのに使用できるビットが1つあります。

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に設定する必要があります。

他の人はすでに一般的な答えを与えているかもしれませんが、それを決定するための迅速な方法を与えることは良い考えだと思いました：

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

Chrome 30では、ミリ秒未満で9007199254740992が得られます。

2の累乗をテストして、「1」を追加したときにどれが自分自身に等しいかを見つけます。

ビット演算に使用するものはすべて、0x80000000（-2147483648または-2 ^ 31）〜0x7fffffff（2147483647または2 ^ 31-1）の間でなければなりません。

コンソールには、0x80000000は+2147483648と等しいが、0x80000000＆0x80000000は-2147483648と等しいことが表示されます。

試してください：

maxInt = -1 >>> 1

Firefox 3.6では2 ^ 31-1です。

執筆の時点で、JavaScriptは新しいデータ型を受け取っています：BigInt。EcmaScript 2020に含まれるのは、ステージ4の TC39提案です。Chrome 67以降、FireFox 68以降、Opera 54、Node 10.4.0で利用できます。Safariなどで進行中です...「n」サフィックスを持つ数値リテラルを導入し、任意の精度を可能にします。BigInt

var a = 123456789012345678901012345678901n;

もちろん、そのような数値が（おそらく意図せずに）数値データ型に強制変換された場合でも、精度は失われます。

そして、明らかに、有限のメモリと、必要なメモリを割り当ててそのような大きな数で演算を実行するための時間の面でのコストにより、常に精度の制限があります。

たとえば、10進数で10桁の数値を生成すると、完了するまでにかなりの遅延が発生します。

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

...しかし、動作します。

X-（X + 1）=-1という数式を使用して簡単なテストを行いました。XIの最大値はSafari、Opera、Firefox（OS Xでテスト済み）で機能するために9e15です。テストに使用したコードは次のとおりです。

javascript: alert(9e15-(9e15+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;

ソースに行きましょう

説明

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はtrueと評価されますが、これは数学的に正しくありません。詳細については、Number.isSafeInteger（）を参照してください。

MAX_SAFE_INTEGERはNumberの静的プロパティであるため、作成しNumber.MAX_SAFE_INTEGERたNumberオブジェクトのプロパティとしてではなく、常にとして使用します。

ブラウザの互換性

Google Chromeの組み込みJavaScriptでは、番号が無限大と呼ばれる前に約2 ^ 1024に到達できます。

JavaScriptでは、数値の表現はです2^53 - 1。

ただし、Bitwise operationで計算されます32 bits ( 4 bytes )。つまり、32ビットシフトを超えると、ビットが失われます。

Scatoは書きました：

ビット演算に使用するものはすべて、0x80000000（-2147483648または-2 ^ 31）〜0x7fffffff（2147483647または2 ^ 31-1）の間でなければなりません。

コンソールは、0x80000000は+2147483648と等しいが、0x80000000＆0x80000000は-2147483648と等しいことを通知します

16進数は符号なしの正の値なので、0x80000000 = 2147483648-数学的に正しい。符号付きの値にしたい場合は、右シフトする必要があります：0x80000000 >> 0 = -2147483648。代わりに1 << 31と書くこともできます。

Firefox 3は膨大な数の問題を抱えているようには見えません。

1e + 200 * 1e + 100は1e + 300まで細かく計算されます。

Safariも問題ないようです。（記録のために、誰かがこれをテストすることを決定した場合、これはMac上にあります。）

この時間に脳を失っていない限り、これは64ビット整数よりもはるかに大きいです。

Node.jsとGoogle Chromeはどちらも1024ビットの浮動小数点値を使用しているようです。

Number.MAX_VALUE = 1.7976931348623157e+308