Comment vérifier si un nombre est évalué à l'infini?

J'ai une série de calculs Javascript qui (uniquement sous IE) montrent Infinity en fonction des choix de l'utilisateur.

Comment empêcher le mot d' Infinityapparaître et, par exemple, montrer à la 0.0place?

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

Vous pouvez éventuellement utiliser la isFinitefonction à la place, selon la façon dont vous souhaitez traiter NaN. isFiniteretourne falsesi votre numéro est POSITIVE_INFINITY, NEGATIVE_INFINITYou NaN.

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

Un simple n === n+1ou n === n/0fonctionne:

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

Sachez que le natif isFinite()contraint les entrées aux nombres. isFinite([])et isFinite(null)sont les deux truepar exemple.

In ES6, La Number.isFinite()méthode détermine si la valeur transmise est un nombre fini.

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

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

En fait, n === n + 1 fonctionnera pour les nombres supérieurs à 51 bits, par exemple

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

J'aime utiliser Lodash pour diverses raisons de codage défensif ainsi que pour la lisibilité. ES6 Number.isFiniteest génial et n'a pas de problèmes avec les valeurs non numériques, mais si ES6 n'est pas possible, vous avez déjà lodash ou voulez un code plus court : _.isFinite

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

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

J'ai rencontré un scénario qui m'obligeait à vérifier si la valeur est du type NaNou Infinitymais à passer des chaînes comme résultats valides. Étant donné que de nombreuses chaînes de texte produiront des faux positifs NaN, j'ai proposé une solution simple pour contourner cela:

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

Le code ci-dessus convertit les valeurs en chaînes et vérifie si elles sont strictement égales à NaN ou Infinity (vous devrez ajouter un autre cas pour l'infini négatif).

Alors:

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

Vous pouvez utiliser isFinite dans la fenêtre, isFinite(123):

Vous pouvez écrire une fonction comme:

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

Et utilisez comme:

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

Vous pouvez également Number.isFinitvérifier si la valeur est également Number et est plus précise pour la vérification undefined, nulletc.

Ou vous pouvez le polyfill comme ceci:

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