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

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

=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

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

尝试：

在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

---

进一步阅读：

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

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

未签名：

0…（-1>>0）

签名：

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

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

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

签名：

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

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

为了安全起见 推理 我想我会很聪明，用更务实的方法找到

x+1===x

的值

我的机器每秒只能数1000万左右。。。因此，我将在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);
}());

---

在Google Chrome内置的javascript中，在这个数字被称为infinity之前，你可以移动到大约2^1024。

在javascript中，有一个数字被称为

infinity

示例：

(Infinity>100)
=> true

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

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

---

这可能足以回答有关此主题的一些问题。

要用于位运算的任何内容必须介于0x8000000（-2147483648或-2^31）和0x7fffffff（2147483647或2^31-1）之间

控制台将告诉您0x80000000等于+2147483648，但0x80000000和0x80000000等于-2147483648。

正确地将连续JavaScript整数谱表示为-9007199254740992到9007199254740992（抱歉9007199254740993，您可能认为您是9007199254740993，但您错了！ 下面或里面的演示）

---

console.log（9007199254740993）；

Node.js和Google Chrome似乎都在使用1024位浮点值，因此：

Number.MAX_VALUE = 1.7976931348623157e+308

---

其他人可能已经给出了一般性的答案，但我认为最好给出一种快速确定答案的方法：

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

在Chrome 30中，在不到一毫秒的时间内，我得到了9007199254740992

它将测试2的幂，以确定当“添加”1时，哪一个等于他自己。

ECMAScript 6:

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

斯卡托·沃特斯：

要用于位运算的任何内容都必须介于 0x8000000（-2147483648或-2^31）和0x7fffffff（2147483647或2^31- 1）

控制台将告诉您0x8000000等于+2147483648，但是 0x8000000和0x8000000等于-2147483648

十六进制小数是无符号正值，因此0x8000000=2147483648-这在数学上是正确的。如果要使其成为有符号值，必须右移：0x8000000>>0

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)