Comprendre les opérateurs JavaScript

En JavaScript, les opérateurs sont des symboles spéciaux ou des mots-clés utilisés pour effectuer des opérations sur des valeurs et des variables. Ils nous permettent de manipuler les données et de contrôler le flux du code. Décomposons les types d'opérateurs les plus couramment utilisés et leurs objectifs :

1️⃣ Opérateurs d'affectation (=)

L'opérateur d'affectation est utilisé pour attribuer des valeurs aux variables.
? Exemple :

let x = 10 // Assigns the value 10 to variable x
let y = 5 // Assigns the value 5 to variable y

2️⃣ Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des opérations mathématiques de base sur les nombres.

1. (Ajout)
2. - (Soustraction)
3. * (Multiplication)
4. / (Division)
5. % (Module – reste de la division)
6. ** (Exponentiation (ES2016))
7. (Incrément)
8. -- (Décrément)

? Exemple :

console.log("x + y = " + (x + y)) // Output: x + y = 15
console.log("x - y = " + (x - y)) // Output: x - y = 5
console.log("x / y = " + (x / y)) // Output: x / y = 2
console.log("x * y = " + (x * y)) // Output: x * y = 50
console.log("x % y = " + (x % y)) // Output: x % y = 0
console.log("(x**y) = " + (x**y)) // Output: (x**y) = 100000
console.log("(++x) = " + (++x)) // Output: (++x) = 11
console.log("(x++) = " + (x++)) // Output: (x++) = 11
console.log("(--y) = " + (--y)) // Output: (--y) = 4
console.log("(y--) = " + (y--)) // Output: (y--) = 4

3️⃣ Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et renvoient un booléen (vrai ou faux). Ceux-ci sont souvent utilisés dans les boucles et les instructions de branchement.

1. == (Égal à)
2. === (Strictement égal à)
3. != (Différent de)
4. !== (Strictement différent de)
5. < (Moins de)
6. > (Supérieur à)
7. <= (Inférieur ou égal à)
8. >= (Supérieur ou égal à)

? Exemple :

console.log("(x == y) = " + (x == y)) // Output: (x == y) = false
console.log("(x != y) = " + (x != y)) // Output: (x != y) = true
// Compares datatypes also
console.log("(x === y) = " + (x === y)) // Output: (x === y) = false
// Compares datatypes also
console.log("(x !== y) = " + (x !== y)) // Output: (x !== y) = true
console.log("(x > y) = " + (x > y)) // Output: (x > y) = true
console.log("(x >= y) = " + (x >= y)) // Output: (x >= y) = true
console.log("(y < x) = " + (y < x)) // Output: (y < x) = true
console.log("(y <= x) = " + (y <= x)) // Output: (y <= x) = true

4️⃣ Opérateurs logiques

Les opérateurs logiques sont utilisés pour effectuer des opérations logiques et renvoyer une valeur booléenne (vrai ou faux).

1. && (ET logique)
2. || (OU logique)
3. ! (NON logique)

? Exemple :

let isValidNumber = (x > 8 && 8 > y) // If both condition are correct returns true otherwise false
console.log("(x > 8 && 8 > y) = " + isValidNumber) // Output: (x > 8 && 8 > y) = true

let isValidCheck = (x > 20 || 8 > y) // If one of condition is correct returns true otherwise false
console.log("(x > 20 || 8 > y) = " + isValidCheck) // Output: (x > 20 || 8 > y) = true

let isValid = false
console.log("(!isValid) = " + !isValid) // Output: (!isValid) = true

5️⃣ Opérateurs de chaînes

L'opérateur est polyvalent et peut être utilisé avec des chaînes pour la concaténation (joindre deux chaînes). Lorsqu'il est utilisé avec des nombres, il effectue une addition.

? Exemple :

// Concatenation
console.log("Richa " + "webDev") // Output: Richa webDev 
// Addition
console.log(10 + 5) // Output: 15

6️⃣ Opérateur Ternaire (? :)

L'opérateur ternaire est un moyen concis d'effectuer des vérifications conditionnelles. Il renvoie une valeur si la condition est vraie et une autre si elle est fausse.
? Syntaxe :

condition ? valueIfTrue : valueIfFalse;

? Exemple :

const isEven = 10 % 2 === 0 ? "Number is even" : "Number is old"
console.log("isEven = " + isEven) // Output: isEven = Number is even

? Casse-tête

Expliquez pourquoi la sortie de l'extrait de code, impliquant les opérations num , --num et num--, donne la valeur 21. Commentez ci-dessous.

let num = 20
console.log("num = " + num) // Output: (++num) = 21
console.log("(++num) = " + (++num)) // Output: (++num) = 21
console.log("(num++) = " + (num++)) // Output: (num++) = 21
console.log("(--num) = " + (--num)) // Output: (--num) = 21
console.log("(num--) = " + (num--)) // Output: (num--) = 21

Sortie :

num = 20
(++num) = 21
(num++) = 21
(--num) = 21
(num--) = 21

Conclusion

Les opérateurs JavaScript sont des éléments fondamentaux qui vous aident à écrire du code efficace et efficient. En les maîtrisant, vous pouvez effectuer un large éventail d'opérations, des simples affectations aux contrôles logiques complexes. Expérimentez avec ces opérateurs pour mieux comprendre leur comportement !
Bon codage ✨

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!