Les opérateurs en JavaScript

Opérateur unaire ou opérateur binaire

Les opérateurs sont là pour faire des opérations entre des valeurs ou entre des valeurs qui sont stockées dans des variables c'est la même chose et retourner un résultat. Le résultat de l'opération.

Il existe des opérateurs qui ont deux opérandes. On les appelle les opérateurs binaires. Par exemple l'addition de 4 + 3. Le + est l'opérateur binaire et le 3 et 4 sont les opérandes. Il en existe d'autres qui sont unaire et qui ont une seul opérande par exemple typeof x. Enfin certains opérateurs peuvent être unaire -3 ou binaire 4 - 3. Et il y a encore d'autres cas possibles par exemple l'opérateur ternaire qu'on verra dans un tuto dédié.

Combinaison d'opérateur ou expression

Lorsque l'on combine les opérateurs on obtient une expression. Par exemple 4 + 3 * 7.

Ordre d'évaluation des opérateurs

Si l'on doit faire dans sa tête l'opération suivante 4 + 3 * 7 on a deux solutions :

• faire l'addition en premier ce qui donne 49.
• faire la multiplication en premier ce qui donne 25.

Donc vous voyez bien qu'il va falloir définir un ordre de passage pour décider de qui passe en premier. Ici en l'occurrence l'addition ou la multiplication.

Un langage de programmation établit des règles qui définissent cet ordre de passge. On parle de règles de précédence ou de priorité des opérateurs.

Ici JavaScript va décider de faire la multiplication en premier et l'addition ensuite. On dit que la multiplication est prioritaire par rapport à l'addition. Si ça ne vous convient pas vous avez la solution de parenthéser (4+3)*7.

Les opérateurs arithmétiques + - * / ** %

Ci-dessous vous avez la liste des principaux opérateurs disponibles en JavaScript sur les number.

Opération	Opérateur
Modulo	%
Puissance	**
Division	/
Multiplication	*
Soustraction	-
Addition	+

Ci-dessous vous avez les règles de précédence pour ces opérateurs.

Priorité du plus au moins
()
* / ** %
- +
=

Les situations sont nombreuses et je vous renvoie à cette page si vous avez une difficulté particulière.

Les opérateurs += et -=

On affecte à la variable sa valeur courante et on lui ajoute (ou soustrait) la valeur de l'opérande qui est à droite de l'opérateur.

var x=5; x += 5 ; // Equivalent à x = x + 5; x -= 5 ; // Equivalent à x = x - 5;

Si vous êtes gêné par le x = x + 5; c'est probablement que vous confondez une équation mathématique avec une instruction informatique. On ne parle pas ici d'égalité mais d'affectation !

Les opérateurs d'incrémentation ++ et --

Pour incrémenter on utilise l'opérateur ++ que l'on place soit devant la variable soit derrière la variable.

var x=5; x++; // est équivalent à x = x + 1; alert(x); // Affiche 6

Si c'est devant alors la variable est incrémentée avant son utilisation. Si c'est derrière alors la variable est incrémentée après.

var x=5; alert(x++); // Affiche 5 alert(x); // Affiche 6 var x=5; alert(++x); // Affiche 6 alert(x); // Affiche 6

Pour décrémenter on utilise -- en lieu et place du ++.

Les opérateurs de comparaisons > < >= <= == != === !==

On peut tester si une variable est plus grande x>you plus petite x<yque l'autre.

On peut tester si une variable est égale à une autre == ou bien si une variable est différente d'une autre !=

var x=5; var y=3; alert(x > y); // Affiche true alert(x < y); // Affiche false alert(x == y); // Affiche false alert(x != y); // Affiche true

On peut également tester si elles sont égales et de même type ===. (Il y a bien trois signes =)

var x=0; var y=false; alert(x == y); // Affiche true alert(x === y); // Affiche false

Ici x est égal à y car x avec la valeur 0 est considéré comme ayant la "valeur" booléenne false. Mais x est de type number et y est de type boolean

La concaténation

La principale opération que l'on fait sur des chaînes en utilisant un opérateur est la concaténation. On assemble les chaînes bout à bout. Il en faut deux minimum.

Javascript considère que concaténer des chaînes revient à les ajouter et utilise ici aussi l'opérateur +.

var str1='Le début'; var str2=' et la fin'; alert(str1+str2);

L'opérateur + est donc utilisé en Javascript avec deux types d'opérande différents. On dit qu'il est surchargé. On se doute que pour aller chercher le bon opérateur, l'interpréteur Javascript va se baser sur le type des opérandes. Il est donc important d'être sûr que les deux opérandes sont du même type, soit number soit string.

La comparaison

Vous pouvez savoir si deux chaînes sont égales en utilisant l'opérateur == ou différentes en utilisant !=. La comparaison est case sensitive.

alert('Paris' == 'Paris') // Affiche true alert('Paris' == 'paris') // Affiche false alert('Paris' == 'Parie') // Affiche false

La comparaison selon l'ordre alphabétique

On peut comparer des chaînes avec < ou >. La comparaison se fait selon le rangement du jeu de caractère unicode. Si on résume on trouve d'abord les chiffres puis les lettres majuscules puis les lettres minuscules [0-9A-Za-z]

alert('nice' < 'paris') // Affiche true alert('nice' < 'Nice') // Affiche false alert('2' < '9') // Affiche true alert('20' < '9') // Affiche true

Autres opérations

Les autres opérations traditionnelles de manipulation de chaînes (recherche ou extraction de sous-chaîne) se font avec des "fonctions" spécifiques.

Le ET logique &&

Le && est un opérateur binaire. Il faut que les deux opérandes soient true pour que le résultat de l'opération soit true.

var bol1=true; var bol2=true; alert(bol1 && bol2); // Affiche true bol1=false; bol2=true; alert(bol1 && bol2); // Affiche false bol1=true; bol2=false; alert(bol1 && bol2); // Affiche false bol1=false; bol2=false; alert(bol1 && bol2); // Affiche false

On peut faire la liste de tous les cas possibles et rassembler les résultats dans un tableau.

bol1	bol2	Résultat du &&
true	true	true
true	false	false
false	true	false
false	false	false

Le OU logique ||

Le || est un opérateur binaire. Il suffit que l'un des deux opérandes soient true pour que le résultat de l'opération soit true.

var bol1=true; var bol2=true; alert(bol1 && bol2); // Affiche true bol1=false; bol2=true; alert(bol1 && bol2); // Affiche true bol1=true; bol2=false; alert(bol1 && bol2); // Affiche true bol1=false; bol2=false; alert(bol1 && bol2); // Affiche false

bol1	bol2	Résultat du ||
true	true	true
true	false	true
false	true	true
false	false	false

La négation logique !

Le ! est un opérateur unaire. Si l'opérande vaut true l'opération vaut false. Si l'opérande vaut false l'opération vaut true.

var bol=false; alert(!bol); // Affiche true bol=true; alert(!bol); // Affiche false

bol	Résultat du !
true	false
false	true

Combiner les opérateurs

Si on combine les opérateurs logiques on fabrique une expression logique et ici aussi il y a une priorité au niveau des opérateurs.

Dans un ordre de priorité décroissante on a la négation puis le ET puis le OU

alert(true || true && false); // Affiche true alert((true || true) && false); // Affiche false alert(true || (true && false)); // Affiche true

Ici le ET se fait en premier et vous voyez que ce n'est pas le même résultat si vous faites le OU en premier