Syntaxe JavaScript

Les nombres en JavaScript sont représentés en binaire comme des IEEE-754 Doubles, ce qui permet une précision de 14 à 15 chiffres significatifs JavaScript FAQ 4.2 (en). Comme ce sont des nombres binaires, ils ne représentent pas toujours exactement les nombres décimaux, en particulier les fractions.

Ceci pose problème quand on formate des nombres pour les afficher car JavaScript n'a pas de méthode native pour le faire. Par exemple:

alert(0.94 - 0.01); // affiche 0.9299999999999999

En conséquence, l'arrondi devrait être utilisé dès qu'un nombre est formaté pour l'affichage (en). La méthode toFixed() ne fait pas partie des spécifications de l'ECMAScript et est implémentée différemment selon l'environnement, elle ne peut donc être invoquée.

Les nombres peuvent être spécifiés dans l'une de ces notations :

345;    // un "entier", bien qu'il n'y ait qu'un seul type numérique en JavaScript
34.5;   // un nombre flottant
3.45e2; // un autre nombre flottant, équivalent à 345
0377;   // un entier octal égal à 255
0xFF;   // un entier hexadecimal égal à 255, les lettres A-F peuvent être en minuscules ou en majuscules

Dans certaines implémentations de l'ECMAScript comme l'ActionScript, les couleurs sont parfois spécifiées avec des nombres entiers en écriture hexadécimale :

var colorful = new Color( '_root.shapes' );
colorful.setRGB( 0x003366 );

Le constructeur Number peut être utilisé pour réaliser une conversion numérique explicite :

var myString = "123.456"
var myNumber = Number( myString );

Quand il est utilisé comme un constructeur, un objet wrapper numérique est créé (toutefois il est peu employé) :

myNumericWrapper = new Number( 123.456 );

Un tableau est un ensemble d'éléments repérés par leur indice, qui est un nombre entier. En JavaScript, tous les objets peuvent être formés d'un ensemble d'éléments, mais les tableaux sont des objets spéciaux qui disposent de méthodes spécifiques (par exemple, join, slice, et push).

Les tableaux ont une propriété length qui représente la longueur du tableau, c'est-à-dire le nombre d'éléments qu'il peut contenir. La propriété length d'un tableau est toujours supérieure à l'indice maximal utilisé dans ce tableau (N.B. Les indices de tableaux sont numérotés à partir de zéro). Si on crée un élément de tableau avec un indice supérieur à length, length est automatiquement augmentée. Inversement, si on diminue la valeur de length, cela supprime automatiquement les éléments qui ont un indice supérieur ou égal. La propriété length est la seule caractéristique qui distingue les tableaux des autres objets.

Les éléments de tableau peuvent être accédés avec la notation normale d'accès aux propriétés d'objet :

monTableau[1];
monTableau["1"];

Les 2 notations ci-dessus sont équivalentes.

Par contre, il n'est pas possible d'utiliser la notation "point" : objet.propriété, ni d'autres représentations du nombre entier de l'indice :

monTableau.1;       // déclenche une erreur de syntaxe
monTableau["01"];   // n'est pas identique à monTableau[1]

La déclaration d'un tableau peut se faire littéralement ou par l'utilisation du constructeur Array :

monTableau = [0,1,,,4,5];             // crée un tableau de longueur 6 avec 4 éléments
monTableau = new Array(0,1,2,3,4,5);  // crée un tableau de longueur 6 avec 6 éléments
monTableau = new Array(365);          // crée un tableau vide de longueur 365

Les tableaux sont implémentés de façon que seuls les éléments utilisés utilisent de la mémoire ; ce sont des tableaux sporadiques. Si l'on crée un tableau monTableau de longueur 58, puis qu'on attribue monTableau[10] = 'uneValeur' et monTableau[57] = 'uneAutreValeur', l'espace occupé correspondra seulement à ces 2 éléments, comme pour tous les objets. La propriété length du tableau restera quand même à 58.

Grâce à la déclaration littérale, on peut créer des objets similaires aux tableaux associatifs d'autres langages :

chien = {"couleur":"brun", "taille":"grand"};
chien["couleur"];           // rend la valeur "brun"

On peut mélanger les déclarations littérales d'objets et de tableaux pour créer facilement des tableaux associatifs, multidimensionnels, ou les deux à la fois :

chats = [{"couleur":"gris", "taille":"grand"},
         {"couleur":"noir", "taille":"petit"}];
chats[0]["taille"];         // rend la valeur "grand"
chiens = {"azor":{"couleur":"brun", "taille":"grand"},
          "milou":{"couleur":"blanc", "taille":"petit"}};
chiens["milou"]["taille"];  // rend la valeur "petit"

En Javascript la chaîne de caractères est considérée comme une suite de caractères. Une chaîne de caractères en JavaScript peut être directement créée en plaçant des caractères entre quotes (doubles ou simples) :

var salutation = "Hello, world!";
var salutmartien = 'Bonjour, amis terriens';

Dans les navigateurs basés sur Mozilla, les caractères d'une chaîne peuvent être accédés individuellement (ils sont considérés comme des chaînes d'un seul caractère) avec la même notation que pour les tableaux :

var a = salutation[0];        // a vaut 'H' - dans un navigateur basé sur Mozilla seulement

Dans Internet Explorer, il est nécessaire d'utiliser la méthode charAt() issue de la classe String. C'est la technique recommandée étant donnée qu'elle fonctionne aussi sur les navigateurs issus de Mozilla :

var a = salutation.charAt(0); // a vaut 'H' - fonctionne avec Internet Explorer
                              //              et avec les navigateurs basés sur Mozilla

En JavaScript les chaînes sont immuables :

salutation[0] = "H";      // erreur

L'opérateur d'égalité == permet de comparer le contenu de deux chaînes de caractères (en tenant compte de la casse), et retourne un booléen :

var x = "world";
var compare1 = ("Hello, " + x == "Hello, world"); // compare1 vaut true
var compare2 = ("Hello, " + x == "hello, world"); // compare2 vaut false car les
                                                  // premiers caractères des arguments
                                                  // n'ont pas la même casse

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)

=     Affectation
+=    Ajoute et affecte
-=    Soustrait et affecte
*=    Multiplie et affecte
/=    Divise et affecte
%=    Applique le modulo 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

==    É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

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.

Opérateurs binaires

&     And  : et binaire
|     Or  : ou binaire
^     Xor  : ou binaire exclusif

<<    Shift left  : décalage à gauche avec remplissage à droite avec 0)
>>    Shift right : décalage à droite avec conservation du bit de signe (le bit de gauche, celui du signe, est décalé vers la droite et recopié à son emplacement)
>>>   Shift right : décalage à droite sans conservation du bit de signe (avec remplissage à gauche avec 0)

      Pour les nombres positifs, >> et >>> donnent le même résultat

Opérateur unaire

~     Not : inverse tous les bits

Affectation

&= Et binaire puis affectation
|= Ou binaire puis affectation
^= Ou exclusif binaire puis affectation
<<= Décalage binaire à gauche puis affectation
>>= Décalage binaire à droite avec conservation du bit de signe puis affectation
>>>= Décalage binaire à droite sans conservation du bit de signe puis affectation

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

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

 if (expression1)
 {
   //instructions réalisées si expression1 est vraie;
 }
 else if (expression2)
 {
   //instructions réalisées si expression1 est fausse et expression2 est vraie;
 }
 else
 {
   //instructions réalisées dans les autres cas;
 }

Dans chaque structure if..else, la branche else  :

• est facultative
• peut contenir une autre structure if..else

L'opérateur conditionnel crée une expression qui, en fonction d'une condition donnée, prend la valeur de l'une ou l'autre de 2 expressions données. Son fonctionnement est similaire à celui de la structure si..sinon qui, en fonction d'une condition donnée, exécute l'une ou l'autre de 2 instructions données. En ce sens on peut dire que l'opérateur conditionnel est aux expressions ce que la structure si..sinon est aux instructions.

 var resultat = (condition) ? expression1 : expression2;

Le code ci-dessus, qui utilise l'opérateur conditionnel, a le même effet que le code ci-dessous, qui utilise une structure si..sinon :

 if (condition)
 {
   resultat = expression1;
 }
 else
 {
   resultat = expression2;
 }

Contrairement à la structure si..sinon, la partie correspondant à la branche sinon est obligatoire.

 var resultat = (condition) ? expression1; // incorrect car il manque la valeur à prendre si condition est fausse

L'instruction switch remplace une série de si..sinon pour tester les nombreuses valeurs que peut prendre une expression :

 switch (expression) {
   case UneValeur: 
     // instructions réalisées si expression=UneValeur;
     break;
   case UneAutreValeur: 
     // instructions réalisées si expression=UneAutreValeur;
     break;
   default:
     // instructions réalisées dans les autres cas;
     break;
 }

• l'instruction break; termine le bloc case (le cas à traiter). Elle est facultative dans la syntaxe Javascript. Cependant, elle est recommandée, car en son absence l'exécution continuerait dans le bloc case suivant. Dans le dernier bloc case d'un switch l'instruction break; ne sert à rien, sauf à prévoir l'éventualité où on rajouterait plus tard un bloc case supplémentaire.
• la valeur du case peut être une chaîne de caractères
• les accolades { } sont obligatoires

Syntaxe pour plusieurs lignes d'instructions :

 for (initialisation;condition;instruction de boucle) {
   /*
      instructions exécutées à chaque passage dans la boucle     
      tant que la condition est vérifiée
   */
 }

Syntaxe pour une seule instruction :

 for (initialisation;condition;instruction)

 for (var Propriete in Objet) {
   //instructions utilisant Objet[Propriete];
 }

• L'itération s'effectue sur toutes les propriétés qui peuvent être associées à un compteur
• Les avis divergent sur la possibilité d'utiliser cette boucle avec un tableau[1].
• L'ensemble des propriétés balayées dans la boucle diffère selon les navigateurs. Théoriquement, cela dépend d'une propriété interne appelée "DontEnum" définie dans le standard ECMAscript, mais dans la pratique chaque navigateur renvoie un ensemble différent.

break permet de sortir d'une boucle.

continue permet de passer à l'itération suivante de la boucle.

var listeFruit=["pomme","poire","banane","cerise",
            "framboise", "biscotte", "abricot", "mangue",
            "prune", "olive", "fraise"];
 for(var i=0;i< listeFruit.length;i++) {
  var fruit = listeFruit[i];
    if(fruit == "olive"){
     break;
    }
    if(fruit == "biscotte"){
     continue;
    }
    document.write(fruit + "<br>"); 
 }

Les labels permettent de "briser" (break) ou continuer (continue) plusieurs niveaux de boucles.

 var listeFruit=[["pomme","poire","banane","cerise"],
            ["framboise", "biscotte", "abricot", "mangue"],
            ["prune", "olive", "fraise"],
            ["concombre", "cresson", "haricot"]];
 listons:
 for(var i=0;i< listeFruit.length;i++) {
  var sousliste = listeFruit[i];
  for(var j=0;j< sousliste.length;j++){
  var fruit=sousliste[j];
    if(fruit == "olive"){
     break listons;
    }
    if(fruit == "biscotte"){
     continue listons;
    }
    document.write(fruit + "<br>"); 
  }
 }

Les labels permettent aussi de sortir d'un block de code anonyme.

 var fruit=["pomme","poire","banane","cerise"];
 listons: 
 {
  document.write(fruit[0] + "<br>"); 
  document.write(fruit[1] + "<br>"); 
  document.write(fruit[2] + "<br>"); 
  break listons;
  document.write(fruit[3] + "<br>"); 
  document.write(fruit[4] + "<br>"); 
  document.write(fruit[5] + "<br>"); 
 }

  with(Objet) {
    var a = getElementById('a');
    var b = getElementById('b');
    var c = getElementById('c');
  };

• On n’a alors plus besoin d’écrire Objet. avant chaque getElementById().
• Les variables déclarées avec var dans un bloc with(){...} (ici, a, b et c) ne modifient pas l’objet référencé par with(), mais restent dans le contexte local de la fonction ou du bloc en cours.
• Toute utilisation ou affectation de variable non déclarée dans le contexte local avec var va d’abord rechercher l’existence d'une propriété homonyme dans l’objet référencé par l’instruction with() la plus imbriquée en cours, avant de remonter récursivement la chaîne des instructions with() englobantes pour rechercher cette propriété dans les autres objets correspondants ; si une telle propriété n’est pas trouvée lors de l’affectation, une nouvelle propriété sera créée dans l'objet du dernier contexte introduit par l’instruction with().
• Dans un navigateur, le code Javascript s'exécute dans le contexte de l’objet window qui englobe tous les autres contextes de résolution, et qui désigne la fenêtre du navigateur et référence dans ses propriétés tous les autres objets, dont au moins :
  • lui-même dans sa propriété homonyme (window),
  • l'objet navigator donnant des renseignements sur le navigateur ayant créé la fenêtre,
  • l’objet frames contenant la liste des cadres affichés dans la fenêtre (l'un d'eux contient le document chargé tout entier),
  • l’objet location donnant les propriétés permettant de désigner, localiser et charger la source du document dans le cadre principal de la fenêtre,
  • l’objet history contenant l’historique de tous les emplacements visités dans l’ordre par le navigateur,
  • l’objet document chargé dans cette fenêtre (ses propriétés sont décrites dans le modèle de document DOM).
• Dans d’autres applications qu’un navigateur, l’objet principal conteneur dans lequel s’exécute un script peut être différent et peut désigner le système hôte fournissant ses services sous formes de méthodes et propriétés.

Attention, le code suivant :

  with(Objet) {
    b = getElementById('a');
  };

n’est pas totalement équivalent à :

   Objet.b = Objet.getElementById('a');

• En effet dans le second, la propriété b ne peut être affectée quand dans l’objet référencé par la variable Objet, qui doit déjà exister et pointer sur un objet existant. Aucune propriété d’un autre objet ne sera affecté. Si Objet ne référence aucun objet, il aura la valeur undefined (indéfini) et ne contiendra aucune propriété ; de ce fait l'affectation de sa propriété b inexistante ne donnera pas d'erreur mais lui ajoutera cette propriété alors que sa lecture donnera l'objet undefined qui produira une erreur si on essaye d'en extraire ses propres propriétés.
• En revanche, dans le premier, l'affectation peut modifier toute propriété nommée b dans un objet englobant (par exemple le document ou la fenêtre qui sera alors modifié).

Pour ces raisons, il est hautement recommandé de désigner explicitement l'objet dans lequel on affecte une valeur (faute de quoi des effets de bords restent possibles), ou de déclarer toutes les variables locales (avec var) afin de ne pas modifier les objets englobants, ce qui limite très fortement l’intérêt de l'instruction with() ; il vaut donc mieux déclarer une variable locale (ci-dessous nommée o) pour y stocker une référence à l'objet désigné (si cette référence est complexe et coûteuse à obtenir), et utiliser ses propriétés en préfixant toutes les propriétés ou méthodes par le nom de cette variable locale, afin de lever toute ambiguïté à l'exécution selon le contexte d'appel, et éviter ainsi des effets de bords inattendus :

  var o = Objet;
  o. b = o.getElementById('a');

Les objets peuvent être créés à l'aide d'un constructeur ou de façon littérale. Le constructeur peut utiliser la fonction prédéfinie Object ou une fonction sur mesure. Par convention les noms des fonctions constructeurs commencent par une majuscule.

// création à l'aide du constructeur prédéfini :
var premierObjet = new Object();
// création littérale :
var objetA = {};
var monObjet = {nom: 'vistemboir', utilite: 'cet objet ne sert à rien', prix: 5000};

Les déclarations littérales d'objets et de tableaux permettent de créer facilement des structures de données adaptées aux besoins :

var maStructure = {
  nom: {
     prenom: "Sylvain",
     patronyme: "Etiré"
  },
  age: 33,
  distractions: [ "oenologie", "beuveries" ]
};

C'est la base de JSON, un format d'échanges de données utilisant une syntaxe inspirée des objets Javascript.

Les constructeurs assignent simplement des valeurs aux slots de l'objet nouvellement créé. Les valeurs assignées peuvent être elles-mêmes d'autres fonctions.

Contrairement à ce qui se passe dans d'autres langages à objets, en Javascript les objets n'ont pas de type. Le constructeur qui sert à créer l'objet n'est pas mémorisé. C'est simplement une fonction qui remplit les slots et le prototype du nouvel objet. Donc le constructeur ne correspond pas à la notion de classe qu'on trouve dans d'autres langages.

Les fonctions sont elles-mêmes des objets, ce qui peut servir à obtenir le même fonctionnement que les "static properties" des langages C++ et Java (cf exemple ci-dessous).

Les fonctions ont une propriété spécifique appelée prototype (cf paragraphe Héritage ci-dessous).

La destruction d'objet est rarement pratiquée car elle est peu nécessaire. En effet le ramasse-miettes détruit automatiquement les objets qui ne sont plus référencés.

Exemple : manipulation d'objet

function MonObjet(attributA, attributB) {
  this.attributA = attributA;
  this.attributB = attributB;
}

MonObjet.statiqueC = " bleu";   // ajoute à la fonction une propriété statique avec une valeur
println(MonObjet.statiqueC);    // imprime ' bleu'

objet = new MonObjet(' rouge', 1000);

println(objet.attributA);      // imprime ' rouge'
println(objet["attributB"]);   // imprime 1000

println(objet.statiqueC);      // imprime 'undefined'

objet.attributC = new Date();  // ajoute à l'objet une nouvelle propriété avec une valeur

delete objet.attributB;        // enlève une propriété à l'objet
println(objet.attributB);      // imprime 'undefined'

delete objet;                  // supprime l'objet entier (rarement utilisé)
println(objet.attributA);      // déclenche une exception

Une méthode est simplement une fonction qui est assignée à la valeur d'un slot d'objet. Contrairement à ce qui se passe dans de nombreux langages à objets, dans Javascript il n'y a pas de distinction entre la définition d'une fonction et la définition d'une méthode. La différence peut apparaître lors de l'appel de la fonction : une fonction peut être appelée comme une méthode.

Dans l'exemple ci-dessous, la fonction Gloup assigne simplement des valeurs aux slots. Certaines de ces valeurs sont des fonctions. De cette façon Gloup peut assigner des fonctions différentes au même slot de différentes instances du même objet. N.B. Il n'y a pas de prototypage dans cet exemple.

function y2() {return this.xxx + "2 ";}
 
function Gloup(xz) {
  this.xxx = "yyy-";
  if (xz > 0) 
    this.xx = function() {return this.xxx +"X ";};
  else 
    this.xx = function() {return this.xxx +"Z ";};
  this.yy = y2;
}
 
var gloup_un = new Gloup(1);
var gloup_zero = new Gloup(0);

gloup_zero.xxx = "aaa-";

println(gloup_un.xx() + gloup_zero.xx());              // imprime yyy-X aaa-Z

gloup_un.y3 = y2;           // assigne à y3 la fonction y2 elle-même et non pas son résultat y2()
 
var bloub={"xxx": "zzz-"}   // création d'un objet sans utilisation de constructeur
bloub.y4 = y2               // assigne à y4 la fonction y2 elle-même et non pas son résultat y2()
 
println(gloup_un.yy() + gloup_un.y3() + bloub.y4());  // imprime yyy-2 yyy-2 zzz-2
 
gloup_un.y2();              // déclenche une exception car gloup_un.y2 n'existe pas

Javascript supporte les hiérarchies d'héritage par prototypage de la même façon que le langage self. Chaque objet contient un slot implicite appelé prototype.

Dans l'exemple ci-dessous, la classe Bagnole hérite de la classe Vehicule. Quand on crée l'instance b de la classe Bagnole, une référence à l'instance de base de la classe Vehicule est copiée dans b. La classe Bagnole ne contient pas de valeur pour la fonction roule. Quand la fonction roule est appelée cette fonction est recherchée dans l'arborescence d'héritage et elle est trouvée dans la classe Vehicule. Cela se voit clairement dans l'exemple : si on change la valeur de vehicule.roule, on retrouve cette valeur dans b.roule.

Les implémentations de Javascript basées sur Mozilla permettent d'accéder explicitement au prototype d'un objet grâce à un slot appelé _proto_ comme dans l'exemple ci-dessous.

function Vehicule() {
  this.roues = function() {println("nombre pair de roues");};
  this.roule = function() {println("ça roule");};
}

function Bagnole() {
  this.roues = function() {println("quatre roues");};
// redéfinition de la fonction roues pour la classe Bagnole
}

vehicule = new Vehicule();
Bagnole.prototype = vehicule;    // doit être exécuté avant d'instancier Bagnole

b = new Bagnole();               // crée b ce qui copie vehicule dans le slot prototype de b

vehicule.roule = function() {println("ça roule sur terrain plat")}
// redéfinition de la fonction roule pour l'objet vehicule

b.roues();                                   // imprime quatre roues
b.roule();                                   // imprime ça roule sur terrain plat
println(b.roule == Bagnole.prototype.roule); // imprime true
println(b.__proto__ == vehicule);            // imprime true seulement avec Mozilla

L'exemple suivant montre clairement que les références aux prototypes sont copiées lors de la création de l'instance et que les changements appliqués au prototype se répercutent dans toutes les instances qui s'y réfèrent.

function m1() {return "un ";}
function m2() {return "deux ";}
function m3() {return "trois ";}

function Base() {}

Base.prototype.y = m2;
alpha = new Base();
println(alpha.y());                      // imprime deux 

function Special(){this.y = m3}
special = new Special();

beta = new Base();
Base.prototype = special;                // n'a pas d'effet sur alpha et beta qui sont déjà créés
println(beta.y());                       // imprime deux 

gamma = new Base();                      // gamma est créé avec special dans son slot prototype
println(gamma.y());                      // imprime trois 

special.y = m1;                          // impacte gamma et ses éventuelles classes dérivées
println(gamma.y());                      // imprime un

En pratique de nombreuses variations d'héritage sont utilisées, ce qui peut être très puissant mais aussi prêter à confusion.

Javascript est sensible à la casse.

L'usage est de donner aux objets un nom qui commence par une majuscule et de donner aux fonctions ou variables un nom qui commence par une minuscule.

Dans le langage Javascript les instructions se terminent par un point-virgule.

Cependant Javascript comporte un mécanisme d'insertion automatique de point-virgule : lors de l'analyse d'une ligne de code qui ne se termine pas par un point-virgule, si le contenu de la ligne correspond à une instruction correcte, la ligne peut être traitée comme si elle se terminait par un point-virgule.

Les caractères espace, tabulation, fin de ligne et leurs variantes, quand ils ne sont pas inclus dans une chaîne de caractères, sont désignés sous le terme général whitespace. Les caractères whitespace peuvent avoir un effet sur le code à cause du mécanisme d'insertion automatique de point-virgule.

Pour éviter les effets non désirés dus au mécanisme d'insertion automatique de point-virgule, il est conseillé d'ajouter systématiquement un point-virgule à la fin de chaque instruction, même si cela diminue la lisibilité du code.

Exemple d'effet non désiré :

return
a + b;
//   ces 2 lignes renvoient undefined car elles sont traitées comme :
//   return;
//   a + b;

Autre exemple :

a = b + c
(d + e).fonc()
//   pas de point-virgule ajouté, les lignes sont traitées comme :
//   a = b + c(d + e).fonc()

D'autre part, les caractères whitespace accroissent inutilement la taille du programme et donc du fichier .js. La solution la plus simple à ce problème est de faire comprimer les fichiers par le serveur, ce qui réduira la taille de tous les fichiers source téléchargés sur le serveur. La compression en zip fonctionne mieux que les logiciels spécialisés en suppression de whitespace (whitespace parser).

La syntaxe des commentaires est la même qu'en C++.

// commentaire

/* commentaire
   multiligne */

Il est interdit d'imbriquer les commentaires :

/* cette syntaxe
   /* est interdite */
*/

• David Flanagan, Paula Ferguson: JavaScript: The Definitive Guide, O'Reilly & Associates, (ISBN 0-596-10199-6)
• Danny Goodman, Brendan Eich: JavaScript Bible, Wiley, John & Sons, (ISBN 0-7645-3342-8)
• Thomas A. Powell, Fritz Schneider: JavaScript: The Complete Reference, McGraw-Hill Companies, (ISBN 0-07-219127-9)
• Emily Vander Veer: JavaScript For Dummies, 4th Edition, Wiley, (ISBN 0-7645-7659-3)

• JavaScript

Reference material

• Core References for JavaScript versions 1.5
  • « 1.4 » (version du 12 mai 2008 sur l'Internet Archive)
  • « 1.3 » (version du 11 mai 2008 sur l'Internet Archive)
  • « 1.2 » (version du 10 mai 2008 sur l'Internet Archive)

Ressources

• Mozilla JavaScript Language Documentation
• A re-introduction to JavaScript - Mozilla Developer Center

• Portail de la programmation informatique