Syntaxe JavaScript - Définition

Opérateurs

L'opérateur '+' est surchargé; il est utilisé pour la concaténation de chaîne de caractères et l'addition ainsi que la conversion de chaînes de caractères en nombres. Il a également un rôle spécial lorsqu'il est utilisé dans une expression régulière.

      // Concatène 2 chaînes      var a = 'Ceci';      var b = ' et cela';      alert(a + b);  // affiche 'Ceci et cela'             // Additionne deux nombres      var x = 2;      var y = 6;      alert(x + y); // affiche 8             // Concatène une chaîne et un nombre      alert( x + '2'); // affiche 22             // Convertit une chaîne en nombre      var z = '4';   // z est une chaîne (le caractère 4)      alert( z + x); // affiche 42      alert( +z + x);// affiche 6      

Arithmétiques

Opérateurs binaires

      +     Addition      -     Soustraction      *     Multiplication      /     Division (retourne une valeur en virgule flottante)      %     Modulo (retourne le reste de la division entière)      

Opérateurs unaires

      -     Négation unaire (inverse le signe)      ++    Incrémentation (peut être utilisé en forme préfixée ou postfixée)      --    Décrémentation (peut être utilisé en forme préfixée ou postfixée)      

Affectations

      =     Affectation      +=    Ajoute et affecte      -=    Soustrait et affecte      *=    Multiplie et affecte      /=    Divise et affecte      

      var x = 1;      x *= 3;      document.write( x );  // affiche: 3      x /= 3;      document.write( x );  // affiche: 1      x -= 1;      document.write( x );  // affiche: 0      

Comparaisons

      ==    Égal à      !=    Différent de      >     Supérieur à      >=    Supérieur ou égal à      <     Inférieur à      <=    Inférieur ou égal à            ===   Identiques (égaux et du même type)      !==   Non-identiques      

Booléens

Le langage Javascript possède 3 opérateurs booléens :

      &&    and (opérateur logique ET)      ||    or (opérateur logique OU)      !     not (opérateur logique NON)      

Dans une opération booléenne, toutes les valeurs sont évaluées à true (VRAI), à l'exception de :

• la valeur booléenne false (FAUX) elle-même
• le nombre 0
• une chaîne de caractères de longueur 0
• une des valeurs suivantes : null undefined NaN

On peut faire explicitement la conversion d'une valeur quelconque en valeur booléenne par la fonction Boolean :

      Boolean( false );     // rend false (FAUX)      Boolean( 0 );         // rend false (FAUX)      Boolean( 0.0 );       // rend false (FAUX)      Boolean( "" );        // rend false (FAUX)      Boolean( null );      // rend false (FAUX)      Boolean( undefined ); // rend false (FAUX)      Boolean( NaN );       // rend false (FAUX)      Boolean ( "false" );  // rend true (VRAI)      Boolean ( "0" );      // rend true (VRAI)      

L'opérateur booléen unaire NOT ! évalue d'abord la valeur booléenne de son opérande, puis rend la valeur booléenne opposée :

      var a = 0;      var b = 9;      !a; // rend true, car Boolean( a ) rend false      !b; // rend false, car Boolean( b ) rend true      

En doublant l'opérateur !, on peut normaliser une valeur booléenne :

      var arg = null;      arg = !!arg; // arg est désormais à false au lieu de null             arg = "ChaîneQuelconqueNonVide";      arg = !!arg; // arg est désormais à true      

Dans les premières implémentations de Javascript et JScript, les opérateurs booléens && et || fonctionnaient comme leurs homologues dans d'autres langages issus du C, c'est-à-dire qu'ils rendaient toujours une valeur booléenne :

      x && y; // rend true si x ET y est VRAI, sinon il rend false      x || y; // rend true si x OU y est VRAI, sinon il rend false      

Dans les implantations récentes, les opérateurs booléens && et || rendent un de leurs deux opérandes :

      x && y; // rend x si x est FAUX, sinon il rend y      x || y; // rend x si x est VRAI, sinon il rend y      

Ce fonctionnement provient du fait que l'évaluation s'effectue de gauche à droite. Dès que la réponse est déterminée, l'évaluation s'arrête :

• x && y est nécessairement FAUX si x est FAUX, ce n'est pas la peine d'évaluer y
• x || y est nécessairement VRAI si x est VRAI, ce n'est pas la peine d'évaluer y

Ce nouveau comportement est peu connu, même parmi les développeurs Javascript expérimentés, et peut causer des problèmes si on s'attend à recevoir une valeur booléenne.

Binaires

Opérateurs binaires

      &     And (et)      |     Or (ou inclusif)      ^     Xor (ou exclusif)            <<    Shift left  (décalage à gauche avec remplissage à droite avec 0)      >>    Shift right avec propagation du signe (le bit de gauche, celui du signe, est décalé vers la droite)      >>>   Shift right (décalage à droite avec remplissage à gauche avec 0)                  Pour les nombres positifs, >> et >>> donnent le même résultat      

Opérateur unaire

      ~     Not (inverse tous les bits)      

Chaînes de caractères

      =     Assignation      +     Concaténation      +=    Concatène et assigne      

      str = "ab" + "cd";   // rend "abcd"      str += "e";          // rend "abcde"