Qu'est-ce qu'un opérateur?
Prenons une expression simple 4 + 5 est égal à 9.
Ici 4 et 5 sont appelés opérandes et '+' est appelé l'opérateur.
JavaScript prend en charge les types d'opérateurs suivants.
· Opérateurs arithmétiques
· Opérateurs de comparaison
· Opérateurs logiques (ou relationnels)
· Opérateurs d'affectation
· Opérateurs conditionnels (ou ternaires)
Jetons un coup d'oeil sur tous les opérateurs un par un.
Opérateurs arithmétiques
JavaScript prend en charge les opérateurs arithmétiques suivants:
Supposons que la variable A détient 10 et la variable B détient 20, alors -
(+)Addition : A+B = 30
(-) soustraction : B-A = 10
(*)Multiplication : B*A = 20*10 = 200
(/)Division : B/A = 20/10 = 2
(%)le reste d’une division entière : B%A = 0 ;
(++)Incrémentation : Augmente une valeur entière par un
A++ = 10+1 = 11
(--) décrémentation : Diminue une valeur entière par un
A-- = 10-1 = 9
Exemple :
<html>
<body>
<script type="text/javascript">
<!--
var a = 33;
var b = 10;
var c = "Test";
var linebreak = "<br />";
document.write("a + b = ");
result = a + b;
document.write(result);
document.write(linebreak);
document.write("a - b = ");
result = a - b;
document.write(result);
document.write(linebreak);
document.write("a / b = ");
result = a / b;
document.write(result);
document.write(linebreak);
document.write("a % b = ");
result = a % b;
document.write(result);
document.write(linebreak);
document.write("a + b + c = ");
result = a + b + c;
document.write(result);
document.write(linebreak);
a = ++a;
document.write("++a = ");
result = ++a;
document.write(result);
document.write(linebreak);
b = --b;
document.write("--b = ");
result = --b;
document.write(result);
document.write(linebreak);
//-->
</script>
Réglez les variables sur différentes valeurs, puis essayez.
</body>
</html>
Résultat en ligne
La sortie :
a + b = 43
a - b = 23
a / b = 3.3
a % b = 3
a + b + c = 43Test
++a = 35
--b = 8
Réglez les variables sur différentes valeurs, puis essayez...
Opérateurs de comparaison
JavaScript prend en charge les opérateurs de comparaison suivants -
Supposons que la variable A détient 10 et la variable B détient 20, alors –
1. == Egal :
Vérifie si la valeur de deux opérandes est égale ou non,
si oui, alors la condition devient vraie.
A==B : Donne le résultat faux
var a = 10 ;
var b =2 0 ;
B = (a==b) ;
Document.write (B) ;
Donne le résultat : false
2. != Not Egal
Vérifie si la valeur de deux opérandes est égale ou non,
si les valeurs ne sont pas égales, alors la condition devient vraie
A != B est vraie (true)
3. > (Greater than) supérieur à
Vérifie si la valeur de l'opérande gauche est supérieure à la valeur
de l'opérande droit, si oui, alors la condition devient vraie.
A>B est non vraie (false)
4. < (Less than) inferieur à ( Même que supérieur à )
5. <= inferieur ou égale à
6. >= supérieur ou égale à
<html>
<body>
<script type="text/javascript">
<!--
var a = 10;
var b = 20;
var linebreak = "<br />";
document.write("(a == b) => ");
result = (a == b);
document.write(result);
document.write(linebreak);
document.write("(a < b) => ");
result = (a < b);
document.write(result);
document.write(linebreak);
document.write("(a > b) => ");
result = (a > b);
document.write(result);
document.write(linebreak);
document.write("(a != b) => ");
result = (a != b);
document.write(result);
document.write(linebreak);
document.write("(a >= b) => ");
result = (a >= b);
document.write(result);
document.write(linebreak);
document.write("(a <= b) => ");
result = (a <= b);
document.write(result);
document.write(linebreak);
//-->
</script>
</body>
Résultat en ligne :
La sortie :
(a == b) => false
(a < b) => true
(a > b) => false
(a != b) => true
(a >= b) => false
(a <= b) => true
Opérateurs logiques
JavaScript prend en charge les opérateurs logiques suivants:
Supposons que la variable A détient 10 et la variable B détient 20, alors –
1- && (Logical AND) :
Si les deux opérandes sont non-zéro, alors la
condition devient vraie.
A&&B est vraie
2- || (Logical OR) :
Si l'un des deux opérandes n'est pas nul, la condition devient vraie.
(A || B) est vraie
3- ! (Logical NOT) :
Inverse l'état logique de son opérande. Si une condition est vraie,
l'opérateur Logical NOT le rendra faux
! (A && B) est faux
Exemple :
<html>
<body>
<script type="text/javascript">
<!--
var a = true;
var b = false;
var linebreak = "<br />";
document.write("(a && b) => ");
result = (a && b);
document.write(result);
document.write(linebreak);
document.write("(a || b) => ");
result = (a || b);
document.write(result);
document.write(linebreak);
document.write("!(a && b) => ");
result = (!(a && b));
document.write(result);
document.write(linebreak);
//-->
</script>
</body>
</html>
La sortie :
(a && b) => false
(a || b) => true
!(a && b) => true
Opérateurs bit à bit: binaire
JavaScript prend en charge les opérateurs bit à bit suivants -
Supposons que la variable A tienne 2 et que la variable B tienne 3, alors –
Opérateur
|
Utilisation
|
Description
|
ET binaire
|
a & b |
Renvoie un
1 pour chaque position de bit pour laquelle
les bits correspondants des deux opérandes sont des 1. |
OU binaire
|
a | b |
Renvoie un
1 pour
chaque position de bit pour laquelle le bit correspondant d'au moins un des
deux opérandes est un 1 . |
OU exclusif binaire (XOR)
|
a ^ b |
Renvoie un
1 pour
chaque position de bit pour laquelle le bit correspondant d'un seul des deux
opérandes est un 1. |
NON binaire
|
~ a |
Inverse les bits de son opérande.
|
Décalage à gauche
|
a << b |
Décale
a en
représentation binaire de b bits vers la
gauche, en introduisant des zéros par la droite. |
Décalage à droite avec propagation du signe
|
a >> b |
Décale
a en
représentation binaire de b bits vers la droite,
en rejetant les bits à droite. |
Décalage à droite avec introduction de zéros
|
a >>> b |
Décale
a en
représentation binaire de b bits vers la
droite, en rejetant les bits à droite et en introduisant des zéros par la
gauche. |
1. & (ET binaire)
Effectue
l'opération ET (AND) sur chaque
paire de bits.
a ET b donne 1 uniquement
si à la fois a et b sont 1 .
La table de vérité pour l'opération ET est :
a
|
b
|
a ET b
|
0
|
0
|
0
|
0
|
1
|
0
|
1
|
0
|
0
|
1
|
1
|
1
|
A = 2 (base 10) = 10 (base 2)
B = 3(base 10) = 11 (base 2)
A&B = 2 (base 10)= 10(base2)
A & B est 2
Utiliser le ET binaire avec n'importe quel nombre x et zéro donne zéro.
Utiliser le ET binaire avec n'importe quel nombre x et -1 donne x.
2. | (ou binaire)
Effectue l'opération OU (OR) sur chaque paire de bits.
a OU b donne 1 si a ou b vaut 1. La table de vérité pour l'opération OU est :
a
|
b
|
a OU b
|
0
|
0
|
0
|
0
|
1
|
1
|
1
|
0
|
1
|
1
|
1
|
1
|
A = 2 (base 10) = 10 (base 2)
B = 3(base 10) = 11 (base 2)
A | B = 3 (base 10) = 11 (base 2)
Utiliser le OU binaire avec n'importe quel nombre x et 0 donne x.
Utiliser le OU binaire avec n'importe quel nombre x et -1 donne -1.
3.
^ (XOR binaire)
Effectue l'opération XOR (OU
exclusif) sur chaque paire de bits.
a XOR b donne 1 si a et b sont différents. La table de vérité pour l'opération XOR
est :
a
|
b
|
a XOR b
|
0
|
0
|
0
|
0
|
1
|
1
|
1
|
0
|
1
|
1
|
1
|
0
|
A = 10(base 2) = 2 (base 10)
B = 11 (base 2)= 3(base 10)
A ^ B = 01(base 2) = 1(base 10)
4.
~ (NON binaire)
Effectue l'opération NON (NOT) sur chaque bit. NON
la valeur inversée (c'est-à-dire le complément à un) de
La table de vérité de l'opération NON est :
a donne la valeur inversée (c'est-à-dire le complément à un) de
a. La table de vérité de l'opération NON est :
a
|
NON a
|
0
|
1
|
1
|
0
|
B
= 11 (base 2)= 3(base 10)
~B = 1100 = -4
Opérateurs de décalage binaire
Les opérateurs de
décalage binaire (shift) prennent
deux opérandes :
le premier est une valeur à décaler et le second spécifie le nombre
de positions de bits duquel le premier opérande doit glisser.
La direction de l'opération de décalage est contrôlée par l'opérateur utilisé.
le premier est une valeur à décaler et le second spécifie le nombre
de positions de bits duquel le premier opérande doit glisser.
La direction de l'opération de décalage est contrôlée par l'opérateur utilisé.
Les opérateurs de décalage convertissent leurs
opérandes en entiers 32 bits en ordre big-endian et renvoient un résultat du
même type que l'opérande de gauche. L'opérande droit doit être inférieur à 32,
sinon les cinq bits les plus faibles seront utilisés.
1
- << (décalage à
gauche) :
Cet opérateur décale le premier opérande du nombre de bits
spécifié vers la gauche.
Les bits surnuméraires éjectés à gauche sont perdus. Des bits à zéro sont insérés par la droite.
Les bits surnuméraires éjectés à gauche sont perdus. Des bits à zéro sont insérés par la droite.
B<< 1 = 0100 (base 2) = 4 (base10)
2
- >> (Décalage à
droite) :
Cet opérateur décale le premier opérande du nombre de bits
spécifié vers la droite.
Les bits surnuméraires éjectés à droite sont perdus. Des copies du bit
le plus à gauche sont insérés par la gauche. Comme le bit le plus a gauche
a la même valeur qu'avant l'opération, le bit de signe (celui qui est le plus à gauche) ne change pas. D'où ce qu'on appelle la « propagation du signe ».
Les bits surnuméraires éjectés à droite sont perdus. Des copies du bit
le plus à gauche sont insérés par la gauche. Comme le bit le plus a gauche
a la même valeur qu'avant l'opération, le bit de signe (celui qui est le plus à gauche) ne change pas. D'où ce qu'on appelle la « propagation du signe ».
9 (base 10) : 00000000000000000000000000001001 (base 2) --------------------------------9 >> 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10)
3
- >>> (décalage à droite avec
insertion de zéros)
Cet opérateur décale le premier opérande du
nombre de bits spécifié vers la droite.
Les bits surnuméraires éjectés à droite sont perdus. Des bits à zéro sont insérés par la gauche. Le bit de signe devient 0, donc le résultat est toujours positif.
Les bits surnuméraires éjectés à droite sont perdus. Des bits à zéro sont insérés par la gauche. Le bit de signe devient 0, donc le résultat est toujours positif.
Pour les nombres non
négatifs, le décalage à droite avec insertion de zéros
et le décalage à droite avec propagation du signe donnent le même résultat.
Par exemple,
et le décalage à droite avec propagation du signe donnent le même résultat.
Par exemple,
9 >>> 2 donne 2, tout comme 9 >> 2 :9 (base 10) : 00000000000000000000000000001001 (base 2) --------------------------------9 >>> 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10)
Hello, my name is Jack Sparrow. I'm a 50 year old self-employed Pirate from the Caribbean. 
Aucun commentaire