Introduction aux opérations mathématiques dans les compétences JavaScript_javascript

En JavaScript, les opérations mathématiques peuvent être implémentées à travers deux opérations :

1. , -, *, /, % et autres opérateurs.
2. Utilisez la fonction de calcul de l'objet Math. Par exemple, utilisez Math.pow(2,3) pour calculer 2 élevé à la puissance trois.

Contrairement à Java, les opérations mathématiques en JavaScript ne génèrent aucune erreur. Les opérations telles que le débordement des résultats de calcul, la division par 0 et la prise de la racine carrée de nombres négatifs sont toutes légales. Les résultats sont des valeurs spéciales en JavaScript : Infini positif et négatif (infini), 0 positif et négatif, NaN (pas un). numéro):

1. Infini positif et négatif. Lorsque le résultat du calcul est supérieur au nombre maximum que JavaScript peut représenter (Number.MAX_VALUE), le résultat est Infini positif ; lorsque le résultat du calcul est inférieur au nombre minimum que JavaScript peut représenter (-Number.MAX_VALUE), le résultat est positif. Infini négatif. Les opérations mathématiques telles que , -, * et / liées à l'infini suivent les règles de calcul des limites en mathématiques avancées. Le résultat de 1/0 est un Infini positif et le résultat de -1/0 est un Infini négatif.

2. Plus ou moins 0. Lorsque le résultat du calcul est positif, mais inférieur à la plus petite décimale négative que JavaScript peut représenter (Number.MIN_VALUE), le résultat est positif 0 ; lorsque le résultat du calcul est négatif, mais supérieur à la plus grande décimale négative que JavaScript peut représenter (-Number). .MIN_VALUE) , le résultat est négatif 0. Normalement, les développeurs n'ont pas besoin de se soucier de la différence entre 0 positif et négatif.

3.NaN. Pour certains résultats de calcul spéciaux qui ne peuvent pas être exprimés même avec un infini positif et négatif, JavaScript utilise NaN pour le représenter (il convient de noter que bien que NaN signifie littéralement « pas un nombre », son type est un nombre). Ces calculs spéciaux incluent :

1).0/0.
2).Infini/Infini.
3). Prenez la racine carrée des nombres négatifs.
4). Effectuez des opérations de conversion numérique sur des chaînes non numériques.

Pour Infinity et NaN, il ne s'agit pas seulement des résultats imprimés de "infini" et "pas un nombre", mais aussi des noms de variables globales 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 exaspérante a été révisée dans ECMAScript 5, rendant ces deux variables globales en lecture seule. En plus d'accéder directement à la variable Infinity et à la variable NaN, vous pouvez également utiliser ces deux valeurs spéciales en accédant aux variables membres de l'objet Number :

1.Infinity équivaut à Number.POSITIVE_INFINITY.
2.-Infinity est équivalent à Number.NEGATIVE_INFINITY.
3.NaN est équivalent à Number.NaN.

En JavaScript, NaN est une valeur spéciale très intéressante. Elle possède une propriété particulière : 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. Utiliser cette méthode pour déterminer NaN n'est en fait pas rigoureux, car l'expression isNaN(x) est vraie dans quatre 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 de isNaN(), JavaScript possède une autre fonction globale utile : isFinite(). Pour la variable a, isFinite(a) est vrai dans les situations suivantes :

1).a est un nombre, mais pas NaN ou l'Infini positif ou négatif.
2).a est une chaîne, mais le contenu de la chaîne est un nombre infini non NaN, non positif ou négatif.
3).a est nul.
4).a est une valeur booléenne.

Étant donné que les types non numériques tels que null et undefined affecteront le résultat, je pense personnellement qu'il est préférable de déterminer le type du paramètre avant d'utiliser isNaN() ou isFinite().

Expérimenter

Copier le code Le code est le suivant :

//Test Infini
var a = Nombre.MAX_VALUE;
console.log(a*1.1);//Infini
console.log(a*-1.1);//-Infinity
console.log(1/0);//Infini
console.log(-1/0);//-Infini

//Test positif/négatif 0
var b = Nombre.MIN_VALUE;
console.log(b/2);//0
console.log(-b/2);//0

//Test NaN
console.log(0/0);//NaN
console.log(Infinity/Infinity);//NaN
console.log(Math.sqrt(-1));//NaN
console.log(parseInt("string"));//NaN

//Comparaison Test Infinity
console.log(Infinity === Number.POSITIVE_INFINITY);//true
console.log(-Infinity === Number.NEGATIVE_INFINITY);//true

//Test de comparaison NaN
console.log(NaN === NaN);//false

//Test isNaN()
console.log(isNaN(NaN));//true
console.log(isNaN("42"));//false
console.log(isNaN("string"));//true
console.log(isNaN({}));//true
console.log(isNaN(undefined));//true
console.log(isNaN(null));//false

//Test isFinite()
console.log(isFinite(42));//true
console.log(isFinite(Infinity));//false
console.log(isFinite(NaN));//false
console.log(isFinite("29"));//true
console.log(isFinite("string"));//false
console.log(isFinite(null));//true
console.log(isFinite(undefined));//false
console.log(isFinite(true));//true
console.log(isFinite(false));//true