[javaScript] T1 : JavaScript une Vue d'ensemble

Pour les programmeurs expérimentés en C, C++, Java ou PHP ce résumé devrait être suffisant pour maîtriser le langage JavaScript et l'utiliser pour construire des pages Web dynamiques ou des interfaces utilisateur en XUL.

JavaScript est sensible à la casse.
Comme PHP il ne fait pas de différence entre un nombre littéral exprimé tel quel ou placé entre guillemets.

Les types primaires sont: boolean, number, string, array, object, function, undefined, Infinity, NaN. Ils peuvent avoir des attributs et des méthodes.

Les variables sont dynamiques

Les variables n'ont pas un type défini lors de la déclaration. Une variable est déclarée dans un scope, local ou global avec le mot-clé var ou juste un assignement:

var x = 1;
y = 2;

Si on la déclare dans une fonction sans le mot-clé var, elle a le scope global et non interne à la fonction.

Opérateurs et symboles sont ceux du langage C

Ainsi que de C++ pour les objets.

• // Commentaire sur une ligne, ou en fin de ligne.
• /* */ Commentaire de plusieurs lignes ou imbriqué dans du code.
• Espaces blancs, tabulations, fin de lignes ne sont pas significatifs.
• = Opérateur d'assignement.
• + Addition de nombres ou concaténation de chaînes.
• - * / % ++ -- Autres opérateurs arithmétiques: % (modulo) ++ (incrément) -- (décrément).
• += Opérateurs composés avec = et + - etc.
• == != < > <= >= Opérateurs de comparaison, == (égal) != (non égal) > (plus grand) < (moins que).
• === Comparaison stricte. === (même valeur et type) !== (valeur ou type différents).
• || && ! Opérateurs logiques !! (ou) && (et) ! (non).
• & | ^ ~ Opérateurs binaires: & (et) | (ou) ^ (ou exclusif) ~ (non binaire ou complément).
• << >> Décalage binaires: << (à gauche) >> (à droite) >>> (à droite, signe supprimé).
• { } Enclôt le corps d'une fonction ou la liste des éléments dans un tableau associatif.
• [] Enclôt les éléments d'un tableau simple ou sert à indicer un tableau ou une chaîne.
• " Les guillemets simples ou doubles enclosent une chaîne, ils n'ont pas de différence au contraire de PHP.
• . Associe un objet avec un attribut ou une méthode.
• :: Associe le nom d'un membre au nom de classe.
• in, this, new Ils seront détaillés plus loin.
• with établit un objet comme objet par défaut pour un ensemble d'instructions.

Les tableaux sont des objets dynamiques

Les tableaux ont un attribut, la taille (length), et quelques méthodes dont le constructeur.
Le tableau peut être déclaré selon différents moyens:

arr = new Array(1000); // tableau avec une taille de 1000.
arr = new Array(1,2,3); // tableau comprenant trois éléments.
arr = [1,2, 3]; // le même tableau déclaré en assignant un litéral.

Un tableau associatif se déclare en assignant une liste de couples clé-valeur:

arr = { "un": 1, "deux": 2, "trois": 3 }

Pour indicer un tableau, il y à deux syntaxes:

arr[x] // retourne l'élément à la position x
arr["x"] // retourne la valeur associée à la clé "x" qui est une chaîne

Lorsque la chaîne utilisée comme clé à une valeur numérique, elle est convertie en nombre. Pour l'utiliser en tant que chaîne et donc de clé, il faut mettre un zéro en préfixe:

arr["01"]

retourne la valeur associée à la clé 01, et non pas l'élément d'indice 1.

On ajoute des éléments en fin de tableau avec la méthode push.

arr.push("x");

Les tableaux multi dimensionnels sont déclarés en imbriquant des tableaux littéraux comme élément de tableaux ou en associant un tableau litéral à une clé.

Les structures de contrôle sont celles de C

Ces structures sont identiques à celles du langage C avec une addition:

• if else
• for
• while
• do .. while
• switch case
• break et continue
• ?:

Le for .. in a été ajouté au JavaScript:

for(var conteneur in liste) { ... instructions ...}

La liste peut être un tableau ou un objet.

Les fonctions peuvent être des objets

Une déclaration de fonction débute par le mot clé function.

function nomfonct(arguments)
{
  ...instructions... 
  return x;
}

On peut assigner une fonction à une variable:

var x = function(arguments) { ...instructions... }

Cela permet notamment d'associer un traitement à un évènement.
L'instruction return retourne une valeur.
Tous les arguments sauf les objets sont passés par valeur.

Les objets sont comme des fonctions et des tableaux

En JavaScript, les objets sont similaires aux tableaux associatifs.
Comme les tableaux, ils sont déclarés avec un constructeur ou un littéral. Le littéral à une forme associative, les clés sont les noms d'attributs et les valeurs leurs valeurs initiales.

obj1 = { 'type' : "integer", "nom" : "Objet X", taille : 11, ... }
x = obj1["nom"] // ceci assigne la chaîne 'Objet X' à l'attribut x 

Les objets sont dynamiques, des attributs peuvent être ajoutés dynamiquement. On peut démarrer avec un objet vide:

obj1 = {}

La structure des objets est récursive, la valeur d'un attribut peut être un autre objet.

On crée une classe en déclarant une fonction-constructeur

Les classes sont simulées en JavaScript par le moyen des constructeurs, et un constructeur est une fonction.
Le mot-clé this identifie les variables d'une fonction comme attributs de la classe.

function ClassA(x, y)
{
  this.propertyX = x;
  this.propertyY = y;
} 
       
obj1 = new ClassA(12, 34);  // instance        
obj1.propertyX = z;
obj1.properyZ = z; // ajout dynamique d'un nouvel attribut à l'instance.      

On peut créer une classe vide et définir tous les attributs de cette façon.

Un attribut peut être effacé par la commande delete, ce qui complète l'aspect dynamique des objets en JavaScript.

delete obj1.propertyY;

Les méthodes sont des fonctions dans les fonctions

On peut définir des fonctions à l'intérieur de fonctions et cela fournit des méthodes aux objets.

function ClassA
{
  this.methodA = function(x, y) { ...body... }
}    

Exemple de déclaration en utilisant un littéral:

var ClassA = {
 nom : "class A";
 type : 3;
 changeNom : function(n)
 { 
  this.nom = n;
 }
}

On peut simuler l'héritage

On peut hériter les membres d'une classe en déclarant une fonction qui référence les attributs de cette classe de base, ou appelle ses méthodes. 

Les exceptions sont reconnues

La syntaxe provient de Java:

try { ... } 
catch(nom-exception) { ... } 
finally { ... }

On peut omettre la clause catch ou finally.

Les expression régulières font partie du langage

Mais elle peuvent aussi être des objets.

Une expression régulière littérale est définie sans guillemets sous la forme:

/ x / y 

ou x est l'expression et y une chaîne d'options.

 Leçon suivant