Caractéristiques du langage JavaScript

Caractéristiques clefs:

• Programme JavaScript (unité de compilation) est une liste d'instructions (statements)
• En général, les instructions sont exécutées en ordre
• L'ordre d'exécution des instructions peut être alterné par:
  • les instructions conditionnelles: if, switch
  • les boucles: while, for, do
  • les instructions de rupture: break, return, throw
  • les appels de fonctions (function calls)
• Une instruction JavaScript peut:
  • introduire ou modifier un objet, et/ou
  • définir ou appeler une fonction
• En général, un programme JavaScript définit un état (collection d'objets) et ses transformations (fonctions/méthodes).
  Par exemple, dans le contexte du Web, l'état contient l'arbre du document HTML, qui peut être changé par l'exécution d'une fonction attachée à un évènement (e.g., clique souris, entrée clavier, etc...)

Noms, nombres, strings

La syntaxe est basée sur les concepts de nom, nombre, et string (chaîne de caractères)

Nom

• Un nom, une suite de lettres et chiffres (et d'autres caractères..., sauf les mots réservés, comme if, new, null, else, return,...), est utilisé pour nommer les objets, leurs propriétés, et les fonctions

Number (Nombre)

• En JavaScript il n'y a qu'un type de nombres, donc 0 et 0.0, c'est la même chose.
• La notation assez riche:

   100; 1.0e2; 10e1;

• "Infinity" pour les valeurs plus grandes que 1.7977e+308
• "NaN" - Not-A-Number - est un nombre représentant un "résultat impossible"
• Les Numbers ont des méthodes, par exemple:

   
        (2.5).toString(2);
    

• Il y a un objet Math qui contient un ensemble de méthodes sur les nombres, comme:

   Math.floor(12.3); Math.sqrt(34);

• Quelques exemples:

     
        Number.MAX_VALUE;
      

     
         2*Number.MAX_VALUE;
      

     
         2/-0;
      

     
         0/0;
      

String (chaîne de caractères)

• Une chaîne de caractères est entourée de "..." ou '...'. Par exemple:

  "toto"; 'titi';

• JavaScript support Unicode

  "aA" === "a\u0041";

• Les strings ont la propriété length, par exemple:

  "un".length === 2;

• Les strings ont des méthodes, par exemple:

   
        "ABCD".charAt(1);
      

     
        'cat'.toUpperCase();
      

• (+) représente l'addition et/ou concaténation (attention!):

       ("10" + "2");
     

     
       (10 + "2" + 3);
     

     
       (10 + 2 + "3");
     

Boolean (Booléen)

• Deux valeurs true et false.
• L'opérateur d'identité (===)

           2*6 === 3*4;
      

           (NaN === NaN);  
      

           (isNaN(NaN));
      

• l'opérateur d'égalité (==) avec conversion, dangereux! Chaînes ou booléens peuvent être convertis vers des nombres:

      (0 == "0");
      

      (0 == ""); 
      

      ("" == "0");
      

• Comparaison:

        ("10" < 2);
      

        ("10" < "2");
      

  Attention si les types sont différents!!!

null et undefined

• null décrit la valeur unique représentant vide ou référence inexistante.
• undefined précise que la valeur n'est pas définie.

Par convention, on utilise plutôt null que undefined; ainsi la valeur undefined indique que la variable n'a pas été initialisée.

Objects (Objets)

Les types simples de JavaScript sont: number, string, boolean, null, et undefined. Toutes autres valeurs sont des objets.

• Un objet est une collection de pairs (clef,valeur). Par exemple:

   {nom:"Robert",age:21};

• Un objet peut être vu comme un conteneur de propriétés: on peut ajouter, supprimer, ou modifier ses propriétés:

   
        var objet={nom:"Rioux"};
        objet['age'] = 25;
        objet['nom'] = "Beaulieu";
        [objet.nom, objet.age]; 
      

Numbers, strings, et booleans sont comme objets sauf qu'ils sont immutables - on ne peut pas les changer, ajouter de propriétés, etc...

Arrays (Tableaux)

• Tableaux (Arrays) sont des Objets avec une syntaxe et propriétés enrichies

 
      var tableau = [1,2,3,4];
    

• Propriétés: length, push(), pop(), sort(), ...
• Exemple:

        var a = [0,1,2];
        a[3]=3;  
        a[4]=4;
        a.push(5);
        a[a.length] = 6; // a.push(6) 
        a['toto'] = 'titi';
        alert(a.toto);
        a;
      

Date (la date)

Exemples:

  now = new Date();
 

  x = {annee:2012, mois:0, jour:1, heure:10, min:1, sec:32};
  d = new Date(x.annee, x.mois, x.jour, x.heure, x.min, x.sec);
 

  now.getMinutes();
 

RegExp (Expressions régulières)

Exemples:

    re=/[a-z]+/; 
    re.test("20 cents");
  

 "Tarte aux pommes".match(re);
  

    "100.23".match(re);
  

Functions (Fonctions)

• Fonctions (Functions) sont des Objets avec une syntaxe et propriétés enrichies

   
  var f = function(x,y){return x+y;};
  // function f(x,y){return x+y;};
    

• Une fonction peut être appliquée aux arguments:
  Exemple:

   function f(x){return x+x;};
   f(8);
      

• Une propriété d'un objet qui est une fonction est dite une méthode:

   o={set:function(x){this.x=x;}};
   o.set(2);
   o.x;
      

• Fonctions jouent aussi un rôle de constructeurs si préfixées par new:

   function Point(x,y){
     this.x=x;
     this.y=y;
     this.add=function(x){
       this.x += x.x;
       this.y += x.y;
       return this;};
     this.toString=function(){
       return "("+this.x+
              ","+this.y+")";
     }
  };
   var o = new Point(3,2);
   o.add(o);
      

• L'aspect Objet de JavaScript est construit en utilisant des fonctions et leurs "closures".

Instructions

Une unité de compilation est une liste d'instructions. Dans un navigateur, chaque élément <script> définit une unité de compilation qui est exécutée immédiatement - les noms ainsi introduits sont globaux et peuvent cacher les objets déjà définis.

Instruction var

• Une variable devrait être introduite à l'aide de l'instruction var, par exemple:

   var ma_variable = 10; 

  Sinon, elle est globale!
• Si l'instruction var est à l'intérieur d'une fonction, alors la variable ainsi introduite est locale à la fonction (et aux "closures" des fonctions retournées)

Instruction d'affectation ... = ...

• La valeur d'une variable ou d'une propriété peut être alternée par l'instruction d'affectation:

   var o = {}; o.x = 1; 

Instructions conditionnelles

Instructions "if-else" et "switch-case-break";

  var o = [0,1];
  if (o[0] === 0) { 
     o[2] = 1;
  } else { "sinon"; };
  switch (o[2]) {
    case 0 : "cas 0"; break;
    case 1 : "cas 1"; break;
    case 2 : "cas 2"; break;
    default : "autres";
  };

Boucles

Boucles "for", "while", et "do-while":

 t = [1,1];
 for (var i=2; i < 4; i=i+1){
    t[i] = t[i-1] + t[i-2]; 
 }; t;
  

 t.next = function(){
   var i = this.length;
   this[i] = this[i-1]+this[i-2];
 };
 while(t.length < 6){ 
   t.next(); 
 }; t;
  

 while (true) { 
   t.next(); 
   if (t.length > 8) break;
 }; t; 
  

 do { 
   t.next(); 
 } while (t.length < 12);
 t; 
  

Appels de fonctions

Il y a trois manières d'appeler une fonction:

• invocation simple, où this représente l'état global:

   F = function(x){ 
         this.a = x; 
         return this.a; };
   a = 1;
   o ={a:2, F:F};
   [F(3), a, o.a];
      

• invocation comme méthode d'un objet o, où this représente l'objet o:

   [o.F(4), a, o.a];
      

• invocation en mode constructeur (préfixé par new), où this représente l'objet créé (la valeur retournée est ignorée):

   o2 = new F(5);
   [o2.a, a, o.a];
      

Exceptions

 fact = function(x){
   if (x <= 0) throw "argument = "+x;
   if (x === 1) return 1;
   return x * fact(x-1);				  
 };
 fact(4);
  

 fact(-1);
  

  try {
    fact(-1);
  } catch(err) {
    'Problème: '+ err;
  }
  

  try {
    fact("test");
  } catch(err) {
    'Problème: '+ err;
  }