Quels sont les opérateurs arithmétiques javascript ?

Les opérateurs arithmétiques Javascript incluent : l'opérateur d'addition "+", l'opérateur de soustraction "-", l'opérateur de multiplication "*", l'opérateur de division "/", l'opérateur de reste "%", l'opérateur d'incrémentation "++" ", l'opérateur de décrémentation "-- ", opérateur électrique "**".

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

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques sur des nombres (littéraux ou variables). Les opérateurs arithmétiques standards sont l'addition +, la soustraction -, la multiplication * et la division /. C’est très similaire à l’addition, la soustraction, la multiplication et la division en mathématiques. Examinons-les ensemble.

Opérateur d'addition

L'opérateur d'addition + est utilisé pour additionner des valeurs numériques, ce qui devrait être très simple.

Exemple :

Ce qui suit est une simple somme de deux nombres :

var a = 8;
var b = a + 5;
console.log(b);  // 13

+ Invoquer des opérateurs En plus de calculer la somme de deux nombres, nous pouvons concaténer des chaînes via + et le résultat est une nouvelle chaîne.

Exemple :

Utilisez + pour connecter les trois variables définies :

str1 = "hello";
str2 = "xkd";
str3 = " ";
console.log(str1 + str3 + str2);  // 输出： hello xkd

De plus, les nombres et une chaîne peuvent également être connectés via le signe + plus, et le résultat renvoyé est également une chaîne.

Exemple :

Regardez la différence entre l'ajout de nombres et de nombres, et l'ajout de nombres et de chaînes :

num1 = 10;
num2 = 15;
str1 = "15"

console.log(num1 + num2 );  // 输出： 25
console.log(num1 + str1 );  // 输出：1015

Notez que dans certains langages de programmation (tels que Python), différents types ne peuvent pas être ajoutés, par exemple l'ajout d'un nombre à une chaîne entraînera une erreur. En JavaScript, des nombres et des chaînes sont ajoutés et une chaîne est renvoyée.

Opérateur de soustraction

L'opérateur de soustraction - peut être utilisé pour soustraire deux opérandes, et le résultat est leur différence.

Exemple :

var c = 8;
var d = c - 5;
console.log(d);  // 3

En 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é.

Exemple :

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

Utilisez une valeur moins 0 pour convertir rapidement une 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. .

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

Opération de négation

Faites attention à l'opération d'inversion 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

Opérateur de multiplication

Le résultat de l'opérateur de multiplication * est le produit des opérandes.

Exemple :

var e = (8 + 5) * 3;
var f = 'xkd' * 3;
console.log(e);  // 输出：39
console.log(f);  // 输出：NaN

Si nous utilisons une chaîne pour multiplier un nombre, elle finira par renvoyer un NaN, qui est un nombre illégal.

Opérateur de division

Le résultat de l'opérateur de division / est le quotient des opérandes. L'opérande de gauche est le dividende et l'opérande de droite est le diviseur.

Exemple :

var g = (9 - 3) / 3;
var h = 3.0 / 1.0;
var i = 1 / 2;

console.log(g);  //输出：2
console.log(h);  //输出：3
console.log(i);  //输出：0.5

Ce que nous devons noter, c'est qu'en JavaScript, les opérations 1 / 2 avec un point décimal dans le résultat auront un point décimal dans le résultat, comme 0.5. Dans des langages tels que Java, il n'est pas nécessaire que le nombre soit un nombre à virgule flottante explicite et le résultat de retour de 1 / 2 est 0.

Opérateur de reste

Signe de pourcentage% est l'opérateur de reste, qui renvoie le modulo (reste) du premier opérande au deuxième opérande, par exemple x % y, le résultat est x divisé par y Reste entier. Tout le monde doit savoir que le reste, que nous avons également appris en mathématiques, fait référence à la partie du dividende qui n'est pas divisée par le déclencheur entier.

Exemple :

Par exemple, le code suivant :

var m = 9;
var n = 2;
var mn = m % n;
console.log(mn);  //输出： 1

Le résultat de sortie est 1, ce qui est en fait facile à comprendre 9 % 2 consiste à trouver le reste de 9 divisé par 2, ce qui est 1.

Donc, si c'est le cas 12 % 5, quel sera le résultat ? Diviser 12 par 5 laisse un reste de 2, donc le résultat est 2. Vous devriez maintenant savoir comment utiliser %.

Opérateur d'incrémentation

L'opérateur d'incrémentation ++ incrémente son opérande de 1 et renvoie une valeur numérique. Si vous utilisez un suffixe, tel que x++, la valeur sera renvoyée avant l'incrémentation. Si elle est ajoutée au début, comme ++x, la valeur sera renvoyée après incrémentation.

Exemple :

假设我们定义了一个变量 i，然后使用自增运算符对 i 进行递增运算，将递增后的 i 赋值给了变量 j，最终j 的输出结果为 6：

var i = 5;
i++;
var j = i;
console.log(j);  // 6

那为什么结果会是6呢，i++ 其实就是表示在 i 的基础上加一，相当于i + 1。

然后我们看一下递增运算符前置和后置，到底有什么区别，例如下面这个代码：

var a = 9;
console.log(a++);  // 输出：9

console.log(a);    // 输出：10

console.log(++a);  // 输出：11

• 变量 a 的值为9，然后使用后置递增运算符a++，第一次输出会在递增之前就返回数值，即输出结果还是 9。
• 然后此时输出 a 的值，可以看到 a 的值已经为10了，因为已经执行了一次递增运算符，所以加 1。
• 接着第三次输出时，使用前置递增运算符，这会在递增之后才返回数值，即输出结果为11。

递减运算符

递减运算符 -- 为其操作数减去1，并返回一个数值。递减运算符和递增运算符的使用方法差不多，一个是减、一个是加，正好相反。

如果后置使用递减运算符，则在递减之前返回数值。如果前置使用，则在递减之后返回数值。

示例：

var b = 7;
console.log(b--);  // 输出：7

console.log(b);    // 输出：6

console.log(--b);  // 输出：5

• 变量b的值为7，然后使用后置递减运算符b--，会在递减之钱返回数值，即7。
• 然后第二次输出变量b，此时已经成功执行b-- ，会在此基础上减1，所以输出6。
• 第三次输出--b，使用后置递减运算符，会在递减之后返回数值，所以会输出5。

幂运算符

幂运算符 ** 返回第一个操作数做底数，第二个操作数做指数的乘方。例如5 ** 2 表示 5 的 2 次方，根据所学数学知道就能得出结果为25。

示例：

下面这个代码表示求 6 的 3 次方，相当于 6 * 6 * 6，结果为216：

var x = 6;
var y = x ** 3;
console.log(y);  // 216

上面的运算出的结果与 Math.pow(x, y) 是相同的，例如：

var x = 6;
var y = Math.pow(x,3);
console.log(y);  // 216

pow()方法可返回 x 的 y 次幂的值。

【推荐学习：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!