什么是JavaScript'；一个数字在不损失精度的情况下可以达到的最大整数值是多少？

这是由语言定义的吗？是否有定义的最大值？在不同的浏览器中是否不同？

=ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

---

=ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

---

JavaScript有两种数字类型：和

最常用的数字类型是64位浮点数，

number

此类型的最大精确积分值为，即：

• 253-1，或
• +/-9007199254740991，或
• 玖亿肆仟柒万亿壹仟玖佰玖拾玖亿贰仟伍佰肆拾肆万柒仟玖佰玖拾壹

从这个角度来看：1万亿字节等于1 PB（或1000 TB）

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

请注意，大小为no的所有正整数和负整数 大于253的可表示为

编号

类型（事实上 整数0有两种表示形式，+0和-0）

要安全地使用大于此值的整数，需要使用，它没有上限

请注意，按位运算符和移位运算符对32位整数进行运算，因此在这种情况下，最大安全整数为231-1或2147483647

const log=console.log
变量x=9007199254740992
变量y=-x
log（x==x+1）//真！
log（y==y-1）//也是真的！
//算术运算符工作，但按位/移位仅在int32上工作：
日志（x/2）//4503599627370496
日志（x>>1）//0
log（x | 1）//1

JavaScript有两种数字类型：和

最常用的数字类型是64位浮点数，

number

此类型的最大精确积分值为，即：

• 253-1，或
• +/-9007199254740991，或
• 玖亿肆仟柒万亿壹仟玖佰玖拾玖亿贰仟伍佰肆拾肆万柒仟玖佰玖拾壹

从这个角度来看：1万亿字节等于1 PB（或1000 TB）

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

请注意，大小为no的所有正整数和负整数 大于253的可表示为

编号

类型（事实上 整数0有两种表示形式，+0和-0）

要安全地使用大于此值的整数，需要使用，它没有上限

请注意，按位运算符和移位运算符对32位整数进行运算，因此在这种情况下，最大安全整数为231-1或2147483647

const log=console.log
变量x=9007199254740992
变量y=-x
log（x==x+1）//真！
log（y==y-1）//也是真的！
//算术运算符工作，但按位/移位仅在int32上工作：
日志（x/2）//4503599627370496
日志（x>>1）//0
log（x | 1）//1

Firefox3似乎对庞大的数字没有问题

1e+200*1e+100将计算罚款至1e+300

Safari似乎也没有问题。（为了记录在案，如果其他人决定对此进行测试，这是在Mac上进行的。）

---

除非我在一天中的这个时候失去了理智，否则这个数字要比64位整数大得多。

Firefox3似乎没有大数字的问题

1e+200*1e+100将计算罚款至1e+300

Safari似乎也没有问题。（为了记录在案，如果其他人决定对此进行测试，这是在Mac上进行的。）

---

除非我在一天中的这个时候失去了理智，否则这比一个64位整数要大得多。

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

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

---

我用一个公式做了一个简单的测试，X-（X+1）=-1，在Safari、Opera和Firefox（在OSX上测试）上我能得到的最大X值是9e15。以下是我用于测试的代码：

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

尝试：

在Firefox3.6中是2^31-1。

试试：

在Firefox3.6中是2^31-1。

是253==9 007 199 254 740 992。这是因为

Number

s以浮点形式存储在52位尾数中

最小值为-253

这让一些有趣的事情发生了

Math.pow(2, 53) == Math.pow(2, 53) + 1
>> true

也可能是危险的：）

var MAX_INT=Math.pow（2,53）；//9 007 199 254 740 992
对于（变量i=MAX_INT；i

进一步阅读：

它是253==9 007 199 254 740 992。这是因为

Number

s以浮点形式存储在52位尾数中

最小值为-253

这让一些有趣的事情发生了

Math.pow(2, 53) == Math.pow(2, 53) + 1
>> true

也可能是危险的：）

var MAX_INT=Math.pow（2,53）；//9 007 199 254 740 992
对于（变量i=MAX_INT；i

---

进一步阅读：

简短的回答是“视情况而定”

如果您在任何位置使用位运算符（或如果您指的是数组的长度），则范围为：

未签名：

0…（-1>>0）

签名：

（-1>>1）-1）.（-1>>1）

（按位运算符和数组的最大长度限制为32位整数。）

如果不使用位运算符或不使用数组长度：

签名：

（-Math.pow（2,53））…（+Math.pow（2,53））

这些限制是由“数字”类型的内部表示施加的，该类型通常对应于IEEE 754双精度浮点表示。（注意，与典型的有符号整数不同，由于内部表示的特性，负极限的大小与正极限的大小相同，内部表示实际上包括一个否定

var MAX_INT = 4294967295;

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

(Infinity>100)
=> true

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

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

Number.MAX_VALUE = 1.7976931348623157e+308

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

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

var max_int = 0x20000000000000;
var min_int = -0x20000000000000;
(max_int + 1) === 0x20000000000000;  //true
(max_int - 1) < 0x20000000000000;    //true

var max_int32 =  0x80000000;
var min_int32 = -0x80000000;

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

  1 . 0000 ---- 0000  *  2^52            =>  1  0000 ---- 0000.  
     |-- 52 bits --|    |exponent part|        |-- 52 bits --|

  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. 

  ┏━━▶ 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 --| 

                            (consume 2^52 to move radix point to the end)
  1 . 0000 ---- 0001  *  2^53  =>  1  0000 ---- 0001.  *  2
     |-- 52 bits --|                 |-- 52 bits --|

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

 1 . 0000 ---- 0001  *  2^51  =>  1 0000 ---- 000.1
     |-- 52 bits --|                |-- 52 bits  --|

input: 4503599627370495.5   output: 4503599627370495.5  
input: 4503599627370495.75  output: 4503599627370495.5  
            

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"

var a = 123456789012345678901012345678901n;

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