Les opérateurs de JavaScript et outil de test

Le langage C a transmis - comme à beaucoup d'autres langages - ses opérateurs à JavaScript. Les principaux symboles que contient un clavier sont mis à contribution pour former l'éventail des opérations possibles dans une expression.

Donc les résultats de l'outil de test ci-dessous sont aussi valables pour les autres languages utilisant les opérateurs de C: soit PHP, Java, C#. Cependant le résultat de la division diffère pour les langages typés.

Tester un opérateur

Entrer des nombres et un opérateur et cliquez sur Tester pour effectuer l'opération.

Opérande	Opérateur	Opérande	Résultat

Tester une expression

On peut utiliser la variable x pour tester les assignements simples ou composés. Elle est remise à zéro par le bouton Effacer.
Une variable quelconque, y par exemple, peut aussi être utilisée. Ainsi, avec une variable, on enchaîne une série d'assignements comme par exemple: y = 5 puis y += 12 etc.
Les variables autres que x sont remises à zéro en rechargeant la page.

Expression:
Résultat:

Opérateurs arithmétiques

Ce sont des opérateurs binaires, sauf la négation, et ils ont donc la forme:

x = a + b 

+    addition
-    soustraction
*    multiplication
/    division
%    modulo. Retourne la reste de la division de deux nombres.
**   puissance, remplace Math.pow (depuis 2017).
++   incrémentation, simplifie l'addition de 1.
--   décrémentation, simplifie la soustraction de 1.
-    négation, génère le négatif d'un nombre.  Sous la forme x = -y

Noter que la division de deux entiers peut produire un entier s'il n'y a pas de reste, ou un nombre réel dans le cas contraire. Dans les langages typés, cela est différent.

Les chaînes de caractères ont deux opérateurs:

+    concaténation de deux chaînes:   a = str1 + str2
+=   concaténation d'une autre chaîne:  a += str2

Opérateurs de comparaison

Ce sont des opérateurs binaires qui s'emploient dans les tests de comparaison.

Ils comparent des nombres ou des expressions qui retournent true si la comparaison réussit ou false si elle échoue. Quand les opérandes sont de types différents, ils sont convertis avant comparaison.

if(x == 5) ...  

==   égal
<     inférieur
>     supérieur
<=   inférieur ou égal
>=   supérieur ou égal
!=    différent

Deux chaînes sont égales si elles ont la même taille et les mêmes caractères aux mêmes positions.
Deux variables correspondant à des objets sont égales s'il s'agit du même objet assigné à deux variables différentes.

Les opérateurs stricts

Lorsque les opérandes d'une comparaison stricte sont de types différents, le resultat est toujours false, quel que puissent être les valeurs.

===  égalité stricte
!==   différence stricte

Les codes null et undefined ont une égalité simple, mais pas stricte.

Il n'y a pas d'autres opérateurs stricts dans la version 1.5 de JavaScript.

Opérateurs logiques

Ils s'emploient dans les tests de condition, comme les opérateurs de comparaison:

if(a && b) ... 

&&   et logique. Vrai si les deux opérandes sont vrais.
||      ou logique. Vrai si l'un des deux opérandes est vrai.
!      négation logique. Vrai si l'opérande est faux.

Opérateurs d'assignement

L'assignement simple s'effectue avec l'opérateur =

a = 5 

Mais on peut combiner l'assignement avec d'autres opérations lorsque la variable a assigner est un des deux opérandes, par exemple:

a += b       équivaut à      a = a + b 

+=    ajoute une valeur.
-=    soustrait.
*=    multiplie par l'opérande.  Ex: a *= 3, si a valait 2, elle vaudra 6.
/=    divise par l'opérande. 
%=  
<<=  décale à gauche en mettant des zéros à droite. Ex: a <<= 2. si a valait 10, elle vaudra 40 après deux décalages
>>=  décale à droite. 
>>>= décale à droite, ignore le bit de signe.
&=  effectue un et binaire avec l'opérande.
|=   effectue un ou binaire.
^=   effectue un ou exclusif binaire.  Ex: a ^=2, si a valait 4, elle vaudra 16. 

Opérateurs sur les bits

Ils permettent d'effectuer des opérations sur la représentation binaire des nombres. Ainsi 0110 & 0010 retourne 0010.

&     et binaire
|     ou binaire
^     ou exclusif 
~     complément
a << b  décalage à gauche selon b. Ex:   x = a << b. Si a vaut 0001 et b vaut 2, le résultat sera 0100.
a >> b  décalage à droite avec préservation du bit le plus à gauche. C'est l'opération inverse.
a >>> b  décalage à droite avec remplissage par des zéros.

La différence entre >> et >>> est que le bit le plus à gauche, qui est le bit de signe est préservé dans le premier cas et non dans le second. Cela permet de préserver le signe dans le premier cas, tandis que dans le second, la variable est supposée être utilisée comme stockage de bits et le bit le plus à gauche n'a pas rôle de signe.

Autres opérateurs

Ils ont des rôles divers dans le language selon le contexte.

.         le point associe un membre à un objet
[ ]       les crochets enclosent les indices. 
()        les parenthèses regroupent les expressions.

,          la virgule est un séparateur.
? :        cette construction signifie pour exp ? action1 : action2, si exp vaut true, exécuter action1 sinon action2.
=>         lambda, remplace function() { }
new        annonce un constructeur. Crée un objet.
this       désigne un variable interne à un objet.
in         appartenance. Dans x in y, la condition est vraie si x fait partie des éléments de y.
delete     supprime un objet, une variable.
instanceof x instanceof y retourne vrai si l'objet x est une instance de y.
typeof     typeof x affiche une chaîne qui indique le type de x.

Annotation

L'opérateur dit d'annotation utilisé par Asm.js (sous-ensemble de JavaScript) est un opérateur logique utilisé par le langage pour déduire le type d'une variable. Quand on écrit:

 x =  x | 0

Cela signifie que x vaut x ou zéro, et le zéro implique un type entier, cela aurait été 0.0 pour un float. Il n'y a que des types numériques en Asm.js.

Précédence des opérateurs

On peut se dispenser des parenthèses dans une expression si la précédence permet de determiner quels opérandes sont concernés par un opérateur. Ainsi (x * y) + z est équivalent à x * y + z, parceque * à la précédence sur +.

Dans l'ordre de précédence:

.   []  le point et les crochets sont prioritaires sur tous autres et ensuite
() new
!   ~  - + ++ -- typeof void delete:  tous les opérateurs unaires
* / %
+ -
<< >> >>>
< > <= >= in instanceof
== != === !==
&
^
|
&&
||
?:
=   et  autres opérateurs d'assignement
,     la virgule a la priorité la plus faible.

Voir aussi

• Les variables en JavaScript.
• Testeur d'expressions régulières. Un autre outil en ligne.