En JavaScript, les opérations mathématiques peuvent être mises en œuvre via deux opérations:
1. +, -,, *, /,% et autres opérateurs.
2. Utilisez la fonction de calcul de l'objet mathématique. Par exemple, utilisez Math.Pow (2,3) pour calculer la puissance de 2 à 3.
Contrairement à Java, les opérations mathématiques en JavaScript ne lancent aucune erreur. Le débordement du résultat du calcul, la division par 0, et les nombres négatifs au carré sont tous légaux, et le résultat est une valeur particulière en JavaScript: plus ou négative infinity (infinité), plus ou négatif 0, nan (non-nombre):
1. Infinity positive et négative. Lorsque le résultat du calcul est supérieur au nombre maximum que JavaScript peut représenter (numéro.max_value), le résultat est une infinité positive; Lorsque le résultat du calcul est inférieur au nombre minimum que JavaScript peut représenter (-number.max_value), le résultat est une infinité négative. Les opérations mathématiques telles que +, -, * et / liées à l'infini suivent toutes les règles de calcul de limite en mathématiques avancées. Le résultat de 1/0 est l'infini positif, et le résultat de -1/0 est l'infini négatif.
2. Plus ou moins 0. Lorsque le résultat de calcul est positif mais inférieur à la décimale minimale (nombre.min_value) que JavaScript peut représenter, le résultat est positif 0; Lorsque le résultat du calcul est négatif mais supérieur à la décimale négative maximale (-nombr.min_value) que JavaScript peut représenter, le résultat est négatif 0. Généralement, les développeurs n'ont pas besoin de se soucier de la différence entre plus et moins 0.
3.Nan. Pour certains résultats de calcul spéciaux qui ne peuvent pas être représentés même avec l'infini positif et négatif, JavaScript utilise NAN pour les représenter (il convient de noter que bien que NAN signifie littéralement "non-nombre", son type est numéro). Ces calculs spéciaux comprennent:
1) .0 / 0.
2) .Infinity / Infinity.
3). Nombres négatifs carrés.
4). Effectuer des opérations de conversion numérique sur les chaînes non nucères.
Pour Infinity et Nan, ils sont à la fois des résultats "infinis" et "non-nombre", et sont également des noms de variables globaux représentant ces deux valeurs spéciales en JavaScript. En fait, dans ECMAScript 3, ces deux variables globales peuvent également se voir attribuer d'autres valeurs; Cette règle folle a été corrigée dans Ecmascript 5 pour rendre ces deux variables globales en lecture seule. En plus d'accès directement à la variable Infinity et à la variable NAN, vous pouvez également utiliser ces deux valeurs spéciales en accédant aux variables membre de l'objet numéro:
1.Infinity est équivalent à Number.Positive_infinity.
2. L'infinity est équivalent à Number.NEGATIF_INFINITY.
3.Nan équivaut à numéro.nan.
Dans JavaScript, NAN est une valeur spéciale intéressante, qui a une propriété spéciale: elle n'est égale à aucune autre valeur (y compris elle-même). Il existe deux façons de déterminer si une valeur est NAN:
1. Pour la variable x, déterminez si x! = X est vrai. Cette expression n'est vraie que si x est nan.
2. Pour la variable x, appelez la fonction globale ISNAN () en JavaScript pour déterminer si Isnan (x) est vraie. Cette méthode détermine que Nan n'est pas réellement rigoureux, car l'expression isnan (x) est vraie dans 4 cas:
1) .x est nan.
2) .x est une chaîne, et la chaîne n'est pas un nombre.
3) .x est un objet.
4) .x n'est pas défini.
En plus d'Isnan (), JavaScript a une autre fonction globale utile: isFinite (). Pour la variable A, l'isfinite (a) est vrai dans les cas suivants:
1) .A est le nombre, mais pas le NAN ou l'infini positif et négatif.
2) .A est une chaîne, mais le contenu de la chaîne est un numéro d'infini non positif et non positif.
3) .A est nul.
4) .A est la valeur booléenne.
Étant donné que les types non nucères tels que NULL et UNDEFINED auront un impact sur le résultat, je pense personnellement qu'il est préférable de juger le type du paramètre avant d'utiliser Isnan () ou Isfinite ().
expérience
La copie de code est la suivante:
// tester l'infini
var a = nombre.max_value;
Console.log (A * 1.1); // Infinity
console.log (A * -1.1); // - Infinity
Console.log (1/0); // Infinity
console.log (-1/0); // - Infinity
// tester positif / négatif 0
var b = nombre.min_value;
console.log (b / 2); // 0
console.log (-b / 2); // 0
// tester nan
console.log (0/0); // nan
console.log (Infinity / Infinity); // nan
console.log (math.sqrt (-1)); // nan
console.log (parseInt ("string")); // nan
// Tester la comparaison de l'infini
console.log (infinité === numéro.Positive_infinity); // true
console.log (-infinity === numéro.negative_infinity); // true
// Tester la comparaison NAN
console.log (nan === nan); // false
// tester ISNAN ()
console.log (Isnan (nan)); // vrai
console.log (isnan ("42")); // false
console.log (isnan ("string")); // true
console.log (isnan ({})); // true
console.log (Isnan (non défini)); // vrai
console.log (Isnan (null)); // false
// tester isfinite ()
console.log (isfinite (42)); // true
console.log (isfinite (infinité)); // false
console.log (isfinite (nan)); // false
console.log (isfinite ("29")); // true
console.log (isfinite ("string")); // false
console.log (isfinite (null)); // true
console.log (isfinite (non défini)); // false
console.log (isfinite (true)); // true
console.log (isfinite (false)); // true