Les opérateurs

Opérateurs arithmétiques

let iNumber = 3; // Autre exemple de variable mal nomée... console.log(++iNumber); // iNumber vaut 4, affiche 4 console.log(iNumber++); // iNumber vaut 3, affiche 3

Terminologie :

La connaissance des termes exactes vous sera toujours utile lors de recherche d'informations précises, ou simplement pour communiquer de manière efficace dans le jargon du dev.

A quoi sert le modulo ?

Affectation

Nom Opérateur Signification
Affectation x = y x = y
Affectation après addition x += y x = x + y
Affectation après soustraction x -= y x = x - y
Affectation après multiplication x *= y x = x * y
Affectation après division x /= y x = x / y
Affectation du reste x %= y x = x % y
Affectation après exponentiation x **= y x = x ** y
Affectation après ET logique x &&= y x && (x = y)
Affectation après OU logique x ||= y x || (x = y)
Affectation après coalescence des nuls x ??= y x ?? (x = y)

en JS, on est libre... Vous pouvez affecter une expression, une valeur, et meme une fonction.

il est fortement deconseille d'utiliser la version chainée

var a = b = c = 1;
Poru eviter les effets indesirables, mieux vaut prendre son temps
var a = 1; var b = 1; var c = 1;
const oRace = { sTitle : '', iDuration : 50, iCar : 0, }; // ******************************************** oRace.iDuration &&= 10; console.log(oRace.iDuration); // Affiche : 10 oRace.iCar &&= 20; console.log(oRace.oTitle); // affiche : 0 // ******************************************** oRace. iDuration ||= 10; console.log(oRace.iDuration); // Affiche : 50 oRace.iTitle ||= 'title is empty.'; console.log(oRace.iTitle); // affiche : "title is empty" // ******************************************** oRace.iDuration ??= 10; console.log(oRace.iDuration); // Affiche : 50 oRace.iSpeed ??= 25; console.log(oRace.iSpeed); // Affiche : 25

Opérateurs de comparaison

// Pour les exemples ci dessous let var1 = 3; let var2 = 4;
Opérateur Description Exemples qui renvoient true
Égalité (==) Renvoie true si les opérandes sont égaux (après conversion implicite). 3 == var1
"3" == var1
3 == '3'
Inégalité (!=) Renvoie true si les opérandes sont différents (après conversion implicite). var1 != 4
var2 != "3"
Égalité stricte (===)i Renvoie true si les opérandes sont égaux et du même type. Voir également Object.is() et l'égalité en JavaScript. 3 === var1
Inégalité stricte (!==) Renvoie true si les opérandes sont du même type et différents ou s'ils ne sont pas du même type. var1 !== "3"
3 !== '3'
Supériorité stricte (>) Renvoie true si l'opérande gauche est strictement supérieur à l'opérande droit. var2 > var1
"12" > 2
Supériorité (>=) Renvoie true si l'opérande gauche est supérieur ou égal à l'opérande droit. var2 >= var1
var1 >= 3
Infériorité stricte (<) Renvoie true si l'opérande gauche est strictement inférieur à l'opérande droit. var1 < var2
"2" < 12
Infériorité (<=) Renvoie true si l'opérande gauche est inférieur ou égal à l'opérande droit. var1 <= var2
var2 <= 5

Opérateurs logiques

Opérateur Utilisation Description
ET logique (&&) expr1 && expr2 Renvoie expr1 si elle peut être convertie en false et renvoie expr2 sinon. Lorsqu'il est utilisé avec des valeurs booléennes, && renvoie true si les deux opérandes valent true et false sinon.
OU logique (||) expr1 || expr2 Renvoie expr1 si elle peut être convertie en true et renvoie expr2 sinon. Lorsqu'il est utilisé avec des valeurs booléennes, || renvoie true si l'un des deux opérandes vaut true et false si les deux valent false.
NON logique (!) !expr Renvoie false si son unique opérande peut être converti en true, renvoie true sinon.

les opérateurs logiques peuvent :

Decomposition

const aCount = ['un', 'deux', 'trois']; // sans décomposition const sCount0 = aCount[0]; const sCount1 = aCount[1]; const sCount2 = aCount[2]; // avec décomposition const [sCount0, sCount1, sCount2] = aCount;

Nous ne verrons pas...

Ils sont plus complexes, rarement utilisés. Sachez qu'ils existent pour vous reporter à la documentation en cas de besoin.