Les opérateurs

Opérateurs arithmétiques

Addition : +
Incrément : ++
- ajoute un à son opérande
- utilisé en opérateur :
  - préfixe (++x) : renvoie la valeur de son opérande après y avoir ajouté un
  - postfixe (x++) : renvoie la valeur de l'opérande avant l'ajout de un
  - dans la pratique : l'usage de x++ est quasi exclusif (cf structures de contrôle).
Décrément : --
- ajoute un à son opérande
- utilisé en opérateur :
  - préfixe (--x) : renvoie la valeur de son opérande après y avoir soustrait un
  - postfixe (x--) : renvoie la valeur de l'opérande avant la soustraction de un
  - dans la pratique : '--' est bien moins utilisé que '++'
Multiplication : *
Division : /
Exposant : ** (ex : 2**3 donne 8)
Modulo : % (le reste d'une division)

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 :

opérateur : réalise une opération...
opérande : valeur sur laquele l'opération est réalisé...
++ et -- sont des opérateurs unaires (un opérande)
+, -, *, /, etc. sont des opérateurs binaires (deux opérandes)
il existe egalement des opérateurs ternaires (trois opérandes), que nous aborderons dans le cours suivant

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;

L'opérateur d'affectation après ET logique n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est équivalent à vrai (truthy).
L'opérateur d'affectation après OU logique n'affecte la valeur de l'opérande droit uniquement si l'opérande gauche est équivalent à faux (falsy).
L'opérateur d'affectation après coalescence des nuls effectue une affectation uniquement si l'opérande de gauche vaut null ou undefined.

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 :

peuvent se cumuler ad nauseam (a && b && c && d && e)
peuvent sembler triviaux. Les sous estimer peut conduire à des erreurs pénibles (!(a&&b) = !a || !b), utilise lorsque vous devez "renverser une condition").
Nous tacherons de voir ce point une fois les notions de bases acquises.

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

les opérateurs binaires
les opérateurs binaires logiques
les opérateurs de décalage binaires
...

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