Comment implémenter les opérations d'addition, de soustraction, de multiplication et de division en javascript

Méthode d'implémentation : 1. Utilisez les symboles "+", "-", "*", "/" et "%" pour implémenter les opérations d'addition, de soustraction, de multiplication, de division et de reste ; Les symboles "-=", "*=" et "/=" effectueront d'abord des opérations d'addition, de soustraction, de multiplication et de division, puis attribueront les résultats aux variables sur le côté gauche de l'opérateur 3. Utilisez le " ; Symboles ++x" ou "x++" La valeur de la variable est incrémentée (+1), et le caractère "--x" ou "x--" est utilisé pour décrémenter la valeur de la variable (-1).

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

En JavaScript, vous pouvez utiliser des opérateurs pour implémenter les quatre opérations arithmétiques d'addition, de soustraction, de multiplication et de division. Les opérateurs sont des symboles utilisés pour indiquer au moteur JavaScript d'effectuer une certaine opération. Par exemple, le signe plus (+) représente une addition, le signe moins (-) représente une soustraction, etc.

1 : Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques courantes, telles que l'addition, la soustraction, la multiplication, la division, etc. Le tableau suivant répertorie les opérateurs arithmétiques pris en charge en JavaScript :

描 Curchase述 Description opérateur de soustraction Opérateur de multiplicationOpérateur de divisionopérateur de module (reste)

Exemple		+
x + y indique que le calcul de X plus y et		-
x -y indique le calcul X Soustraire la différence de y		*
x * y signifie calculer le produit de x fois y		/
x / y signifie calculer le quotient de x divisé par y		%

x % y signifie calculer le reste de x divisé par y🎜🎜🎜🎜

Opérateur d'addition

Exemple 1

Faites attention à l'opération de sommation 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相加，结果是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 essaie d'abord d'appeler la méthode valueOf() de l'objet pour la conversion, puis appelle toString() pour la conversion après un échec. .

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

2 : Opérateur d'affectation

L'opérateur d'affectation est utilisé pour attribuer des valeurs aux variables. Il a les deux formes suivantes :

• Opération d'affectation simple = : Copie directement la valeur de l'opérande sur le côté droit du signe égal à l’opérande gauche, donc la valeur de l’opérande gauche change.

• Opération d'affectation d'opérations supplémentaires : avant d'attribuer, effectuez une opération sur l'opérande de droite, puis copiez le résultat de l'opération dans l'opérande de gauche.

Les quatre opérations arithmétiques d'addition, de soustraction, de multiplication et de division peuvent être réalisées par quelques opérations d'affectation supplémentaires. La description spécifique est présentée dans le tableau :

Opération d'addition ou de concaténation et affectationa += ba = a + b-=

Opérateur d'affectation qui implémente les opérations supplémentaires des quatre opérations arithmétiques d'addition, soustraction, multiplication et division

Opérateur d'affectation	Explication	Exemple	équivaut à
+=+=	加法运算或连接操作并赋值	a += b	a = a + b
-=	减法运算并赋值	a -= b	a= a - b
*=	乘法运算并赋值	a *= b	a = a * b
/=	除法运算并赋值	a /= b	a = a / b
%=

Opération et affectation de soustraction

a -= b

a= a - b

*=

Opération et affectation de multiplicationa *= bopération et affectation de division%=L'exemple de code est le suivant :

var x = 10;
x += 20;
console.log(x);  // 输出：30
var x = 12,
    y = 7;
x -= y;
console.log(x);  // 输出：5
x = 5;
x *= 25;
console.log(x);  // 输出：125
x = 50;
x /= 10;
console.log(x);  // 输出：5
x = 100;
x %= 15;
console.log(x);  // 输出：10

Trois : opérateurs d'auto-incrémentation et d'auto-décrémentationOpérateur.

a = a * b		/=
a /= b	a = a/b
fonctionnement et affectation du module	a %= b	a = a % b
	Les opérateurs d'incrémentation et de décrémentation automatiques sont utilisés. Effectuez des opérations d'incrémentation (+1) et de décrémentation (-1) sur la valeur d'une variable. Le tableau suivant répertorie les opérateurs d'incrémentation et de décrémentation pris en charge en JavaScript :

Nom

Impact ++x

🎜Opérateur d'incrémentation🎜🎜incrémente x de 1 puis renvoie la valeur de x🎜🎜🎜🎜x++🎜🎜Opérateur d'incrémentation🎜🎜renvoie la valeur de x puis incrémente x par 1🎜 🎜🎜🎜--x🎜🎜opérateur de décrémentation🎜🎜décrémente x de 1 puis renvoie la valeur de x🎜🎜🎜🎜x--🎜🎜opérateur de décrémentation🎜🎜renvoie la valeur de x puis décrémente x de 1 🎜 🎜🎜🎜🎜L'exemple de code est le suivant : 🎜

var x;

x = 10;
console.log(++x);  // 输出：11
console.log(x);    // 输出：11

x = 10;
console.log(x++);  // 输出：10
console.log(x);    // 输出：11

x = 10;
console.log(--x);  // 输出：9
console.log(x);    // 输出：9

x = 10;
console.log(x--);  // 输出：10
console.log(x);    // 输出：9

🎜[Recommandations associées : 🎜Tutoriel vidéo javascript🎜, 🎜Vidéo de programmation de base🎜]🎜

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!