Amusant avec les numéros JavaScript

Points clés

• Tous les nombres en JavaScript sont représentés en utilisant le type de données de nombre, y compris les entiers, les nombres réels, les nombres hexadécimaux et les nombres de notation scientifique. Cependant, JavaScript représente en interne tous les nombres en tant que nombres de points flottants IEEE 754, ce qui signifie que les mathématiques JavaScript ne sont pas précises à 100%.
• JavaScript définit un nombre appelé Not-A-Number (NAN) pour représenter les non-chiffres comme des nombres. Nan est la seule valeur numérique en JavaScript qui n'est pas égale à elle-même et peut être testée à l'aide de la fonction isnan ().
• JavaScript a certaines fonctionnalités, telles que les zéros signées, résultant en des zéros positifs (0) et des zéros négatifs (-0), qui sont considérés comme des valeurs différentes, mais les opérateurs de comparaison de JavaScript ne peuvent pas les distinguer. En JavaScript, la division par zéro produit l'infini et la division par zéro négative produit -Infinity.

Les types de données sont une partie importante de chaque langage de programmation, et les nombres sont peut-être les types de données les plus importants. Après tout, les ordinateurs ne sont vraiment que des calculatrices coûteuses. Comme tout langage de programmation précieux, JavaScript prend en charge les données numériques. Mais, comme de nombreux autres aspects de JavaScript, il y a des nuances dans les nombres qui peuvent vous causer des problèmes si vous ne faites pas attention. Cet article traite des données numériques et de certaines de ses caractéristiques. Remarque: Avant de lire cet article, vous devriez avoir une compréhension de base des types de données JavaScript .

Type de nombre

Dans JavaScript, tous les nombres sont représentés par le type de données de nombre. Cela comprend les entiers, les nombres réels, les nombres hexadécimaux et les nombres représentés par la notation scientifique. L'exemple suivant le vérifie en appliquant le type d'opérateur à divers nombres. Dans cet exemple, chaque application de typeof renvoie un nombre.

<code class="language-javascript">typeof(100);
typeof(3.14);
typeof(0xDEADBEEF);
typeof(7.89e2);</code>

Dans l'exemple précédent, les nombres se trouvent dans différents formats. Cependant, en interne, tous les numéros JavaScript sont en fait représentés sous forme de numéros de points flottants IEEE 754. Ceci est important car cela signifie que JavaScript n'a pas le concept d'entiers, bien que la langue ait la fonction parseInt (). Cela signifie également que les opérations mathématiques JavaScript ne sont pas précises à 100%. Par exemple, considérez l'expression suivante.

<code class="language-javascript">(0.1 + 0.2) === 0.3</code>

Si vous n'êtes pas familier avec les numéros de points flottants, vous vous attendez certainement à ce que cette expression évalue à TRUE. Après tout, 0,1 0,2 est égal à 0,3. Cependant, en raison du fonctionnement des numéros de points flottants, leur somme est en fait de 0,30000000000000000000004. La différence est petite, mais cela suffit pour faire en sorte que l'expression entière évalue à False.

zéro positif et zéro négatif

Une autre caractéristique de la norme IEEE 754 est le zéro signé. Il en résulte deux zéros - zéro positif, 0 et zéro négatif, -0. Cela peut sembler étrange, mais le plaisir vient de commencer. De toute évidence, ces deux sont des valeurs différentes, sinon il n'y aura qu'un seul zéro. Cependant, si vous montrez l'un de ces deux zéros, le symbole sera supprimé. Par exemple, le code suivant essaie d'afficher ces deux valeurs zéro côte à côte.

<code class="language-javascript">typeof(100);
typeof(3.14);
typeof(0xDEADBEEF);
typeof(7.89e2);</code>

Pire, les opérateurs de comparaison de JavaScript semblent également incapables de distinguer les deux valeurs, comme le montre l'exemple suivant.

<code class="language-javascript">(0.1 + 0.2) === 0.3</code>

Il existe une solution assez simple à ce problème. En JavaScript, la division par zéro produit une infinité. De même, la division par zéro négative produira -Infinity. Donc, pour déterminer si un nombre est égal à -0, nous devons vérifier s'il est nul, puis utilisez-le comme dénominateur pour la division et vérifiez -infinity comme indiqué ci-dessous.

<code class="language-javascript">alert((+0) + " " + (-0));
// 显示 0 0</code>

pas-un nombre (nan)

JavaScript définit en fait un nombre appelé Not-A-Number (NAN). Nan est une fausse valeur utilisée pour représenter les non-chiffres comme nombres. Cette valeur est intéressante car son nom lui-même exclut la possibilité qu'il soit un nombre, mais le type de (nan) est un nombre. Nan est également intéressant car c'est la seule valeur en JavaScript qui ne s'égale pas elle-même. Par exemple, le code suivant retournera faux.

<code class="language-javascript">alert((+0 === -0));
// 显示 true
alert((-0 === +0)); // 显示 true</code>

Vous pouvez tester NAN à l'aide de la fonction isnan () au lieu d'utiliser l'opérateur de comparaison comme indiqué ci-dessous.

<code class="language-javascript">function isNegativeZero(x) {
  return (x === 0 && (1/x) === -Infinity);
}</code>

Cependant, Isnan () est également intéressant car il peut être trompeur. Si vous transmettez une valeur qui peut être jetée à un nombre, Isnan () reviendra faux. Dans l'exemple suivant, Isnan () est appelé avec plusieurs valeurs qui ne sont évidemment pas numériques. Cependant, chaque appel revient faux.

<code class="language-javascript">alert((NaN === NaN));
// 显示 false</code>

Une meilleure façon de vérifier Nan est de profiter du fait qu'elle ne s'égale pas elle-même. La fonction suivante teste NAN en utilisant une inégalité stricte. Cette fonction renvoie vrai uniquement pour la valeur nan.

<code class="language-javascript">isNaN(1);
// 返回 false
isNaN(NaN);
// 返回 true</code>

Autres moments amusants

Il existe d'autres situations qui peuvent causer des problèmes avec les chiffres. Premièrement, vous devez être conscient des anciens navigateurs, qui permettent aux propriétés globales telles que Infinity, Nan et indéfinies d'être redéfinies sous forme de nouvelles valeurs. Par exemple, si vous utilisez fréquemment NAN, le code suivant peut causer de nombreux problèmes. Heureusement, les navigateurs modernes ignorent les affectations aux propriétés susmentionnées. Le mode strict va plus loin, convertissant ces défaillances silencieuses en erreurs.

<code class="language-javascript">isNaN(true);
isNaN(false);
isNaN("");
isNaN(null);
// 全部返回 false</code>

Une autre erreur de diagnostic intéressante provient de l'ajout de nombres et de chaînes. Un exemple est illustré ci-dessous. Dans ce cas, la concaténation de String remplace l'ajout. Cela fait convertir FOO en la chaîne "100". Le résultat final est la chaîne "1001", qui est très différente de la valeur attendue de 101. Ce type d'erreur est plus courant que vous ne le pensez et se produit souvent lors de la lecture de l'entrée des utilisateurs.

<code class="language-javascript">function isNotANumber(x) {
  return x !== x;
}</code>

Conclusion

Cet article traite de certaines des caractéristiques des nombres en JavaScript. J'espère que vous comprenez maintenant comment ces problèmes surviennent et comment les éviter. Et, même si vous ne rencontrez pas souvent des situations comme des zéros négatifs, du moins maintenant vous êtes prêt.

Des questions fréquemment posées sur les numéros JavaScript (FAQ)

Que se passe-t-il lors de la division d'un nombre par zéro en javascript?

Dans JavaScript, lorsque vous divisez le nombre de zéro, le résultat est l'infini. En effet, tout nombre divisé par zéro est mathématiquement indéfini, mais JavaScript le représente comme infini à des fins pratiques. Cependant, si vous divisez zéro par zéro, le résultat est NAN (pas un nombre), car cette opération est incertaine en mathématiques.

Comment gérer BigInt divisé par zéro?

BigInt est un objet intégré en JavaScript qui fournit un moyen de représenter des entiers supérieurs à 2 ^ 53-1, le plus grand nombre que JavaScript peut représenter de manière fiable en utilisant le nombre de primitifs. Si vous essayez de diviser BigInt par zéro, JavaScript lancera un plageerror indiquant que l'opération n'est pas valide.

Comment prévenir ou gérer la division par zéro erreur dans JavaScript?

Vous pouvez utiliser des instructions conditionnelles dans JavaScript pour empêcher ou traiter la division par zéro erreurs en vérifiant si le dénominateur est nul avant d'effectuer l'opération de division. Si le dénominateur est nul, vous pouvez décider comment le gérer, par exemple, renvoyer une valeur spécifique ou afficher un message d'erreur.

Pourquoi 0 est-il divisé par 0 dans JavaScript nan?

En mathématiques, l'expression 0/0 n'est pas définie car elle n'a pas de valeur explicite et définie. En JavaScript, les opérations mathématiques non définies entraînent NAN (pas un nombre). Ainsi, lorsque vous divisez zéro par zéro en javascript, le résultat est nan.

Quelle est la différence entre Nan et Infinity en JavaScript?

Dans JavaScript, Nan (pas un nombre) et l'infini sont des valeurs spéciales. Nan représente une valeur qui n'est pas un nombre juridique, généralement en raison d'opérations mathématiques non définies ou incertaines. Infinity, en revanche, représente un nombre plus grand que n'importe quel nombre possible, généralement en raison de la division du nombre de zéro.

Comment vérifier si le résultat en JavaScript est nan?

Vous pouvez utiliser la fonction isnan () dans JavaScript pour vérifier si le résultat est nan. Si le paramètre est NAN, cette fonction renvoie vrai, sinon faux.

Comment vérifier si le résultat en JavaScript est Infinity?

Vous pouvez utiliser la fonction isfinite () dans JavaScript pour vérifier si le résultat est un numéro fini. Si le paramètre est positif ou négatif, cette fonction renvoie false, autrement vrai.

Quelle est la signification du nombre primitif en javascript?

Le nombre primitif en JavaScript est utilisé pour représenter les valeurs numériques. Il peut représenter les valeurs entières et les nombres de points flottants. Cependant, il ne peut représenter que de manière fiable des nombres jusqu'à 2 ^ 53-1.

Comment gérer de grands nombres en JavaScript?

Pour gérer de grands nombres qui dépassent la limite entière sécurisée JavaScript, vous pouvez utiliser des objets BigInt. Bigint vous permet de représenter des entiers supérieurs à 2 ^ 53-1.

Qu'est-ce que RangeError en JavaScript?

JavaScript lance un plageerror lorsque la valeur n'est pas dans la plage attendue. Par exemple, essayer de diviser BigInt par zéro se traduit par un plageerror.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!