【问题标题】：What is JavaScript's highest integer value that a number can go to without losing precision?JavaScript 在不损失精度的情况下，一个数字可以达到的最高整数值是多少？
【发布时间】：2025-12-23 01:40:12
【问题描述】：

这是由语言定义的吗？有定义的最大值吗？不同浏览器有区别吗？

【问题讨论】：

你不需要依赖 JS 的限制，比如github.com/MikeMcl/big.js，参见例如here for its reliability tests
big.js 可以使用的最大整数值是多少？
@DmitriZaitsev 我们不再需要依赖外部库（至少在某些浏览器上）。 1n << 10000n 是一个非常非常大的整数，不会丢失任何精度，不需要任何依赖项（不用说，甚至没有接近极限）。
@DmitriZaitsev 注意n 后缀。 BigInt 类是 ES2020 规范草案的一部分，已经在大多数浏览器中实现；您可以尝试评估它，例如Chrome 或 Firefox，没有外部库，并获得 3011 位的BigInt。
@DmitriZaitsev：是的，它只适用于整数。这个问题是关于整数的。

标签： javascript math browser cross-browser

【解决方案1】：

JavaScript 有两种数字类型：Number 和 BigInt。

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

该类型的最大精确整数值为Number.MAX_SAFE_INTEGER，即：

2⁵³-1，或
+/- 9,007,199,254,740,991，或
九千万亿七万亿一千九十九亿二亿五千四百四万九百九十一

换个角度来看：一万亿字节是一拍字节（或一千兆兆字节）。

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

From the spec:

注意所有大小为 no 的正整数和负整数大于 2⁵³ 可以在 Number 类型中表示（实际上，整数 0 有两种表示形式，+0 和 -0)。

要安全地使用大于此的整数，您需要使用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 进行编码是不明确的。

【讨论】：

这似乎是对的，但是否有定义它的地方，比如 C 的 MAX_INT 或 Java 的 Integer.MAX_VALUE？
4294967295 === Math.pow(2,32) - 1;
那么我们可以用来确保精确度的最小和最大整数是多少？
也许值得注意的是，javascript 中没有实际的 (int)。 Number 的每个实例都是 (float) 或 NaN。
9007199254740992 并不是真正的最大值，这里的最后一位已经假定为零，因此您失去了一位精度。真正的安全号码是 9007199254740991 ( Number.MAX_SAFE_INTEGER )

【解决方案2】：

>= ES6：

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

来自the reference：

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

【讨论】：

我已经编辑了这个问题，以便更准确地了解想要最大 Integer 值，而不仅仅是最大 Number 值。很抱歉造成混乱，在这里。
返回的结果在所有浏览器上是否保证相等？
请注意，Number.MIN_VALUE 是可能的最小正数数。最小值（即比其他任何值都小）可能是-Number.MAX_VALUE。
这是最大浮点值。问题是关于最高整数值。虽然Number.MAX_VALUE 是一个整数，但您不能在不丢失精度的情况下越过2^53。
ES6 引入了Number.MIN_SAFE_INTEGER 和Number.MAX_SAFE_INTEGER

【解决方案3】：

它是 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}

【讨论】：

虽然在正常的时间范围内永远不会到达 for 循环的结尾，但您不妨说i += 1000000000
@ninjagecko，他从 MAX_INT 开始，所以终点就在那里。同样使用 i+= 1000000000 将使其不再是无限循环。试试看。
@TedBigham：啊，哎呀，准备得太快了。感谢您纠正我两次。
查看 Jimmy 的论点，即 9,007,199,254,740,991 而不是 9,007,199,254,740,992 here。结合我的后续行动，这似乎很有说服力。

【解决方案4】：

在 JavaScript 中，有一个数字叫做Infinity。

例子：

(Infinity>100)
=> true

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

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

对于一些关于这个主题的问题，这可能就足够了。

【讨论】：

某事告诉我无穷大不符合整数的条件。 :)
但是当你在寻找最小值时，初始化一个min变量就足够了。
请注意Infinity - 1 === Infinity
also (Infinity false and Math.pow(2,1024) === Infinity
它也处理负无穷大也毫无价值。所以1 - Infinity === -Infinity

【解决方案5】：

Jimmy's answer 正确地表示连续的 JavaScript 整数谱为 -9007199254740992 到 9007199254740992 包括在内（对不起 9007199254740993，你可能认为你是 9007199254740993，但你错了！ 下面或jsfiddle中的演示）。

console.log(9007199254740993);

但是，没有答案可以以编程方式找到/证明这一点（除了 his answer 中提到的 CoolAJ86 将在 28.56 年内完成；），所以这里有一种更有效的方法（准确地说，它的效率要高出大约 28.559999999968312 年 :) 以及 test fiddle:

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

【讨论】：

@CoolAJ86：大声笑，我期待着 2040 年 3 月 15 日。如果我们的数字匹配，我们应该举办派对 :)
var x=Math.pow(2,53)-3;while (x!=x+1) x++; -> 9007199254740991
@MickLH：我得到 9007199254740992 和 that code。您使用什么 JavaScript 引擎进行测试？
你用自己的代码得到 9007199254740992，我没有使用 x 的最终值，而是出于偏执的原因对 x++ 的最终评估。顺便说一句，谷歌浏览器。
@MickLH：评估x++ 会为您提供x 在增量发生之前的值，因此这可能解释了差异。如果您希望表达式的计算结果与 x 的最终值相同，则应将其更改为 ++x。

【解决方案6】：

许多较早的答案显示 9007199254740992 === 9007199254740992 + 1 是 true 以验证 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 位。

来自Wikipedia（更多详情，去那里）

所以要使指数部分为 2^52，我们正好需要设置 e = 1075。

【讨论】：

【解决方案7】：

为了安全

var MAX_INT = 4294967295;

推理

我想我会很聪明，用更务实的方法找到 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);
}());

【讨论】：

你不能在 2^53 - 2 开始测试吗？（是的，你可以，我只是尝试过，即使使用 -3 也是安全的： var x=Math.pow(2,53)-3;while (x!=x+1) x++;) -> 9007199254740991
不错的答案！而且，我知道值是确定的，但为什么不使用二分查找呢？
这有什么好玩的？此外，@Briguy37 击败了我：*.com/a/11639621/151312
请注意，当与日期值进行比较时，此基于 32 位的“安全”MAX_INT 将不起作用。 4294967295 就是昨天！
答案“为了安全起见：var MAX_INT = 4294967295;”不幽默。如果您不进行位移，请不要担心（除非您需要大于 4294967295 的 int，在这种情况下您可能应该将其存储为字符串并使用 bigint 库）。

【解决方案8】：

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

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

未签名：0…(-1>>>0)

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

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

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

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

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

【讨论】：

这是我想偶然发现的关于如何将 X 转换为 32 位整数或无符号整数的答案。对此表示赞同。

【解决方案9】：

ECMAScript 6：

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

【讨论】：

小心 this is not (yet) supported by all browsers!今天iOS（甚至连chrome都不行），Safari和IE都不喜欢了。
请仔细阅读答案，我们没有使用 ECMAScript 6 中 Number.MAX_SAFE_INTEGER 的默认实现，我们通过 Math.pow(2, 53)-1 来定义它
我认为这只是对它在 ECMA 6 中的实现方式的参考！ :P 我认为我的评论仍然有效。所有的上下文问题。 ;)
通过逆向计算在所有浏览器中计算MAX_SAFE_INTEGER是否可靠？你应该继续前进吗？即 Number.MAX_SAFE_INTEGER = 2 * (Math.pow(2, 52) - 1) + 1;
Math.pow(2, 53)-1 操作安全吗？它比最大的安全整数大一。

【解决方案10】：

其他人可能已经给出了通用答案，但我认为给出快速确定它的方法是个好主意：

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

这在 Chrome 30 中不到一毫秒就给了我 9007199254740992。

它将测试 2 的幂，以找出在“加”1 时哪个等于他自己。

【讨论】：

你的应用程序可能会崩溃，我想。

【解决方案11】：

您要用于按位运算的任何值都必须介于 0x80000000（-2147483648 或 -2^31）和 0x7fffffff（2147483647 或 2^31 - 1）之间。

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

【讨论】：

【解决方案12】：

试试：

maxInt = -1 >>> 1

在 Firefox 3.6 中为 2^31 - 1。

【讨论】：

@danorton：我不确定你是否理解你在做什么。 ^表示获得权力。在 javascript 控制台中，^ 是 XOR，而不是提升到
打开 Chrome/Firefox 控制台。键入 5^2。在二进制中，5 是101，2 是010。现在，如果你对它们进行按位异或，你会得到5(101) ^ 2(010) = 7(111) READ THIS IF YOU'RE CONFUSED 这里讨论的是Math.pow() 而不是^ 运算符
再一次，我一点也不困惑。我对书面的内容发表了评论并投了反对票。如果 Math.pow() 是什么意思，那么这就是应该写的。在回答有关 JavaScript 的问题时，使用不同语言的语法是不合适的。使用在 JavaScript 中有效但在 JavaScript 中的解释与预期含义不同的语法是更不合适的。
2^31 是一个人用英语写 2 的 31 次方的方式。它不在代码块中。你会抱怨有人使用 ;在答案中，因为这是一个在 Javascript 中具有不同含义的字符？
即使一个人应该用纯文本写2³¹而不是2^31，但这样做很常见，因为大多数键盘布局默认没有这些字符。至少我在理解这个答案的含义时没有任何问题。

【解决方案13】：

JavaScript 在 ECMAScript 2020 中获得了一种新的数据类型：BigInt。它引入了具有“n”后缀的数字文字并允许任意精度：

var a = 123456789012345678901012345678901n;

当然，当这么大的整数（可能是无意的）强制转换为数字数据类型时，精度仍然会丢失。

而且，很明显，由于内存有限，精度总是会受到限制，并且为了分配必要的内存和对如此大的数字执行算术需要时间成本。

例如，十万十进制数字的生成，在完成之前将需要明显的延迟：

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

...但它有效。

【讨论】：

【解决方案14】：

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

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

【讨论】：

请注意 9e15 = 2^53（见@Jimmy 的回答）。
9e15 = 9000000000000000. 2^53 = 9007199254740992。因此，为了迂腐，9e15 仅约等于 2^53（具有两位有效数字）。
@chaiguy 在9000000000000000 中有 1 个有效数字。在`9007199254740992`中有15位有效数字。
@RoyiNamir 不想在这里开始毫无意义的争论，但 9000000000000000 有 16 个有效数字。如果只需要 1，则必须写为 9x10^15。
@chaiguy No. 9000000000000000 原样-有1 SF。其中90*10^14 有 2 个。(sigfigscalculator.appspot.com) & mathsfirst.massey.ac.nz/Algebra/Decimals/SigFig.htm（底部）

【解决方案15】：

我是这样写的：

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;

【讨论】：

【解决方案16】：

让我们去sources

说明

MAX_SAFE_INTEGER 常量的值为 9007199254740991（9,007,199,254,740,991 或约 9 万亿）。该数字背后的原因是 JavaScript 使用 double-precision floating-point format numbers 中指定的 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 对象的属性。

浏览器兼容性

【讨论】：

【解决方案17】：

在 JavaScript 中，数字的表示是2^53 - 1。

然而，Bitwise operation are calculated on 32 bits ( 4 bytes ), meaning if you exceed 32bits shifts you will start loosing bits.

【讨论】：

这是很重要的一点。这就是为什么我在这里谷歌搜索最大 int 大小。其他答案建议使用 53 位，因此我将其编码为我可以安全地对正值进行按位运算，最高可达 52 位。但它在 31 位之后失败了。谢谢@Marwen

【解决方案18】：

在谷歌浏览器内置的javascript中，你可以到大约2^1024，然后这个数字被称为无穷大。

【讨论】：

Math.pow(base, exponent)

【解决方案19】：

如何找到最大整数值

console.log(2 ** 53 - 1);
console.log(Number.MAX_SAFE_INTEGER);

输出：9007199254740993

【讨论】：

【解决方案20】：

斯卡托写道：

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

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

十六进制是无符号的正值，所以 0x80000000 = 2147483648 - 这在数学上是正确的。如果要使其成为有符号值，则必须右移：0x80000000 >> 0 = -2147483648。你也可以写 1

【讨论】：

【解决方案21】：

Firefox 3 似乎对庞大的数字没有问题。

1e+200 * 1e+100 将计算精细到 1e+300。

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

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

【讨论】：

它不是一个 64 位整数，它是一个 64 位浮点数，其中 52/53 位是整数部分。所以它最多可以处理 1e300，但精度不高。
吉米是正确的。在浏览器或 JS 命令行中试试这个：100000000000000010 - 1 => 100000000000000020

【解决方案22】：

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

Number.MAX_VALUE = 1.7976931348623157e+308

【讨论】：

-1：最大可表示（非精确整数）数可能是 ~2^1024，但这并不意味着它们偏离 IEEE-754 64-位标准。
MAX_INT?您的意思是 MAX_VALUE？
这是浮点值的最大值。这并不意味着您可以将 int 存储那么长
或者更重要的是，您不能可靠地存储一个长不损失准确性的int。 2^53 被称为 MAX_SAFE_INT，因为在该点之上，值变为近似值，与分数相同。