- Opérateurs arithmétiques
- Opérateurs d’assignation
- Opérateurs d’incrémentation / décrémentation
- Opérateurs logiques
- Le non !
- Le ou ||
- Le et &&
- Opérateurs binaires
- Le non ~
- Le ou |
- Le et &
- Le ou exclusif ^
- Le décalage de bits << et >>
- 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 1er 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.
</NOSCRIPT>