Come posso verificare se un numero restituisce infinito?

Ho una serie di calcoli Javascript che (solo in IE) mostrano Infinity a seconda delle scelte dell'utente.

Come si fa a impedire che la parola Infinityappaia e, ad esempio, a mostrarla 0.0?

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

Puoi eventualmente usare la isFinitefunzione, a seconda di come vuoi trattare NaN. isFiniterestituisce falsese il tuo numero è POSITIVE_INFINITY, NEGATIVE_INFINITYo NaN.

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

Un semplice n === n+1o n === n/0funziona:

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

Sii consapevole del fatto che il nativo isFinite()costringe gli input ai numeri. isFinite([])e isFinite(null)sono entrambi trueper esempio.

In ES6, Il Number.isFinite()metodo determina se il valore passato è un numero finito.

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

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

In realtà n === n + 1 funzionerà per numeri maggiori di 51 bit, es

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

Mi piace usare Lodash per una serie di motivi difensivi di codifica e leggibilità. ES6 Number.isFiniteè ottimo e non ha problemi con valori non numerici, ma se ES6 non è possibile, hai già lodash o desideri un codice più breve: _.isFinite

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

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

Mi sono imbattuto in uno scenario che mi richiedeva di verificare se il valore è del tipo NaNo Infinityma passa le stringhe come risultati validi. Poiché molte stringhe di testo producono falsi positivi NaN, ho creato una soluzione semplice per aggirarlo:

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

Il codice sopra converte i valori in stringhe e controlla se sono strettamente uguali a NaN o Infinity (dovrai aggiungere un altro caso per infinito negativo).

Così:

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

Puoi usare isFinite nella finestra isFinite(123):

Puoi scrivere una funzione come:

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

E usa come:

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

Puoi Number.isFinitanche controllare se il valore è anche Numero ed è più accurato per il controllo undefinedenull ecc ...

O puoi polyfill in questo modo:

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