CyBWarrior

1. Opérateurs arithmétiques
2. Opérateurs d’assignation
3. Opérateurs d’incrémentation / décrémentation
4. Opérateurs logiques
   1. Le non !
   2. Le ou ||
   3. Le et &&
5. Opérateurs binaires
   1. Le non ~
   2. Le ou |
   3. Le et &
   4. Le ou exclusif ^
   5. Le décalage de bits << et >>
6. Opérateurs relationnels

JavaScript posséde une multitude d’opérarteurs lui permetant d’effectuer des opérations (!) mathématiques,
logiques, de comparaison, d’assignation…

Opérateurs arithmétiques

Pour réaliser les 4 opérations, JavaScript utilise les opérateurs suivants :

Opérateur	Fonction	Exemple de code	Résultat
+	Addition	document.write(5 + 5);	10
-	Soustraction	document.write(25 – 10);	15
*	Multiplication	document.write(5 * 5);	25
/	Division	document.write(63 / 7);	9
%	Modulo (reste d’une division)	document.write(20 % 3);	2

On peut bien sur utiliser ces opérateurs avec des variables :

var a=5;
var b=1;
var c=10;

a = a + b * c;

document.write(a);// Sortie -> 5 + 1 * 10 = 15

Opérateurs d’assignation

Vous connaissez déjà un des ces opérateurs : l’opérateur =.
Vous serez peut-être surpris mais il n’est pas tout seul.
Prenons un exemple. Pour ajouter 5 à une variable et enregistrer le résultat de cette opération
dans cette même variable, vous serez certainement tenté d’écrire :

var a=10;

a = a + 5;// a = 15

Ce n’est pas faux et c’est même tout à fait correct.
Mais JavaScript peut faire mieux dans ce cas là avec l’opérateur += qui ajoute les opérandes
de droite à la variable placée à gauche et place le résultat dans cette même variable.
Ainsi, on peut écrire :

var a=10;

a+=5;// Reviens à écrire a = a + 5

Cette possibilité est étendue aux 4 autres opérateurs :

Opérateur	Exemple	Equivalence
+=	a += b;	a = a + b;
-=	a -= b;	a = a – b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Opérateurs d’incrémentation / décrémentation

Prenons la variable x. Nous voulons lui ajouter 1 et seulement 1.
On peut écrire :

var x=0;

x += 1;// Reviens à écrire x = x + 1

Là aussi JavaScript permet d’aller encore plus vite en écrivant à la place :

var x=0;

x++;// Reviens à écrire x += 1, ce qui revient à écrire x = x + 1

La décrémentation (enlever une unité) se passe de la même façon, mais avec – au lieu de
++ :

var x=0;

x--;// Reviens à écrire x -= 1, ce qui revient à écrire x = x - 1

Attention ! Il convient de distinguer la pré-incrémentation / décrémentation de la
post-incrémentation / décrémentation.
Lors de cette dernière, l’opérateur est placé après la variable, comme dans :

var x=0;

x++;// Post-incrémentation

Pour effectuer une pré-incrémentation, on écrira :

var x=0;

++x;// Pré-incrémentation

Quel est l’intérêt ?
Voici un exemple :

var a=5;
var b=5;
/*  a et b ont tout les deux pour valeur 5  */

document.writeln("<pre>");
document.writeln("a++ = " + a++);// Sortie -> a++ = 5
document.writeln("++b = " + ++b);// Sortie -> ++b = 6
document.writeln("</pre>");

La voilà la différence :

• Dans le 1^er cas, la variable est incrémentée après avoir renvoyée sa valeur
• Dans le 2^ème, la variable est incrémentée avant d’avoir renvoyée sa valeur

Opérateurs logiques

Les opérateurs logiques prennent tout leurs sens avec les variables du type boolean.
Une variable booléenne ne peut prendre que 2 états : true (allumé) ou false (éteint).
true est l’inverse de false.
Il existe 3 opérateurs logiques : le non (!), le et (&&) et le ou (||).

Le non !

Le non effectue une inversion. On utilise le point d’exclamation (!).

Argument	Résultat
false	true
true	false

Exemple :

var variable=true;

document.write(!variable);// Sortie -> false
document.write(!!variable);// Sortie -> true

Le ou ||

Le ou renvoi true si l’une des deux opérandes au moins est true.
On utilise l’opérateur ||.

1er argument	2ème argument	Résultat
false	false	false
false	true	true
true	false	true
true	true	true

Exemple :

document.write(false || false);// Sortie -> false
document.write(false || true);// Sortie -> true
document.write(true || true);// Sortie -> true

Le et &&

Le et renvoi true si les des deux opérandes sont true.
On utilise l’opérateur &&.

1er argument	2ème argument	Résultat
false	false	false
false	true	false
true	false	false
true	true	true

Exemple :

document.write(false && false);// Sortie -> false
document.write(false && true);// Sortie -> false
document.write(true && false);// Sortie -> false
document.write(true && true);// Sortie -> true

Opérateurs binaires

Pour bien comprendre à quoi servent les opérateurs binaires, vous devez tout d’abord savoir qu’est
ce que le binaire. C’est pourquoi je vous invite à lire ceci : La numération.
Ensuite, ce qui suit deviendra compréhensible

Le non ~

Le non ne permet non pas d’inverser tout les bits d’un nombre, mais d’effectuer le complément
à deux de ce nombre. On utilise l’opérateur ~ :

var nombre=3;

nombre = ~ nombre;
document.write(nombre);// Sortie -> -4

Le ou |

Le ou effectue un ou (!) entre chaques bits des deux opérandes. On utilise l’opérateur
| :

var a=2;// 2 -> 10 en binaire
var b=1;// 1 -> 01 en binaire
var resultat=a | b;
//1 | 0 -> 1
//0 | 1 -> 1
// resultat = 11 = 3
document.write(resultat);// Sortie -> 3

Le et &

Comme le ou, le et effectue un et entre chaques bits des deux opérandes. On utilise l’opérateur
& :

var a=255;// 255 -> 11111111 en binaire
var b=170;// 170 -> 10101010 en binaire
var resultat=a & b;
//1 & 1 -> 1
//1 & 0 -> 0
//1 & 1 -> 1
//1 & 0 -> 0
//1 & 1 -> 1
//1 & 0 -> 0
//1 & 1 -> 1
//1 & 0 -> 0
// resultat = 10101010 = 170
document.write(resultat);// Sortie -> 170

Le ou exclusif ^

Le ou exclusif effectue un ou exclusif (en l’aurait deviné ) entre les bits des deux opérandes. On
utilise l’opérateur ^ :

var a=255;// 255 -> 11111111 en binaire
var resultat = a ^ a;
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
//1 ^ 1 -> 0
// resultat = 00000000 = 0
document.write(resultat);// Sortie -> 0

Le décalage de bits << et >>

On peut facilement décaler les bits d’un nombre vers la gauche ou la droite d’un certain nombre
de bits.
Pour décaler les bits vers la gauche, on utilise l’opérateur <<. Pour les décaler vers
la droite, c’est >> qui est utiliser.
Dans tout les cas, on place à gauche de l’opérande le nombre à modifier, et à sa droite le nombre
de bits à décaler :

var a=3;// 3 -> 11 en binaire

a = a << 4;
// On décale de 4 rang vers la gauche, donc :
// 11 - > 110000 = 48
document.write(a);// Sortie -> 48

a = a >> 8;
// On décale de 8 rand vers la droite, donc :
// 110000 -> 0
document.write(a);// Sortie -> 0

À noter que comme pour les opérateurs d’affectation énoncés ci-dessus, ces deux opérateurs peuvent dans
certains cas être résumés ainsi :

Opérateur	Exemple	Equivalence
<<=	a <<= b;	a = a << b;
>>=	a >>= b;	a = a >> b;

L’exemple précedent devient alors :

var a=3;

a <<= 4;// Equivaut à a = a << 4
document.write(a);

a >>= 8;// Equivaut à a = a >> 8;
document.write(a);

Opérateurs relationnels

Les opérateurs relationnels permettent de comparer des nombres, mais aussi des chaînes de caractères
et des types de variables.
Voici un tableau récapitulatif :

Opérateur	Description	Exemple de code	Résultat
==	Egualité	var a=25; var b= »25″; document.write(a==b);	true
===	Identité	var a=25; var b= »25″; document.write(a===b);	false
!=	Inégalité	var a=120; var b=350; document.write(a != b);	true
!==	Non-identité	var a=25; var a= »25″; document.write(a !== b);	true
<	Inférieur	var a=10; var b=100; document.write(a < b);	true
<=	Inférieur ou égal	var a=100; var b=100; document.write(a <= b);	true
>	Supérieur	var a=100; var b=10; document.write(a > b);	true
>=	Supérieur ou égal	var a=100; var b=100; document.write(a >= b);	true

Ces opérateurs sont également utilisables avec les chaines de caractères.
Pour les opérateurs supérieur, supérieur ou égal, inférieur et inférieur ou égal, les chaines
sont comparées par rapport à leur rang alphabétique.

Series Navigation

«JavaScript – Les variablesJavaScript – La structure conditionnelle»