¿Cuál es el valor entero más alto de JavaScript al que puede ir un número sin perder precisión?

951

¿Está esto definido por el idioma? ¿Hay un máximo definido? ¿Es diferente en diferentes navegadores?

TALlama
fuente
55
No necesita depender de los límites de JS con bibliotecas como github.com/MikeMcl/big.js , consulte, por ejemplo, aquí sus pruebas de confiabilidad
Dmitri Zaitsev
2
¿Cuál es el valor entero más alto que puede usar con big.js?
George
@George Aquí está big.js API: mikemcl.github.io/big.js/#dp
simhumileco
La pregunta no tiene sentido. ¿Qué significa que un número "va" a un valor entero? Si solo desea preguntar cuál es el número entero más alto que puede representar en JS, el número más alto (finito) en sí mismo es un número entero.
Veky
@DmitriZaitsev Ya no necesitamos depender de bibliotecas externas (al menos en algunos navegadores). 1n << 10000nes un número muy, muy grande, sin perder precisión, sin necesidad de dependencias (y ni que decir, ni siquiera cerca de un límite).
Amadan

Respuestas:

868

JavaScript tiene dos tipos de números: Numbery BigInt.

El tipo de número más utilizado Number, es un número IEEE 754 de coma flotante de 64 bits .

El valor integral exacto más grande de este tipo es Number.MAX_SAFE_INTEGER, que es:

  • 2 53 -1, o
  • +/- 9,007,199,254,740,991, o
  • nueve cuatrillones siete trillones ciento noventa y nueve mil doscientos cincuenta y cuatro millones setecientos cuarenta mil novecientos noventa y uno

Para poner esto en perspectiva: un billón de bytes es un petabyte (o mil terabytes).

"Seguro" en este contexto se refiere a la capacidad de representar enteros exactamente y compararlos correctamente.

De la especificación:

Tenga en cuenta que todos los enteros positivos y negativos cuya magnitud no es mayor que 2 53 son representables en el Numbertipo (de hecho, el entero 0 tiene dos representaciones, +0 y -0).

Para usar de forma segura enteros más grandes que esto, debe usar BigInt, que no tiene límite superior.

Tenga en cuenta que los operadores bit a bit y los operadores de desplazamiento operan con enteros de 32 bits, por lo que en ese caso, el entero seguro máximo es 2 31 -1, o 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


Nota técnica sobre el tema del número 9,007,199,254,740,992: Hay una representación exacta de IEEE-754 de este valor, y puede asignar y leer este valor desde una variable, por lo tanto, para aplicaciones cuidadosamente seleccionadas en el dominio de enteros menores o iguales a este valor, podría tratarlo como un valor máximo.

En el caso general, debe tratar este valor IEEE-754 como inexacto, porque es ambiguo si está codificando el valor lógico 9,007,199,254,740,992 o 9,007,199,254,740,993.

Palanqueta
fuente
75
Esto parece correcto, pero ¿hay algún lugar donde esté definido, á la C's MAX_INT o Java's Integer.MAX_VALUE?
TALlama el
48
4294967295 === Math.pow(2,32) - 1;
CoolAJ86
13
Entonces, ¿cuál es el número entero más pequeño y más grande que podemos usar para asegurar la precisión exacta?
Pacerier
38
Quizás valga la pena señalar que no hay real (int) en javascript. Cada instancia de Number es (float) o NaN.
Remolacha-Remolacha
53
9007199254740992 no es realmente el valor máximo, el último bit aquí ya se supone que es cero, por lo que ha perdido 1 bit de precisión. El número seguro real es 9007199254740991 (Number.MAX_SAFE_INTEGER)
Willem D'Haeseleer
461

> = ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

De la referencia :

Number.MAX_VALUE;
Number.MIN_VALUE;

Peter Bailey
fuente
23
He editado la pregunta para que sea un poco más precisa acerca de querer los valores enteros máximos, no solo el valor máximo del número. Perdón por la confusión, aquí.
TALlama
55
¿Se garantiza que el resultado devuelto sea igual en todos los navegadores?
Pacerier
77
Tenga en cuenta que Number.MIN_VALUEes el número positivo más pequeño posible . El menor valor (es decir, menos que cualquier otra cosa) es probablemente -Number.MAX_VALUE.
Michael Scheper
34
ES6 presenta Number.MIN_SAFE_INTEGERyNumber.MAX_SAFE_INTEGER
superlukas
2
Entonces, en este caso, ¿deberíamos rechazar la respuesta porque es incorrecta para la pregunta actualizada o dejarla porque Peter Baily tenía razón en el momento en que fue respondida?
Rocketsarefast
112

Es 2 53 == 9 007 199 254 740 992. Esto se debe a que los Numbers se almacenan como coma flotante en una mantisa de 52 bits.

El valor mínimo es -2 53 .

Esto hace que pasen cosas divertidas

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

Y también puede ser peligroso :)

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
}

Leer más: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html

Vjeux
fuente
1
aunque uno nunca llegaría al final de ese ciclo for en un marco de tiempo i += 1000000000
razonable
2
@ninjagecko, comienza en MAX_INT, así que el final está justo ahí. También usar i + = 1000000000 haría que ya no sea un bucle infinito. Intentalo.
Ted Bigham el
@TedBigham: Ah, vaya, estaba listo demasiado rápido para eso. Gracias por corregirme dos veces.
ninjagecko
Vea el argumento de Jimmy para 9,007,199,254,740,991 en lugar de 9,007,199,254,740,992 aquí . Eso, combinado con mi seguimiento, parece persuasivo.
TJ Crowder
60

En JavaScript, hay un número llamado Infinity.

Ejemplos:

(Infinity>100)
=> true

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

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

Esto puede ser suficiente para algunas preguntas sobre este tema.

BananaNeil
fuente
25
Algo me dice que el infinito no califica como un número entero. :)
devios1
77
Pero es lo suficientemente bueno para inicializar una minvariable cuando buscas un valor mínimo.
djjeck el
99
Tenga en cuenta queInfinity - 1 === Infinity
H.Wolper
2
también (Infinity <100) => false y Math.pow (2,1024) === Infinity
Sijav
66
Tampoco vale nada que maneje Infinity negativo también. Entonces1 - Infinity === -Infinity
dmccabe el
41

La respuesta de Jimmy representa correctamente el espectro entero continuo de JavaScript como -9007199254740992 a 9007199254740992 inclusive (perdón 9007199254740993, ¡podrías pensar que eres 9007199254740993, pero estás equivocado! Demostración debajo o en jsfiddle ).

console.log(9007199254740993);

Sin embargo, no hay una respuesta que encuentre / pruebe esto programáticamente (aparte de la que CoolAJ86 aludió en su respuesta que terminaría en 28.56 años;), así que aquí hay una forma un poco más eficiente de hacerlo (para ser precisos, es más eficiente por aproximadamente 28.559999999968312 años :), junto con un violín de prueba :

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

Briguy37
fuente
8
@ CoolAJ86: Lol, estoy deseando que llegue el 15 de marzo de 2040. Si nuestros números coinciden, deberíamos organizar una fiesta :)
Briguy37
var x = Math.pow (2,53) -3; while (x! = x + 1) x ++; -> 9007199254740991
MickLH
@MickLH: obtengo 9007199254740992 con ese código . ¿Qué motor de JavaScript estás usando para probar?
Briguy37
Obtienes 9007199254740992 con tu propio código, no utilicé el valor final de x, sino la evacuación final de x ++ por razones paranoicas. Google Chrome por cierto.
MickLH
@MickLH: la evaluación x++le da el valor de x antes de que ocurra el incremento, por lo que eso probablemente explica la discrepancia. Si desea que la expresión se evalúe de la misma manera que el valor final de x, debe cambiarla a ++x.
peterflynn
32

Para estar seguro

var MAX_INT = 4294967295;

Razonamiento

Pensé que sería inteligente y encontraría el valor en el que x + 1 === xcon un enfoque más pragmático.

Mi máquina solo puede contar con 10 millones por segundo más o menos ... así que volveré a publicar con la respuesta definitiva en 28.56 años.

Si no puedes esperar tanto, estoy dispuesto a apostar que

  • La mayoría de tus bucles no funcionan durante 28,56 años.
  • 9007199254740992 === Math.pow(2, 53) + 1 es prueba suficiente
  • Debería atenerse a lo 4294967295que es Math.pow(2,32) - 1para evitar los problemas esperados con el desplazamiento de bits

Encontrar 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);
}());
CoolAJ86
fuente
44
¿No puedes comenzarlo a las 2 ^ 53 - 2 para probar? (Sí, puedes, lo intenté, incluso con -3 para estar seguro: var x = Math.pow (2,53) -3; while (x! = x + 1) x ++;) -> 9007199254740991
MickLH
¡Buena respuesta! Además, sé que el valor está resuelto, pero ¿por qué no usar la búsqueda binaria para encontrarlo?
higuaro
1
¿Qué es lo divertido en eso? Además, @ Briguy37 me ganó: stackoverflow.com/a/11639621/151312
CoolAJ86
tenga en cuenta que este MAX_INT 'seguro' basado en 32 bits no funcionará al compararlo con los valores de fecha. 4294967295 es tan ayer!
Jerry
1
La respuesta "Para estar seguro: var MAX_INT = 4294967295;" no es chistoso Si no está desplazando bits, no se preocupe (a menos que necesite un int mayor que 4294967295, en cuyo caso probablemente debería almacenarlo como una cadena y usar una biblioteca bigint).
CoolAJ86
29

La respuesta corta es "depende".

Si está utilizando operadores bit a bit en cualquier lugar (o si se refiere a la longitud de una matriz), los rangos son:

No firmado: 0…(-1>>>0)

Firmado: (-(-1>>>1)-1)…(-1>>>1)

(Sucede que los operadores bit a bit y la longitud máxima de una matriz están restringidos a enteros de 32 bits).

Si no está utilizando operadores bit a bit o trabajando con longitudes de matriz:

Firmado: (-Math.pow(2,53))…(+Math.pow(2,53))

Estas limitaciones están impuestas por la representación interna del tipo "Número", que generalmente corresponde a la representación de punto flotante de precisión doble IEEE 754. (Tenga en cuenta que, a diferencia de los enteros con signo típicos, la magnitud del límite negativo es la misma que la magnitud del límite positivo, debido a las características de la representación interna, que en realidad incluye un 0 negativo ).

Danorton
fuente
Esta es la respuesta con la que quería tropezar sobre cómo convertir X a un entero de 32 bits o entero sin signo. Votó su respuesta por eso.
Charlie Affumigato
29

ECMAScript 6:

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;
WaiKit Kung
fuente
1
¡Cuidado, esto no es (todavía) compatible con todos los navegadores! Hoy iOS (ni siquiera Chrome), Safari e IE no les gusta.
cregox
55
Lea atentamente la respuesta, no estamos utilizando la implementación predeterminada de Number.MAX_SAFE_INTEGER en ECMAScript 6, la estamos definiendo por Math.pow (2, 53) -1
WaiKit Kung
¡Pensé que era solo una referencia de cómo se implementa en ECMA 6! : PI creo que mi comentario sigue siendo válido, sin embargo. Todo es cuestión de contexto. ;)
cregox
3
¿Es confiable calcular MAX_SAFE_INTEGERen todos los navegadores trabajando hacia atrás? ¿Deberías avanzar en su lugar? Es decir, Number.MAX_SAFE_INTEGER = 2 * (Math.pow (2, 52) - 1) + 1;
kjv
¿Es Math.pow(2, 53)-1una operación segura? Va uno más grande que el mayor entero seguro.
ioquatix
21

Muchas respuestas de épocas anteriores han mostrado el resultado truede 9007199254740992 === 9007199254740992 + 1verificar que 9 007 199 254 740 991 es el número entero máximo y seguro.

¿Qué pasa si seguimos haciendo acumulación?

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

Podríamos descubrir que entre los números mayores que 9 007 199 254 740 992 , solo los números pares son representables .

Es una entrada para explicar cómo funciona el formato binario de doble precisión de 64 bits en esto. Veamos cómo se mantiene (representa) 9 007 199 254 740 992 utilizando este formato binario.

Usando una versión breve para demostrarlo de 4 503 599 627 370 496 :

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

En el lado izquierdo de la flecha, tenemos el valor de bit 1 y un punto de raíz adyacente , luego, al multiplicar 2^52, movemos a la derecha el punto de raíz 52 pasos, y llega al final. Ahora tenemos 4503599627370496 en binario.

Ahora comenzamos a acumular 1 a este valor hasta que todos los bits se establezcan en 1, lo que equivale a 9 007 199 254 740 991 en decimal.

  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. 

Ahora, debido a que en formato binario de 64 bits de doble precisión , asigna estrictamente 52 bits por fracción, no hay más bits disponibles para sumar uno más, así que lo que podemos hacer es establecer todos los bits nuevamente en 0, y manipular la parte exponente:

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

Ahora obtenemos el 9 007 199 254 740 992 , y con el número mayor que él, lo que el formato podría contener es 2 veces la fracción , significa que ahora cada 1 suma en la parte de la fracción en realidad equivale a 2 sumas, por eso el doble -precisión de formato binario de 64 bits no puede contener números impares cuando el número es mayor que 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 --|

Entonces, cuando el número llega a ser mayor que 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984, solo se pueden mantener 4 veces la fracción :

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

¿Qué tal el número entre [ 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  --|

El valor de bit 1 después del punto de raíz es 2 ^ -1 exactamente. (= 1/2 , = 0.5) Entonces, cuando el número es menor que 4 503 599 627 370 496 (2 ^ 52), hay un bit disponible para representar las 1/2 veces del entero :

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

Menos de 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"

¿Y cuál es el rango disponible de la parte exponente ? el formato le asigna 11 bits. Formato completo de Wiki : (Para más detalles, vaya allí)

IEEE 754 Double Floating Point Format.svg

ingrese la descripción de la imagen aquí

Entonces, para que la parte del exponente sea 2 ^ 52, necesitamos exactamente establecer e = 1075.

Carr
fuente
13

Puede que otros ya hayan dado la respuesta genérica, pero pensé que sería una buena idea dar una forma rápida de determinarla:

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

Lo que me da 9007199254740992 en menos de un milisegundo en Chrome 30.

Pondrá a prueba las potencias de 2 para encontrar cuál, cuando se 'agrega' 1, es igual a sí mismo.

Philippe97
fuente
Podría bloquear su aplicación, pensó.
Sapphire_Brick
8

Cualquier cosa que desee usar para operaciones bit a bit debe estar entre 0x80000000 (-2147483648 o -2 ^ 31) y 0x7fffffff (2147483647 o 2 ^ 31 - 1).

La consola le dirá que 0x80000000 es igual a +2147483648, pero 0x80000000 y 0x80000000 es igual a -2147483648.

Scato
fuente
6

Tratar:

maxInt = -1 >>> 1

En Firefox 3.6 es 2 ^ 31-1.

Martin Naatz
fuente
2
@danorton: No estoy seguro de que entiendas lo que estás haciendo. ^significa elevado al poder . En la consola javascript, ^es XOR , no elevado a
kumarharsh
2
Abra la consola de Chrome / Firefox. Escriba 5 ^ 2. En binario, 5 es 101y 2 es 010. Ahora, si los haces Bitwise XOR, 5(101) ^ 2(010) = 7(111) LEERÁS ESTO SI ESTÁS CONFUNDIDO Lo que se está discutiendo aquí Math.pow()no es el ^operador
kumarharsh
3
De nuevo, no estoy nada confundido. He comentado y rechazado lo que está escrito . Si Math.pow () es lo que significa, entonces eso es lo que debe escribirse. En una respuesta a una pregunta sobre JavaScript, es inapropiado usar la sintaxis de un idioma diferente. Es aún más inapropiado usar una sintaxis que sea válida en JavaScript, pero con una interpretación en JavaScript que tenga un significado diferente de lo que se pretende.
danorton
10
2 ^ 31 es cómo uno escribe dos al trigésimo primer poder en inglés. No está en un bloque de código. ¿Te quejarías de alguien usando un; en una respuesta, porque ese es un personaje con un significado diferente en Javascript?
lmm
3
Aunque uno debería escribir 2³¹ y no 2 ^ 31 en texto plano, es común hacerlo, porque la mayoría de los diseños de teclado no tienen esos caracteres por defecto. Al menos no tuve ningún problema para entender lo que significaba en esta respuesta.
Jocke
6

En el momento de la escritura, JavaScript está recibiendo un nuevo tipo de datos: BigInt. Es una propuesta TC39 en la etapa 4 que se incluirá en EcmaScript 2020 . BigIntestá disponible en Chrome 67+, FireFox 68+, Opera 54 y Node 10.4.0. Está en marcha en Safari, et al ... Introduce literales numéricos con un sufijo "n" y permite una precisión arbitraria:

var a = 123456789012345678901012345678901n;

La precisión aún se perderá, por supuesto, cuando dicho número se coaccione (tal vez involuntariamente) a un tipo de datos numérico.

Y, obviamente, siempre habrá limitaciones de precisión debido a la memoria finita y un costo en términos de tiempo para asignar la memoria necesaria y realizar operaciones aritméticas en números tan grandes.

Por ejemplo, la generación de un número con cien mil dígitos decimales tardará notablemente antes de completarse:

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

...pero funciona.

trincot
fuente
4

Hice una prueba simple con una fórmula, X- (X + 1) = - 1, y el mayor valor de XI puede funcionar en Safari, Opera y Firefox (probado en OS X) es 9e15. Aquí está el código que usé para probar:

javascript: alert(9e15-(9e15+1));
Raynet
fuente
1
Tenga en cuenta que 9e15 = 2 ^ 53 (vea la respuesta de @ Jimmy).
Wedge
66
9e15 = 9000000000000000. 2 ^ 53 = 9007199254740992. Por lo tanto, para ser pedante, 9e15 es solo aproximadamente igual a 2 ^ 53 (con dos dígitos significativos).
devios1
@chaiguy En 9000000000000000hay 1 cifra significativa. en `9007199254740992` hay 15 cifras significativas.
Royi Namir
@RoyiNamir No quiero comenzar una discusión inútil aquí, pero 9000000000000000 tiene 16 dígitos significativos. Si solo desea 1, debería escribirse como 9x10 ^ 15.
devios1
1
@chaiguy No. 9000000000000000tal como está - tiene 1SF. donde 90*10^14tiene 2. ( sigfigscalculator.appspot.com ) y mathsfirst.massey.ac.nz/Algebra/Decimals/SigFig.htm (sección inferior)
Royi Namir
3

Lo escribo así:

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

Lo mismo para int32

var max_int32 =  0x80000000;
var min_int32 = -0x80000000;
Jerome
fuente
3

Vamos a las fuentes

Descripción

La MAX_SAFE_INTEGERconstante tiene un valor de 9007199254740991(9,007,199,254,740,991 o ~ 9 billones). El razonamiento detrás de ese número es que JavaScript usa números de formato de punto flotante de doble precisión como se especifica en IEEE 754 y solo puede representar con seguridad números entre -(2^53 - 1)y 2^53 - 1.

Seguro en este contexto se refiere a la capacidad de representar enteros exactamente y compararlos correctamente. Por ejemplo, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2evaluará a verdadero, que es matemáticamente incorrecto. Consulte Number.isSafeInteger () para obtener más información.

Debido a que MAX_SAFE_INTEGERes una propiedad estática de Number , siempre la usa como Number.MAX_SAFE_INTEGER, en lugar de como una propiedad de un objeto Number que creó.

Compatibilidad del navegador

ingrese la descripción de la imagen aquí

simhumileco
fuente
0

En el javascript incorporado de Google Chrome, puede ir a aproximadamente 2 ^ 1024 antes de que el número se llame infinito.

Tommy
fuente
-1

Scato escribe:

todo lo que desee usar para operaciones bit a bit debe estar entre 0x80000000 (-2147483648 o -2 ^ 31) y 0x7fffffff (2147483647 o 2 ^ 31 - 1).

la consola le dirá que 0x80000000 es igual a +2147483648, pero 0x80000000 y 0x80000000 es igual a -2147483648

Los decimales hexadecimales son valores positivos sin signo, por lo que 0x80000000 = 2147483648, eso es matemáticamente correcto. Si desea convertirlo en un valor firmado, debe desplazarse a la derecha: 0x80000000 >> 0 = -2147483648. También puedes escribir 1 << 31.

SammieFox
fuente
-7

Firefox 3 no parece tener un problema con grandes números.

1e + 200 * 1e + 100 calculará bien a 1e + 300.

Safari parece no tener problemas con eso también. (Para el registro, esto está en una Mac si alguien más decide probar esto).

A menos que pierda mi cerebro a esta hora del día, esto es mucho más grande que un entero de 64 bits.

jishi
fuente
18
no es un número entero de 64 bits, es un número de coma flotante de 64 bits, de los cuales 52/53 bits son la parte entera. por lo que manejará hasta 1e300, pero no con precisión exacta.
Jimmy
44
Jimmy tiene razón. Pruebe esto en su navegador o línea de comando JS:100000000000000010 - 1 => 100000000000000020
Ryan
-7

Node.js y Google Chrome parecen estar utilizando valores de coma flotante de 1024 bits, por lo que:

Number.MAX_VALUE = 1.7976931348623157e+308
TinyTimZamboni
fuente
1
-1: el número máximo representable (integral no exacta) puede ser ~ 2 ^ 1024, pero eso no significa que se estén desviando del estándar IEEE-754 de 64 bits.
Roy Tinker
2
MAX_INT? ¿Te refieres a MAX_VALUE?
Raúl Guiu
3
eso es máximo de un valor de coma flotante . No significa que pueda almacenar un int durante tanto tiempo
phuclv
1
O más al punto, no puede almacenar de manera confiable un int durante tanto tiempo sin pérdida de precisión . 2^53se conoce como MAX_SAFE_INTporque arriba de ese punto los valores se convierten en aproximaciones, de la misma manera que lo son las fracciones.
IMSoP