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

validacion de formularios con javascript ejemplos

Question

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

Answer 1

Para estar seguro

var MAX_INT = 4294967295;

Razonamiento

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

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

Si no puedes esperar tanto, estoy dispuesto a apostar eso.

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

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

Answer 2

Vayamos a las Number.MAX_SAFE_INTEGER

Descripción

La constante MAX_SAFE_INTEGER tiene un valor de 9007199254740991 (9,007,199,254,740,991 o ~ 9 cuatrillones). El razonamiento detrás de ese número es que JavaScript utiliza Wiki como se especifica en IEEE 754 y solo puede representar números entre -(253 - 1) y 253 - 1 forma segura.

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

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

Compatibilidad del navegador

Answer 3

Básicamente, javascript no soporta mucho tiempo.
por lo tanto, para valores normales que pueden representar menos de 32 bits, utilizará el contenedor de tipo int. para valores enteros mayores a 32 bit su doble uso. En la representación doble, la parte entera es de 53 bits y el resto es mantisa (para mantener la información de punto flotante).
por lo que puede usar 2^53 - 1 cuyo valor es 9007199254740991
puede acceder al valor para usar en su código mediante Number.MAX_SAFE_INTEGER

Answer 4

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

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

Answer 5

ECMAScript 6:

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

Answer 6

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.

Answer 7

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

Answer 8

Es 2 ⁵³ == 9 007 199 254 740 992. Esto se debe a que los Number s se almacenan como punto flotante en una mantisa de 52 bits.

El valor mínimo es -2 ⁵³ .

Esto hace que sucedan 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
}

_{Lectura adicional: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html}

Answer 9

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

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

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

A menos que perdiera mi cerebro en este momento del día, esto es mucho más grande que un entero de 64 bits.

Answer 10

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

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

Answer 11

La respuesta corta es "depende".

Si está utilizando operadores bitwise en cualquier lugar (o si se refiere a la longitud de un Array), los rangos son:

Sin firmar: 0…(-1>>>0)

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

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

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

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

Estas limitaciones son impuestas por la representación interna del tipo "Número", que generalmente corresponde a la representación de coma flotante de doble precisión 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 ).

Answer 12

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;

Answer 13

Muchas respuestas anteriores muestran que el resultado es true de 9007199254740992 === 9007199254740992 + 1
para indicar que 9 007 199 254 740 991 es el número entero seguro máximo.

¿Y 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 se pueden representar números pares.

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

Comenzamos desde 4 503 599 627 370 496 con la versión breve del formato primero:

  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 base adyacente, luego, al multiplicar 2^52 , movemos a la derecha el punto de base de 52 pasos, y va al final. Ahora obtenemos 4503599627370496 en binario.

Ahora comenzamos a acumular 1 en este valor hasta que todos los bits se configuran 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 agregar uno más 1, así que lo que podríamos hacer es volver a poner todos los bits a 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 have 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 un número mayor que el que podría tener el formato es 2 veces la fracción :

                            (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 llegue a más de 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984, solo se podrían 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é hay del 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 la 1/2 veces del número 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 parte exponente ? El formato le asigna 11 bits. Formato completo de Wiki : (Para más detalles por favor vaya allí)

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

Answer 14

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

Number.MAX_VALUE = 1.7976931348623157e+308

Answer 15

Otros pueden haber dado ya la respuesta genérica, pero pensé que sería una buena idea dar una manera rápida de determinarlo:

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.

Probará potencias de 2 para encontrar cuál, cuando "agregado" 1, es igual a sí mismo.

Answer 16

Scato escribe:

cualquier cosa que desee utilizar para operaciones bitwise debe estar entre 0x80000000 (-2147483648 o -2 ^ 31) y 0x7fffffff (2147483647 o 2 ^ 31 - 1).

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

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

Answer 17

Tratar:

maxInt = -1 >>> 1

En Firefox 3.6 es 2 ^ 31 - 1.

Answer 18

Number.MAX_VALUE representa el valor numérico máximo representable en JavaScript.

Dado que nadie parece haberlo dicho, en el motor v8 hay una diferencia de comportamiento para el número de 31 bits y el número por encima de eso.

Si tiene 32 bits , puede usar el primer bit para indicar al motor de JavaScript qué tipo de datos son y hacer que los bits restantes contengan los datos reales. Eso es lo que hace V8 como una pequeña optimización para los numbers 31 bis (o solía hacerlo, mis fuentes son bastante anticuadas). Usted tiene los últimos 31 bits son el valor numérico y luego el primer bit que le dice al motor si es un número o una referencia de objeto.

Sin embargo, si utiliza un número superior a 31 bits , los datos no se ajustarán, el número se encuadrará en el doble de 64 bits y la optimización no estará allí.

La línea inferior, en el siguiente video, es:

prefiera valores numéricos que puedan representarse como enteros con signo de 31 bits .

• video interesante
• Otra fuente

Answer 19

> = ES6: Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER; Number.MIN_SAFE_INTEGER; Number.MAX_SAFE_INTEGER;

<= ES5

De la referencia : Number.MAX_VALUE; Number.MIN_VALUE; 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

Answer 20

+/- 9007199254740991

ECMA Sección 8.5 - Números

Tenga en cuenta que todos los enteros positivos y negativos cuya magnitud no es mayor de 2 ⁵³ son representables en el tipo de Número (de hecho, el entero 0 tiene dos representaciones, +0 y −0).

Son valores de punto flotante de 64 bits, el valor integral más grande exacto es 2 ⁵³ -1, o 9007199254740991 . En ES6, esto se define como Number.MAX_SAFE_INTEGER .

Tenga en cuenta que los operadores en modo bit y los operadores de cambio operan en ints de 32 bits, por lo que, en ese caso, el entero seguro máximo es 2 ³¹ -1, o 2147483647.

¡Pruébalo!

var x = 9007199254740992;
var y = -x;
x == x + 1; // true !
y == y - 1; // also true !
// Arithmetic operators work, but bitwise/shifts only operate on int32:
x / 2;      // 4503599627370496
x >> 1;     // 0
x | 1;      // 1

Nota técnica sobre el tema del número 9007199254740992: Existe una representación exacta de IEEE-754 de este valor, y puede asignar y leer este valor desde una variable, por lo que para aplicaciones muy cuidadosamente elegidas en el dominio de números enteros menor o igual 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 9007199254740992 o 9007199254740993.

Answer 21

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

document.write(9007199254740993);

Sin embargo, no hay una respuesta que lo compruebe o lo demuestre programáticamente (aparte de la que CoolAJ86 alude en su respuesta que terminaría en 28.56 años;), así que aquí hay una manera un poco más eficiente de hacerlo (para ser precisos, es más eficiente alrededor de 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);