|  Présentation | Données | Opérateurs | Instructions |

 

Les Opérateurs de comparaison

Ces opérateurs renvoient une valeur true ou false. Les opérandes peuvent être des nombres ou des chaînes. Les nombres sont comparés numériquement, les chaînes alphabétiquement.

a == b	a égale b ?
a != b	a différent de b ?
a === b	a strictement égal à b ? (opérandes égaux et du même type)
a !== b	a non strictement égal à b ? (vrai si valeur ou type différents)
a > b	a supérieur à b ?
a >= b	a supérieur ou égal à b ?
a < b	a inférieur à b ?
a <= b	a inférieur ou égal à b ?

 

Les Opérateurs arithmétiques

Les quatre opérateurs fonctionnent de manière classique :

+ addition,

– soustraction,

* multiplication

/ division (toujours à virgule flottante, jamais entière)

Les autres opérateurs sont :

% modulo, deux arguments, reste de la division entière

++ incrément, un argument, préfixe ou postfixe

— décrément, un argument, préfixe ou postfixe

– opposé, un argument, préfixe

 

Les Opérateurs bit à bit

Les opérateurs bit à bit considèrent leurs opérandes comme des mots de 32 bits, mais retournent des valeurs numériques standard :

& ET logique, bit à bit

| OU logique, bit à bit

^ OU exclusif, bit à bit

~ complément bit à bit

<< décalage à gauche (on rentre des zéros à droite)

>> décalage à droite (bit de signe conservé)

>>> décalage à droite (on rentre des zéros à gauche)

Exemple : 3 << 2 donne 12

Les Opérateurs logiques

Les opérateurs logiques portent sur des variables booléennes. Toutefois leur évaluation est inhabituelle :

a && b		ET logique, ( a == false ) ? a : b
a || b		OU logique, (a == true ) ? a : b
! a		NON logique, ( a == true) ? false : true

N.B. == s’interprète de fait comme « peut être converti en ». Par conséquent, si les opérateurs && et || sont appliqués à des variables booléennes, ils retournent un booléen conforme au résultat attendu. S’ils sont appliqués à des variables non booléennes le résultat est non booléen :

par exemple : 1 && « Hello » vaut « Hello »

 

Les Opérateurs logiques

L’évaluation des expressions logiques est interrompue dès que la valeur du résultat est connu. Dans l’expression ci-dessous, la fonction essai( ) n’est pas appelée :

art = false;

x = art && essai();

De même, dans la situation suivante la fonction la_vie ( ) n’est pas appelée :

la_bourse = true;

y = la_bourse || la_vie();

Ce comportement est garanti. Il fait partie des spécifications du langage.

caractères spéciaux :

\b	backspace		\’	apostrophe simple
\f	form feed		\ »	apostrophe double
\n	new line		\040	code octal (ici espace)
\r	carriage return		\0x20	code hexadecimal (ici space)
\t	tab

 

Les Autres opérateurs

S’il est utilisé dans un contexte où l’un au moins des opérandes est une chaîne, + est interprété comme étant l’opérateur de concaténation :

« Pi vaut :  » + 3.141592 +  » (ou à
peu près) » est une chaîne.

? est le seul opérateur JavaScript à admettre
trois arguments :

condition ? val1 : val2

vaut val1 si condition est vraie (true), val2 sinon.

L’opérateur , (virgule) évalue ses deux opérandes et retourne le second (principalement utilisé avec l’instruction de boucle for).

 i=1, j=2

for(i=1, j=2; i++, j++; i<

10)

 

L’opérateur typeof

L’opérateur typeof renvoie le type de la variable ou de l’expression à laquelle il s’applique :

var pi = 3.141592;

var str = « Coucou »;

var now = Date();

var check = « typeof pi :  » + typeof(pi) + « \n »

+ « typeof str :  » + typeof(str) + « \n »

+ « typeof now :  » + typeof(now) + « \n »

+ « typeof foo :  » + typeof(foo) + « \n »;

Le type d’un objet non défini est undefined

 

Les Opérateurs d’affectation

Un opérateur d’affectation affecte la valeur de l’opérande situé à sa droite (généralement une expression) à l’opérande situé à sa gauche (généralement une variable). L’opérateur d’affectation le plus simple est ‘=’ :

x = y affecte la valeur de y à la variable x.

Les autres opérateurs d’affectation sont en fait des raccourcis pour quelques opérations standards :

 

x += y	x = x + y	x >>= y	x = x >> y
x -= y	x = x – y	x >>>= y	x = x >>> y
x *= y	x = x * y	x &= y	x = x & y
x /= y	x = x / y	x |= y	x = x | y
x %= y	x = x % y	x ^= y	x = x ^ y
x <<= y	x = x << y

 

La Précédence des opérateurs

La précédence des opérateurs donne l’ordre de priorité dans lequel ils sont évalués. Cet ordre permet d’écrire des expressions comme :

x = a + b * c - d == 23 ? 1 : ++j, ++i;

et d’obtenir le résultat escompté, qui est :

(x = (((a+(b*c)-d) == 23)

? 1 : ++j)),++i;
Un conseil : il est plus sûr, plus rapide et plus efficace de spécifier l'ordre de priorité des opérations à effectuer à l'aide de parenthèses bien placées (même si celles-ci sont éventuellement inutiles) que de consulter la documentation relative à la précédence des opérateurs et d'accoucher d'une séquence de code illisible et non maintenable ...