que sont les opérateurs arithmétiques javascript

En JavaScript, les opérateurs arithmétiques sont des symboles utilisés pour effectuer des opérations arithmétiques sur des nombres (littéraux ou variables), notamment : l'opérateur d'addition "+", l'opérateur de soustraction "-" et l'opérateur de multiplication "*", l'opérateur de division "/", le reste opérateur "%", opérateur de négation numérique "-".

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

En JavaScript, les opérateurs arithmétiques sont un symbole utilisé pour effectuer des opérations arithmétiques sur des nombres (littéraux ou variables) ; ce sont des symboles utilisés pour effectuer des opérations arithmétiques de base (opérateurs arithmétiques) et sont utilisés pour traiter les quatre opérations arithmétiques.

Les opérateurs arithmétiques incluent : l'addition +, la soustraction -, la multiplication *, la division /, l'opérateur reste %, et l'opérateur de négation numérique -.

Opérateur	Description	Exemple
+	Opérateur d'ajout	x + y signifie calculer la somme de x plus y
-	Opérateur de soustraction	x-y Représente le calcul de la différence de x moins y
*	Opérateur de multiplication	x * y Représente le calcul du produit de x fois y
/	Opérateur de division	x / y Représente le calcul de x divisé par y Le quotient de
%	opérateur modulo (reste)	x % y signifie calculer le reste de x divisé par y

opérateur d'addition

Exemple 1

Faites attention à la somme opération de formation d'opérandes spéciaux.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN + n);  //NaN与任意操作数相加，结果都是NaN
console.log(Infinity + n);  //Infinity与任意操作数相加，结果都是Infinity
console.log(Infinity + Infinity);  //Infinity与Infinity相加，结果是Infinity
console.log((-Infinity) + (-Infinity));  //负Infinity相加，结果是负Infinity
console.log((-Infinity) + Infinity);  //正负Infinity相加，结果是NaN

Exemple 2

L'opérateur d'addition peut décider d'ajouter ou de se connecter en fonction du type de données des opérandes.

console.log(1 + 1);  //如果操作数都是数值，则进行相加运算
console.log(1 + "1");  //如果操作数中有一个是字符串，则进行相连运算
console.log(3.0 + 4.3 + "");  //先求和，再连接，返回"7.3"
console.log(3.0 + "" + 4.3);  //先连接，再连接，返回"34.3"
                              //3.0转换为字符串3

Lorsque vous utilisez l'opérateur d'addition, vous devez d'abord vérifier si le type de données de l'opérande répond aux exigences.

Opérateur de soustraction

Exemple 1

Faites attention à l'opération de soustraction des opérandes spéciaux.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN - n);  //NaN与任意操作数相减，结果都是NaN
console.log(Infinity - n);  //Infinity与任意操作数相减，结果都是Infinity
console.log(Infinity - Infinity);  //Infinity与Infinity相减，结果是NaN
console.log((-Infinity) - (-Infinity));  //负Infinity相减，结果是NaN
console.log((-Infinity) - Infinity);  //正负Infinity相减，结果是-Infinity

Exemple 2

Dans l'opération de soustraction, si l'opérande est une chaîne, essayez de la convertir en valeur numérique avant d'effectuer l'opération. Si l'un des opérandes n'est pas un nombre, NaN est renvoyé.

console.log(2 - "1");  //返回1
console.log(2 - "a");  //返回NaN

Utilisez la valeur moins 0 pour convertir rapidement la valeur en nombre. Par exemple, les chaînes de requête dans les requêtes HTTP sont généralement des numéros de chaîne. Vous pouvez d'abord soustraire 0 de ces valeurs de paramètres pour les convertir en valeurs numériques. Cela a le même résultat que l’appel de la méthode parseFloat(), mais la soustraction est plus efficace et plus rapide. Les conversions implicites avec l'opérateur de soustraction renvoient NaN si elles échouent, ce qui est différent de la valeur de retour lors de l'exécution de la conversion à l'aide de la méthode parseFloat().

Par exemple, pour la chaîne "100aaa", la méthode parseFloat() peut analyser les premiers nombres, mais pour l'opérateur de soustraction, il doit s'agir d'un nombre complet avant de pouvoir être converti.

console.log(parseFloat("100aaa"));  //返回100
console.log("100aaa" - 0);  //返回NaN

Pour les valeurs booléennes, la méthode parseFloat() peut convertir true en 1 et false en 0, tandis que l'opérateur de soustraction le traite comme NaN.

Pour les objets, la méthode parseFloat() tentera d'appeler la méthode toString() de l'objet pour la conversion, tandis que l'opérateur de soustraction essaiera d'abord d'appeler la méthode valueOf() de l'objet pour la conversion, puis appellera toString() pour la conversion après un échec. .

Opération de négation

L'opérateur de négation est un opérateur unaire, également connu sous le nom d'opérateur de soustraction unaire.

Exemple

Faites attention à l'opération de négation des opérandes spéciaux.

console.log(- 5);  //返回-5。正常数值取负数
console.log(- "5");  //返回-5。先转换字符串数字为数值类型
console.log(- "a");  //返回NaN。无法完全匹配运算，返回NaN
console.log(- Infinity);  //返回-Infinity
console.log(- (- Infinity));  //返回Infinity
console.log(- NaN);  //返回NaN

L'opérateur de soustraction unaire correspondant est l'opérateur d'addition unaire, qui peut être utilisé pour convertir rapidement une valeur en valeur numérique.

Opérateur de multiplication

Faites attention à l'opération de multiplication des opérandes spéciaux.

var n = 5;  //定义并初始化任意一个数值
console.log(NaN * n);  //NaN与任意操作数相乘，结果都是NaN
console.log(Infinity * n);  //Infinity与任意非零正数相乘，结果都是Infinity
console.log(Infinity * (- n));  //Infinity与任意非零负数相乘，结果是-Infinity
console.log(Infinity * 0);  //Infinity与0相乘，结果是NaN
console.log(Infinity * Infinity);  //Infinity与Infinity相乘，结果是Infinity

Opérateur de division

Faites attention au fonctionnement de la division des opérandes spéciaux.

var  n = 5;  //定义并初始化任意一个数值
console.log(NaN / n);  //如果一个操作数是NaN，结果都是NaN
console.log(Infinity / n);  //Infinity被任意数字除，结果是Infinity或-Infinity
                            //符号由第二个操作数的符号决定
console.log(Infinity / Infinity);  //返回NaN
console.log(n / 0);  //0除一个非无穷大的数字，结果是Infinity或-Infinity，符号由第二个操作数的符号决定
console.log(n / -0);  //返回-Infinity，解释同上

Opérateur de reste

L'opération de reste est également appelée opération modulaire. Par exemple :

console.log(3 % 2);  //返回余数1

L'opération modulaire fonctionne principalement sur des nombres entiers, mais s'applique également aux nombres à virgule flottante. Par exemple :

console.log(3.1 % 2.3);  //返回余数0.8000000000000003

Exemple

Faites attention à l'opération restante des opérandes spéciaux.

var n = 5;  //定义并初始化任意一个数值
console.log(Infinity % n);  //返回NaN
console.log(Infinity % Infinity);  //返回NaN
console.log(n % Infinity);  //返回5
console.log(0 % n);  //返回0
console.log(0 % Infinity);  //返回0
console.log(n % 0);  //返回NaN
console.log(Infinity % 0);  //返回NaN

【Recommandations associées : Tutoriel d'apprentissage Javascript】

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!