Discutez de certains opérateurs JavaScript courants et de leur utilisation

En JavaScript, un opérateur est un symbole spécial utilisé pour opérer sur des types de données tels que des nombres, des chaînes et des valeurs booléennes. Cet article abordera certains opérateurs JavaScript courants et leur utilisation.

1. Opérateurs arithmétiques

Les opérateurs arithmétiques incluent l'addition, la soustraction, la multiplication, la division, le reste, etc. Par exemple :

var a = 10;
var b = 3;
var c = a + b; // 加，结果为13
var d = a - b; // 减，结果为7
var e = a * b; // 乘，结果为30
var f = a / b; // 除，结果为3.3333333333333335
var g = a % b; // 求余，结果为1

2. Opérateur d'affectation

L'opérateur d'affectation est utilisé pour attribuer une valeur à une variable. Par exemple :

var a = 10;
var b = a; // 将a的值赋给b

De plus, il existe des opérateurs d'affectation de combinaison, tels que :

var a = 10;
a += 5; // 等价于a = a + 5，结果为15
a -= 3; // 等价于a = a - 3，结果为12
a *= 2; // 等价于a = a * 2，结果为24
a /= 4; // 等价于a = a / 4，结果为6
a %= 2; // 等价于a = a % 2，结果为0

3. Opérateurs de comparaison

#🎜 🎜 Les opérateurs #Comparison sont utilisés pour comparer la taille ou l'égalité de deux valeurs. Par exemple :

var a = 10;
var b = 5;
var c = (a > b); // 大于，结果为true
var d = (a < b); // 小于，结果为false
var e = (a >= b); // 大于等于，结果为true
var f = (a <= b); // 小于等于，结果为false
var g = (a == b); // 相等，结果为false
var h = (a != b); // 不相等，结果为true

Notez que == est utilisé pour comparer l'égalité des valeurs, pas l'égalité des types. Par exemple, l'expression suivante est évaluée comme vraie :

var x = 10;
var y = "10";
var z = (x == y); // 结果为true

Opérateurs logiques

Les opérateurs logiques sont utilisés pour traiter les valeurs de type booléen. Par exemple :

var a = true;
var b = false;
var c = !a; // 非，结果为false
var d = a && b; // 与，结果为false
var e = a || b; // 或，结果为true

Parmi eux, ! signifie négation, && signifie ET logique, ne renvoie vrai que lorsque les deux valeurs sont vraies, sinon renvoie faux || les valeurs Si c'est vrai, renvoie vrai, sinon renvoie faux.

opérateur ternaire

L'opérateur ternaire est le seul opérateur en JavaScript qui possède trois opérandes. Il peut être utilisé pour un simple jugement conditionnel. Par exemple :

var a = 10;
var b = (a > 5) ? "大于5" : "小于等于5"; // 如果a大于5，则返回"大于5"，否则返回"小于等于5"

Les opérateurs de chaîne

Les opérateurs de chaîne sont utilisés pour concaténer des chaînes. Par exemple :

var a = "Hello";
var b = "JavaScript";
var c = a + " " + b; // 将a和b连接起来，结果为"Hello JavaScript"

Notez que l'opérateur + peut être utilisé non seulement pour ajouter des nombres, mais également pour la concaténation de chaînes.

Opérateurs d'incrémentation et de décrémentation

Les opérateurs d'incrémentation et de décrémentation peuvent être utilisés pour augmenter ou diminuer la valeur d'une variable. Par exemple :

var a = 10;
a++; // 自增，结果为11
a--; // 自减，结果为10

Vous pouvez également placer les opérateurs d'incrémentation et de décrémentation avant ou après la variable, ce qui affectera l'ordre d'exécution des opérateurs. Par exemple :

var a = 10;
var b = a++; // 先将a的值赋给b，再自增a，结果为b=10、a=11
var c = ++a; // 先自增a，再将a的值赋给c，结果为c=12、a=12

Summary

Cet article présente certains opérateurs courants et leur utilisation en JavaScript, notamment les opérateurs arithmétiques, les opérateurs d'affectation, les opérateurs de comparaison et les opérateurs logiques, l'opérateur ternaire, opérateur de chaîne et opérateurs d’incrémentation et de décrémentation. Une compréhension approfondie de l'utilisation de ces opérateurs nous aidera à mieux maîtriser les compétences en programmation 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!