我用一个公式做了一个简单的测试，X-(X+1)=-1，我在Safari、Opera和Firefox(在OS X上测试)上可以得到的X的最大值是9e15。下面是我用于测试的代码:

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

JavaScript有两种数字类型:number和BigInt。

最常用的数字类型是一个64位浮点IEEE 754数字。

这种类型的最大精确整数值是Number。MAX_SAFE_INTEGER，即:

253 - 1 +/- 9,007,199,254,740,991，或 九千亿亿七千亿九千九百零五十四万四千九百九十一

从这个角度来看:1千万亿字节是1拍字节(或1千兆字节)。

在此上下文中，“安全”指的是准确表示整数并正确比较它们的能力。

来自规范:

注意所有大小为no的正整数和负整数 在Number类型中可以表示大于253的 整数0有两种表示，+0和-0)。

为了安全地使用大于此值的整数，您需要使用BigInt，它没有上界。

注意，位操作符和移位操作符作用于32位整数，因此在这种情况下，最大安全整数是231-1，即2,147,483,647。

Const log = console.log Var x = 9007199254740992 Var y = -x Log (x == x + 1) // true ! Log (y == y - 1) //也成立! //算术运算符有效，但位/移位只对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进行编码是不明确的。

我用一个公式做了一个简单的测试，X-(X+1)=-1，我在Safari、Opera和Firefox(在OS X上测试)上可以得到的X的最大值是9e15。下面是我用于测试的代码:

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

要用于位操作的任何值必须在0x80000000(-2147483648或-2^31)和0x7fffffff(2147483647或2^31 - 1)之间。

控制台会告诉您0x80000000等于+2147483648，但是0x80000000 & 0x80000000等于-2147483648。

ECMAScript 6:

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

许多先前的答案显示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和一个相邻的基数点。通过消耗左边的指数部分，基数点向右移动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)

  1 . 0000 ---- 0000  *  2^52 * 2  =>  1  0000 ---- 0000. * 2  
     |-- 52 bits --|                     |-- 52 bits --|
                                      (By consuming the 2^52, radix
                                       point has no way to go, but
                                       there is still one 2 left in
                                       exponent part)
  =>  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  --|

0.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
/**
   Please note that if you try this yourself and, say, log 
   these numbers to the console, they will get rounded. JavaScript
   rounds if the number of digits exceed 17. The value 
   is internally 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位。

来自维基百科(欲了解更多细节，请访问那里)

为了使指数部分等于2^52，我们需要令e = 1075。