¿Cómo verifico si un número se evalúa como infinito?

Tengo una serie de cálculos de Javascript que (solo en IE) muestran Infinity dependiendo de las opciones del usuario.

¿Cómo se detiene la Infinityaparición de la palabra y, por ejemplo, se muestra en su 0.0lugar?

if (result == Number.POSITIVE_INFINITY || result == Number.NEGATIVE_INFINITY)
{
    // ...
}

En su lugar, podría usar la isFinitefunción, dependiendo de cómo quiera tratar NaN. isFinitedevuelve falsesi su número es POSITIVE_INFINITY, NEGATIVE_INFINITYo NaN.

if (isFinite(result))
{
    // ...
}

Un simple n === n+1o n === n/0funciona:

function isInfinite(n) {
  return n === n/0;
}

Tenga en cuenta que el nativo isFinite()coacciona las entradas a los números. isFinite([])y isFinite(null)son ambos, truepor ejemplo.

En ES6, El Number.isFinite()método determina si el valor pasado es un número finito.

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

En realidad, n === n + 1 funcionará para números mayores de 51 bits, por ejemplo

1e16 + 1 === 1e16; // true
1e16 === Infinity; // false

Me gusta usar Lodash por una variedad de razones de codificación defensiva , así como por la legibilidad. ES6 Number.isFinitees excelente y no tiene problemas con valores no numéricos, pero si ES6 no es posible, ya tiene lodash o desea un código más breve: _.isFinite

_.isFinite(Infinity); // false
_.isFinite(NaN); // false
_.isFinite(-Infinity); // false

_.isFinite(null); // false
_.isFinite(3); // true
_.isFinite('3'); // true

Me encontré con un escenario que me obligaba a verificar si el valor es del tipo NaNo, Infinitypero pasar cadenas como resultados válidos. Debido a que muchas cadenas de texto producirán falsos positivos NaN, he creado una solución simple para eludir eso:

  const testInput = input => input + "" === "NaN" || input + "" === "Infinity";

El código anterior convierte los valores en cadenas y comprueba si son estrictamente iguales a NaN o Infinity (deberá agregar otro caso para el infinito negativo).

Entonces:

testInput(1/0); // true
testInput(parseInt("String")); // true
testInput("String"); // false

Puede usar isFinite en la ventana isFinite(123):

Puedes escribir una función como:

function isInfinite(num) {
 return !isFinite(num);
}

Y usa como:

isInfinite(null); //false
isInfinite(1); //false
isInfinite(0); //false
isInfinite(0.00); //false
isInfinite(NaN); //true
isInfinite(-1.797693134862316E+308); //true
isInfinite(Infinity); //true
isInfinite(-Infinity); //true
isInfinite(+Infinity); //true
isInfinite(undefined); //true

También puede Number.isFinitE, que también comprobar si el valor es un número demasiado y es más preciso para la comprobación undefinedy nulletc ...

O puede rellenarlo así:

Number.isFinite = Number.isFinite || function(value) {
  return typeof value === 'number' && isFinite(value);
}