100 votes

Comment vérifier si un nombre s'évalue à l'infini ?

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

Comment arrêter le mot Infinity apparaissant et par exemple, montrer 0.0 à la place ?

187voto

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

Vous pouvez éventuellement utiliser le isFinite à la place, en fonction de la façon dont vous souhaitez traiter les données de la NaN . isFinite renvoie à false si votre numéro est POSITIVE_INFINITY , NEGATIVE_INFINITY o NaN .

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

3 votes

Pourquoi utiliser Number.(POSITIVE|NEGATIVE)_INFINITY au lieu de -?Infinity o -?1/0 ?

5 votes

@Eli : Le global Infinity n'est pas en lecture seule, ce qui signifie qu'elle peut être redéfinie : Par exemple, var x = 42; Infinity = 42; alert(x === Infinity); affiche "vrai" . (Il est vrai qu'il s'agit d'un cas obscur, et quiconque décide de redéfinir la notion d'"homme de la rue". Infinity , NaN etc doivent s'attendre à ce que des choses bizarres se produisent).

2 votes

En ignorant le fait que Number.(POSITIVE|NEGATIVE)_INFINITY n'est pas non plus en lecture seule, Infinity est en lecture seule en mode strict. De même, qu'en est-il de la -?1/0 que je vous ai présenté ? De toute façon, vous devriez presque toujours utiliser isFinite à la place.

14voto

zangw Points 401

Sur ES6 , Le Number.isFinite() détermine si la valeur passée est un nombre fini.

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

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

10voto

ryanve Points 6881

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

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

Soyez conscient que le natif isFinite() contraint les entrées à des nombres. isFinite([]) y isFinite(null) sont tous deux true par exemple.

1 votes

Cette réponse est tout simplement fausse. n === n+1 évalue à true pour tous les nombres plus grands que 2^53, c'est-à-dire 1e30. Le hack de la division fonctionne, même pour NaN et -Infinity. Cependant, la réponse de LukeH vous donne un code beaucoup plus lisible.

0 votes

@tglas Pourquoi le plus est comme ça ? Je suis content que la division soit solide. IMO mon code est plus lisible et plus inclusif parce que les mathématiques sont plus universelles que les mots.

1 votes

Étant donné que les flottants IEEE 64 bits ont 53 chiffres binaires significatifs (cf. fr.wikipedia.org/wiki/IEEE_754 ), donc n+1 ne peut pas être représenté et est sujet à des arrondis. Eh bien, même les entiers sont affectés par les erreurs d'arrondi. Btw, je ne pense pas que votre code est "math-proof", il suffit d'essayer n === n/-0 . Lorsque vous complétez les réels avec +/-inf, votre limite n'est pas bien définie à moins que la séquence zéro sous-jacente ne soit supposée positive.

2voto

Yuri Points 111

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

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

2voto

Effectuez une simple comparaison :

(number === Infinity || number === -Infinity)

ou pour enregistrer plusieurs caractères :

Math.abs(number) === Infinity

Pourquoi l'utiliser

  1. !(Number.isFinite(number)) pauses sur NaN les entrées.
  2. Number.POSITIVE_INFINITY y Number.NEGATIVE_INFINITY peuvent être redéfinis ; ils sont configurable .
  3. Infinity y -Infinity sont en lecture seule dans le site mode strict .
  4. C'est la solution la plus courte.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X