JavaScript

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
 Ne doit pas être confondu avec Java (langage).
JavaScript
Logo.

Date de première version Voir et modifier les données sur Wikidata
Auteur Brendan Eich
Développeurs Netscape Communications Corporation, Mozilla Foundation
Dernière version ECMAScript 7 ()Voir et modifier les données sur Wikidata
Paradigme Multi-paradigme: script, orienté objet (orienté prototype), impératif, fonctionel
Typage dynamique, faible
Normes ECMA-262
ISO/CEI 16262
Dialectes JavaScript, JScript, ECMAScript
Influencé par Self, Scheme[1], Perl, C, Java, Python
A influencé JScript, JScript .NET, Objective-J, TIScript, Swift
Implémentations SpiderMonkey, Rhino, KJS, JavaScriptCore, V8
Site web Mozilla

JavaScript est un langage de programmation de scripts principalement employé dans les pages web interactives mais aussi pour les serveurs[2]. C'est un langage orienté objet à prototype, c'est-à-dire que les bases du langage et ses principales interfaces sont fournies par des objets qui ne sont pas des instances de classes, mais qui sont chacun équipés de constructeurs permettant de créer leurs propriétés, et notamment une propriété de prototypage qui permet d'en créer des objets héritiers personnalisés. En outre, les fonctions sont des objets de première classe.

JavaScript a été créé en 1995 par Brendan Eich. Il a été standardisé sous le nom d'ECMAScript en juin 1997 par Ecma International dans le standard ECMA-262. Le standard ECMA-262 en est actuellement à sa 7e édition. JavaScript n'est depuis qu'une implémentation d'ECMAScript, celle mise en œuvre par la fondation Mozilla. L'implémentation d'ECMAScript par Microsoft se nomme JScript, tandis que celle d'Adobe Systems se nomme ActionScript.

Histoire[modifier | modifier le code]

Le langage a été créé en dix jours en mai 1995 par Brendan Eich pour le compte de la Netscape Communications Corporation, qui s'est inspiré de nombreux langages, notamment de Java mais en simplifiant la syntaxe pour les débutants[3].

LiveScript et Mosaic Communications Corporation[modifier | modifier le code]

Brendan Eich a initialement développé un langage de script côté serveur, appelé LiveScript, pour renforcer l'offre commerciale de serveur HTTP de Mosaic Communications Corporation. La sortie de LiveScript intervient à l'époque où le NCSA force Mosaic Communications Corporation à changer de nom pour devenir Netscape Communications Corporation.

Netscape travaille alors au développement d'une version orientée client de LiveScript. Quelques jours avant sa sortie, Netscape change le nom de LiveScript pour JavaScript. Sun Microsystems et Netscape étaient partenaires, et la machine virtuelle Java de plus en plus populaire. Ce changement de nom servait les intérêts des deux sociétés.

Netscape et ECMAScript[modifier | modifier le code]

En , Sun et Netscape annoncent[4] la sortie de JavaScript. En , Netscape met en œuvre le moteur JavaScript dans son navigateur Web Netscape Navigator 2.0. Le succès de ce navigateur contribue à l'adoption rapide de JavaScript dans le développement web orienté client. Microsoft réagit alors en développant JScript, qu'il inclut ensuite dans Internet Explorer 3.0 en pour la sortie de son navigateur.

JavaScript est décrit comme un complément à Java dans un communiqué de presse[4] commun de Netscape et Sun Microsystems, daté du . Cette initiative a contribué à créer auprès du public une certaine confusion entre les deux langages, proches syntaxiquement mais pas du tout dans leurs concepts fondamentaux, et qui perdure encore au début des années 2010.

Netscape soumet alors JavaScript à Ecma International pour standardisation. Les travaux débutent en et se terminent en , donnant naissance au langage ECMAScript, spécifié dans la 1re édition du standard ECMA-262. En , quelques modifications sont apportés pour l'adapter au standard international ISO/IEC-16262, aboutissant à la 2e édition du standard ECMA-262. La 3e édition est publiée en . Le développement de la 4e édition du standard ECMA-262 n'a jamais été achevé. La 5e édition sort en . La 6e édition sort en . L'édition actuelle du standard ECMA-262 est la 7e, sortie en .

Concepts[modifier | modifier le code]

Le propos de JavaScript est de manipuler de façon simple des objets, au sens informatique, fournis par une application hôte.

Hello world[modifier | modifier le code]

Voici l'exemple classique du « hello world » en JavaScript, lorsque l'application hôte est un navigateur Web :

alert("Hello world");

Dans l'application hôte, alert est une méthode de la classe DOM window, mais celle-ci étant récurrente, c'est une des seules classes dont on ne doit pas forcément préciser le nom pour utiliser ses méthodes.

La syntaxe

window.alert("Hello world");

aura donc exactement le même résultat.

Versions[modifier | modifier le code]

Depuis la version 1.3, JavaScript est un sur-ensemble du langage ECMAScript spécifié dans le standard ECMA-262. À partir de la version 1.8.5, la fondation Mozilla qui s'occupe de l'implémentation de JavaScript abandonne sa numérotation et se conforme aux éditions du standard ECMA-262[5].

Version 1.0[modifier | modifier le code]

Sortie en mars 1996.

Version 1.1[modifier | modifier le code]

Sortie en août 1996.

Version 1.2[modifier | modifier le code]

Sortie en juin 1997.

Version 1.3[modifier | modifier le code]

Sortie en octobre 1998. Implémentation basée sur les spécifications des 1re et 2e édition du standard ECMA-262.

Version 1.4[modifier | modifier le code]

Sortie en 1999.

Version 1.5[modifier | modifier le code]

Sortie en novembre 2000. Implémentation basée sur les spécifications de la 3e édition du standard ECMA-262.

Version 1.6[modifier | modifier le code]

Sortie en novembre 2005.

Version 1.7[modifier | modifier le code]

Sortie en octobre 2006.

Version 1.8[modifier | modifier le code]

Sortie en juin 2008.

Version 1.8.1[modifier | modifier le code]

Sortie en juin 2009.

Version 1.8.2[modifier | modifier le code]

Sortie en juin 2009.

Version 1.8.5[modifier | modifier le code]

Sortie en juillet 2010. Implémentation basée sur les spécifications de la 5e édition du standard ECMA-262.

Utilisation[modifier | modifier le code]

Dans une page web[modifier | modifier le code]

Du code JavaScript peut être intégré directement au sein des pages web, pour y être exécuté sur le poste client. C'est alors le navigateur Web qui prend en charge l'exécution de ces programmes appelés scripts.

Généralement, JavaScript sert à contrôler les données saisies dans des formulaires HTML, ou à interagir avec le document HTML via l'interface Document Object Model, fournie par le navigateur (on parle alors parfois de HTML dynamique ou DHTML). Il est aussi utilisé pour réaliser des services dynamiques, parfois futiles, strictement cosmétiques ou à des fins ergonomiques.

JavaScript n'est pas limité à la manipulation de documents HTML et peut aussi servir à manipuler des documents SVG, XUL et autres dialectes XML .

Incompatibilités[modifier | modifier le code]

Netscape et Microsoft (avec JScript dans Internet Explorer) ont développé leur propre variante de ce langage qui chacune supporte presque intégralement la norme ECMAScript mais possède des fonctionnalités supplémentaires et incompatibles, rarement utilisées dans le cadre de la programmation de pages web. Pourtant les scripts JavaScript sont souvent la source de difficultés. Elles sont plus souvent dues à la prise en charge des différentes versions des modèles d'objets (DOM) fournis par les navigateurs, qu'à des problèmes de portabilité du langage (les différentes mises en œuvre respectant relativement bien la norme ECMAScript).

Face à ce problème on utilise souvent une construction du type

if (monObjet.methode) { 
  monObjet.methode();
}

Il est toutefois préférable d'utiliser une comparaison sur le type

if (typeof monObjet.methode !== "undefined") {
  monObjet.methode();
}

ou mieux encore :

if (typeof monObjet.methode === "function") {
  monObjet.methode();
}

On vérifie ainsi que monObjet a bien une mise en œuvre de methode que l'on peut alors utiliser. Le plus souvent, si un navigateur ne gère pas la methode de monObjet, il gère une méthode comparable methode2, et on peut alors adapter le code JavaScript au navigateur qui l'exécute :

if (typeof monObjet.methode === "function") {
  monObjet.methode();
} else if (typeof monObjet.methode2 === "function") {
  monObjet.methode2();
}

Une autre méthode consiste à vérifier, côté serveur, le navigateur utilisé par le client et d'envoyer le code correspondant. Cela n'est toutefois pas recommandable, car il est largement préférable de tester directement l'existence, le comportement d'une fonction, d'une propriété, etc. plutôt que de faire des présomptions basées sur la détection du navigateur.

Ajax[modifier | modifier le code]

Article détaillé : Ajax (informatique).

JavaScript est utilisé dans la méthode Ajax (de l'anglais Asynchronous Javascript And XML) qui sert à modifier le contenu des pages web par programmation. Suite à des manipulations de l'utilisateur, des scripts en langage JavaScript vont envoyer des demandes au serveur Web en utilisant l'objet XMLHTTPRequest. Puis des scripts vont modifier le contenu de la page web en fonction de la réponse reçue ; la réponse est en format XML et le script manipule l'ensemble d'objets DOM qui représente le contenu de la page. Les technologies XMLHTTPRequest, XML et DOM ont été ajoutées aux navigateurs web entre 1995 et 2005. La méthode Ajax permet de réaliser des applications Internet riches, offrant une maniabilité et un confort supérieur ; c'est un des sujets phares du mouvement Web 2.0.

JSON[modifier | modifier le code]

Article détaillé : JavaScript Object Notation.

JSON (JavaScript Object Notation) est un format utilisant la notation des objets JavaScript pour transmettre de l'information structurée, d'une façon plus compacte et plus proche des langages de programmation, que XML.

Malgré l'existence du DOM et l'introduction récente de E4X (voir ci-dessous) dans la spécification du langage JavaScript, JSON reste le moyen le plus simple d'accéder à des données, puisque chaque flux JSON n'est rien d'autre qu'un objet JavaScript sérialisé. De plus, malgré son lien historique (et technique) avec JavaScript, JSON reste un format de données structurées, et peut être utilisé facilement par tous les langages de programmation.

Depuis 2009, les navigateurs commencent à intégrer un support natif du format JSON, ce qui facilite sa manipulation, la sécurité (contre l'évaluation de scripts malveillants inclus dans une chaine JSON), et la rapidité de traitement. Ainsi les navigateurs Firefox et IE[6] l'intègrent respectivement dès les versions 3.5 et 8.

Autres utilisations[modifier | modifier le code]

Sur un serveur web[modifier | modifier le code]

JavaScript peut également être utilisé comme langage de programmation sur un serveur HTTP à l'image des langages comme PHP, ASP, etc. D'ailleurs le projet CommonJS travaille dans le but de spécifier un écosystème pour JavaScript en dehors du navigateur (par exemple sur le serveur ou pour les applications de bureau natives). Le projet a été lancé par Kevin Dangoor en janvier 2009. Le projet CommonJS n'est pas affilié avec le groupe de l'Ecma International TC39 travaillant sur ECMAScript, mais certains membres du TC39 participent au projet.

Historiquement, JavaScript était proposé sur les serveurs de Netscape, par la suite distribués par Sun Microsystems sous les noms iPlanet et Sun ONE, mais JScript peut aussi être utilisé sur les serveurs Internet Information Services de Microsoft. JScript peut d'ailleurs servir pour scripter une plate-forme Microsoft Windows via Windows Scripting Host (WSH).

Il existe par ailleurs des projets indépendants et Open Source d'implémentation de serveurs en JavaScript. Parmi eux, on pourra distinguer Node.js, une plateforme polyvalente de développement d'applications réseau se basant sur le moteur JavaScript V8 et les spécifications CommonJS.

Autres supports[modifier | modifier le code]

ActionScript, utilisé dans Adobe Flash, est aussi une mise en œuvre d'ECMAScript. Il permet de manipuler tous les éléments de l'animation, considérés comme des objets. JavaScript peut être utilisé pour scripter d'autres applications Adobe (Photoshop, Illustrator, …), ce qui permet d'avoir des scripts indépendants de la plate-forme (Microsoft Windows, Apple OSX, Linux…).

JavaScript est enfin utilisé dans la plate-forme de développement Mozilla, sur laquelle sont basés plusieurs logiciels comme des navigateurs Web, pour des tâches relatives à l'interface utilisateur et à la communication interne (ex. : les extensions de Firefox et Thunderbird sont installées à base de fichiers XPI utilisant le JavaScript. Voir aussi Prefs.js).

Depuis 2004, l'objet js de l'environnement de programmation graphique Max/MSP permet d'ouvrir une fenêtre pour programmer en JavaScript, au sein même d'un programme Max/MSP.

Les logiciels ImageJ et CaRMetal sont munis de consoles JavaScript, qui leur permettent d'écrire des scripts dans un contexte graphique. Et Algobox utilise JavaScript pour la syntaxe de ses fonctions.

JavaScript est aussi utilisé dans un contenu BIFS pour l'exploitation des événements. Pour cela la spécification BIFS fournit un nœud Script pour incorporer de l'ECMAScript.

La suite bureautique OpenOffice.org permet d'utiliser JavaScript comme langage de macros.

JavaScript est aussi utilisable en shell[7] ou avec les gadgets Vista.

Enfin, JavaScript est également utilisé pour dynamiser le QML de la bibliothèque graphique Qt.

Particularités du langage[modifier | modifier le code]

Liaison des identifiants[modifier | modifier le code]

Une variable est un identifiant lié à une entité. En JavaScript, toutes les variables sont des pointeurs (comme en Python, Ruby, C#, Java, mais à la différence du C++), c'est-à-dire que leur identifiant est lié à une entité via une adresse mémoire. Les variables ne stockent donc pas directement en mémoire la valeur de l'entité mais l'adresse mémoire de l'entité. Par ailleurs, l'opération d'affectation d'une variable ne modifie pas la valeur de l'entité à laquelle la variable est liée mais l'adresse mémoire stockée par la variable ; la variable se retrouve alors liée à une nouvelle entité : on parle de changement de liaison de la variable (en anglais variable rebinding).

var maVariable1 = 0; // initialise "maVariable1" avec l'adresse de la valeur 0
var maVariable2 = maVariable1; // initialise "maVariable2" avec l'adresse de la valeur pointée par "maVariable1"
maVariable2++; // affecte "maVariable2" (équivalent à "maVariable2 = maVariable2 + 1;") avec l'adresse de la valeur pointée par "maVariable2 + 1" (donc n'affecte pas la valeur pointée par "maVariable2")
alert(maVariable1); // affiche 0
alert(maVariable2); // affiche 1

var maVariable3 = [1, 2, 3];
var maVariable4 = maVariable3; // initialise "d" avec l'adresse de la valeur pointée par "maVariable3"
maVariable4 = [4, 5, 6]; // affecte "maVariable4" avec l'adresse de la valeur [4, 5, 6] (donc n'affecte pas la valeur pointée par "maVariable4")
alert(maVariable3); // affiche [1, 2, 3]
alert(maVariable4); // affiche [4, 5, 6]

var maVariable5 = [1, 2, 3];
var maVariable6 = maVariable5; // initialise "maVariable6" avec l'adresse de la valeur pointée par "maVariable5"
maVariable6.push(4); // affecte le nouvel élément ajouté à la valeur pointée par "maVariable6" avec l'adresse de la valeur 4 (donc affecte la valeur pointée par "maVariable6")
alert(maVariable5);  // affiche [1, 2, 3, 4]
alert(maVariable6);  // affiche [1, 2, 3, 4]

Portée lexicale des variables[modifier | modifier le code]

La portée lexicale d'une variable est la partie d'un programme où la liaison entre son identifiant et son entité est valide. En JavaScript, la portée lexicale d'une variable peut être de deux types, selon le mot-clé utilisé pour la déclarer :

  • var : au niveau de la fonction (ou de l'espace global) où elle est déclarée (comme en Python, Ruby) ;
  • let ou const (introduits dans ECMAScript 6) : au niveau du bloc où elle est déclarée (comme en C++, C#, Java) — une fonction étant un bloc particulier.
// 1. Déclaration dans un bloc

if (true) {            // début du bloc
    var maVariable1;   // declaration de la variable
    let maVariable2;   // declaration de la variable
    const maVariable3; // declaration de la variable
}                      // fin du bloc mais pas de la portée de la variable

alert(maVariable1);    // ne soulève pas d'erreur
alert(maVariable2);    // erreur : la variable est hors de sa portée
alert(maVariable3);    // erreur : la variable est hors de sa portée

// 2. Déclaration dans une fonction

function maFunction() { // début de la fonction
    var maVariable4;    // declaration de la variable
    let maVariable5;    // declaration de la variable
    const maVariable6;  // declaration de la variable
}                       // fin de la fonction et de la portée de la variable

alert(maVariable4);     // erreur : la variable est hors de sa portée
alert(maVariable5);     // erreur : la variable est hors de sa portée
alert(maVariable6);     // erreur : la variable est hors de sa portée

Une variable peut être affectée où masquée par une fonction enfant de la fonction (ou de l'espace global) où elle est déclarée :

var maVariable1 = 0; // définition de la variable parente

// 1. Affectation

function maFonction1() { // fonction enfant
    maVariable1 = 1;     // affectation de la variable parente
}

alert(maVariable1);      // affiche 0
maFonction1();           // affecte la variable parente
alert(maVariable1);      // affiche 1

// 2. Masquage

var maVariable2 = 0;     // définition de la variable parente

function maFonction2() { // fonction enfant
    var maVariable2;     // déclaration de la variable enfant masquant la variable parente
    maVariable2 = 1;     // affectation de la variable enfant
}

alert(maVariable2);      // affiche 0
maFonction2();
alert(maVariable2);      // affiche 0

Déclaration des variables[modifier | modifier le code]

En JavaScript, quelque soit le lieu de la déclaration d'une variable dans sa portée lexicale, la variable est créée au début de l'évaluation de sa portée lexicale.

Les variables déclarées avec le mot-clé var sont en plus pré-initialisée à la valeur undefined lors de leur création, et donc accessibles dès le début de leur portée lexicale. On parle de remontée de la variable (variable hoisting en anglais) car cela se passe comme si la déclaration de la variable était remontée au début de sa portée lexicale :

alert(maVariable); // affiche "undefined"
var maVariable = 0;
alert(maVariable); // affiche 0

Les variables déclarées avec le mot-clé let ou const (ECMAScript 6) ne sont pas pré-initialisées, et donc inaccessibles avant leur déclaration. Si une variable déclarée avec le mot-clé let ne possède pas d'initialiseur, elle est initialisée à la valeur undefined lors de l'évaluation de la déclaration, sinon elle est initialisée avec l'initialiseur lors de l'évaluation de la déclaration. Si une variable déclarée avec le mot-clé const ne possède pas d'initialiseur, une erreur est levée lors de l'évaluation de la déclaration, sinon elle est initialisée avec l'initialiseur lors de l'évaluation de la déclaration :

// 1. Avec initialiseur

alert(maVariable1); // erreur : accès impossible avant l'initialisation
alert(maVariable2); // erreur : accès impossible avant l'initialisation
let maVariable1 = 5;
const maVariable2 = 8;
alert(maVariable1); // affiche 5
alert(maVariable2); // affiche 8

// 2. Sans initialiseur

alert(maVariable3); // erreur : accès impossible avant l'initialisation
alert(maVariable4); // erreur : accès impossible avant l'initialisation
let maVariable3;
const maVariable4; // erreur : initialisation manquante
alert(maVariable3); // affiche "undefined"
alert(maVariable4); // erreur : initialisation manquante

De plus, JavaScript autorise la redéclaration de la même variable dans sa portée lexicale, mais uniquement avec le mot-clé var :

var maVariable = 2;
var maVariable = 9;

Variables globales[modifier | modifier le code]

En JavaScript, il existe plusieurs façons de déclarer une variable globale, et certaines interagissent avec l'objet global (nommé window dans les navigateurs) :

var maVariable1 = 0;
let maVariable2 = 0;
const maVariable3 = 0;
maVariable4 = 0;
window.maVariable5 = 0;
this.maVariable6 = 0;
  1. La variable est aussi une propriété ou méthode de l'objet global qui ne peut pas être détruite par l'opérateur delete.
  2. La variable n'est pas une propriété ou méthode de l'objet global.
  3. La variable n'est pas une propriété ou méthode de l'objet global.
  4. La variable est aussi une propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete.
  5. La variable est aussi une propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete.
  6. La variable est aussi une propriété ou méthode de l'objet global qui peut être détruite par l'opérateur delete.

Une variable initialisée sans déclaration est traitée comme une variable globale :

function maFonction() {
    maVariable = 5;
}

maFonction();
alert(maVariable); // affiche 5

Fonctions anonymes[modifier | modifier le code]

Les fonctions anonymes sont, comme leur nom l'indique, des fonctions qui ne portent pas de nom :

setTimeout(function () {
    alert("Trois secondes se sont écoulées.");
}, 3000);

Fermetures lexicales[modifier | modifier le code]

Un environnement lexical est l'ensemble des variables valides dans une partie du programme. Il est composé de l'environnement lexical interne (les variables locales) et d'une référence à l'environnement lexical externe (les variables non locales).

Une fermeture lexicale (lexical closure en anglais) est une fonction accompagnée de son environnement lexical externe, c'est-à-dire l'ensemble des variables non locales qu'elle a capturé, soit par valeur (c'est-à-dire par copie des valeurs des variables), soit par référence (c'est-à-dire par copie des adresses mémoires des variables). Comme en JavaScript toutes les variables sont des pointeurs (cf. la section Liaison des identifiants), JavaScript n'utilise que la capture par référence — ce qui correspond en C++11 à la syntaxe [&](…) { … }; —, et la durée de vie des variables non locales capturées par une fonction est prolongée à la durée de vie de la fonction — ce qui n'est pas le cas en C++11, quelque soit le type de capture :

function maFonction() {
    var maVariable = 4;  // variable parente
    
    return function () {
        alert(maVariable);
    }
}

var maFermeture = maFonction(); // capture de la variable parente par référence
maFermeture(); // affiche 4

Expressions de fonctions immédiatement invoquées[modifier | modifier le code]

Jusqu'à ECMAScript 6, JavaScript ne proposait pas nativement de portée des variables au niveau des blocs (pas de mots-clé let ou const), ni de modules. Pour éviter de polluer l'espace global, une méthode consistait à encapsuler son code dans une fonction pour s'appuyer sur la portée des variables qui a lieu au niveau des fonctions en JavaScript, puis à invoquer cette fonction juste après. Pour regrouper les deux étapes (définition de la fonction et invocation) et ne pas ajouter un nom de fonction supplémentaire dans l'espace global, le langage permet les expressions de fonctions immédiatement invoquées (EFII ; en anglais immediately-invoked function expressions, IIFE)[8].

Plusieurs syntaxes sont possibles pour ce type d'expression, les plus répandues étant :

  • (function (…) { … }(…)); (syntaxe recommandée par Douglas Crockford pour sa lisibilité)[9] ;
  • (function (…) { … })(…);

L'opérateur d'invocation de fonction () à la fin permet l'exécution immédiate de la fonction. Les parenthèses en gras indiquent à l'analyseur syntaxique qu'elles contiennent une expression, car en JavaScript les parenthèses ne peuvent pas contenir de déclaration. Autrement, dans la plupart des situations, le mot clé fonction est traité comme une déclaration de fonction, et pas comme une expression de fonction. Il existe d'autres façons pour forcer une expression de fonction :

  • !function (…) { … }(…);
  • ~function (…) { … }(…);
  • -function (…) { … }(…);
  • +function (…) { … }(…);

Dans les contextes où une expression est attendue il n'est pas nécessaire d'utiliser les parenthèses en gras :

  • var maVariable = function (…) { … }(…);
  • true && function (…) { … }(…);
  • 0, function (…) { … }(…);

Une utilisation importante des expressions de fonctions immédiatement invoquées est pour la création de modules. Les modules permettent à la fois de rassembler des propriétés et des méthodes dans un espace de nom et de rendre certains membres privés :

var compteur = (function () {
    var i = 0; // propriété privée

    return {   // méthodes publiques
        obtenir: function () {
            alert(i);
        },
        mettre: function (valeur) {
            i = valeur;
        },
        incrementer: function () {
            alert(++i);
        }
    };
})(); // module

compteur.obtenir();     // affiche 0
compteur.mettre(6);
compteur.incrementer(); // affiche 7
compteur.incrementer(); // affiche 8
compteur.incrementer(); // affiche 9

Prototypes[modifier | modifier le code]

Les prototypes sont des objets utilisés lors d'un échec de résolution de nom. Ce mécanisme est un type d'héritage : l'héritage par prototype. En JavaScript, tout objet possède un prototype, accessible via la méthode Object.getPrototypeOf (ou via la propriété historique __proto__ standardisée dans ECMAScript 6 pour assurer la compatibilité entre les navigateurs mais non recommandée). De plus, l'opérateur new permet de transformer l'invocation d'une fonction constructeur en un objet (instanciation) dont le prototype est égale à la propriété prototype de la fonction constructeur :

function MonConstructeur() {
    this.maPropriete1 = 3;
}

var monInstance = new MonConstructeur();
alert(monInstance.maPropriete1); // affiche 3
alert(Object.getPrototypeOf(monInstance) === MonConstructeur.prototype); // affiche "true"
MonConstructeur.prototype.maPropriete2 = 5;
alert(monInstance.maPropriete2); // affiche 5

Toute instance de MonConstructeur (monInstance ici) possède un prototype égale à MonConstructeur.prototype. Lors de l'utilisation d'une propriété ou d'une méthode d'une instance de MonConstructeur (monInstance.maPropriete1 et monInstance.maPropriete2 ici), si l'instance ne possède pas la propriété ou la méthode recherchée, la recherche se poursuit dans le prototype de l'instance (MonConstructeur.prototype ici). Si la recherche échoue aussi avec cet objet, la recherche se poursuit dans le prototype de cet objet, et ainsi de suite jusqu'à arriver à la première fonction constructeur. Si la recherche échoue encore, cette première fonction constructeur étant une fonction donc une instance de la fonction constructeur Fonction du langage, la recherche se poursuit dans son prototype qui est égale à Fonction.prototype. Si la recherche échoue à nouveau, Fonction.prototype étant un objet donc une instance de la fonction constructeur Object du langage, la recherche se poursuit dans son prototype qui est égale à Object.prototype. Si la recherche échoue cette fois, comme le prototype de Object.prototype est égale à null, la recherche s'arrête et JavaScript génère une erreur de résolution de nom. Ce mécanisme de recherche parcoure ce qu'on appelle la chaîne de prototypes.

Le code de l'opérateur instanceOf illustre bien ce mécanisme. A instanceOf B (ou de manière équivalente : instanceOf.call(A, B)) renvoie true si A est une instance de B, c'est-à-dire si B.prototype est trouvé dans le chaîne de prototypes de A, et false sinon :

function instanceOf(f) {
    var o = this;

    while (o !== null) {
        if (Object.getPrototypeOf(o) === f.prototype) {
            return true;
        }

        o = Object.getPrototypeOf(o);
    }

    return false;
}

Par ailleurs, la méthode Object.create introduite dans ECMAScript 5 permet d'éviter d'utiliser directement les fonctions constructeurs, leurs propriétés prototype et l'opérateur new, pour ne travailler qu'avec des objets. L'utilisation de cette méthode simplifie grandement la complexité du code et est donc recommandée. La méthode Object.create est définie par

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

L'exemple précédent peut alors être réécrit

var MonObjet = {
    function initialiser() {
        this.maPropriete1 = 3;
    }
}

var monInstance = Object.create(MonObjet);
monInstance.initialiser();
alert(monInstance.maPropriete1); // affiche 3
MonObjet.maPropriete2 = 5;
alert(monInstance.maPropriete2); // affiche 5

Séparation des instructions[modifier | modifier le code]

En C, chaque instruction se termine par un point-virgule. Cette pratique a fait du point-virgule une obligation dans de nombreux langages inspirés de la syntaxe du C.

JavaScript est plus souple, permettant à une fin de ligne de marquer implicitement la fin d'une instruction. Le but est de faciliter l'usage du langage aux personnes inexpérimentées en programmation informatique. Mais cette souplesse introduit des effets inattendus[10] :

return
    true;

Le parseur comprend cela comme deux instructions :

return;
true;

Les expressions de fonctions immédiatement invoquées lorsque le programmeur s'appuie sur les fins d'instruction implicites rencontrent également ce genre de problème avec l'usage des parenthèses :

maVariable1 = maVariable2 + maVariable3

(function () { 
    // code
})()

est traité comme

maVariable1 = maVariable2 + maVariable3(function () { /* code */ })();

Les ouvrages de programmation avancés en JavaScript mettent en garde contre les effets inattendus de la déduction automatique de fin d'instruction et conseillent d'écrire un point-virgule à la fin de chaque instruction, ce qui n'empêche pas les surprises lorsqu'on oublie le point-virgule, d'autant plus quand la compression du code impose le retrait des retours chariot.

E4X[modifier | modifier le code]

Les versions récentes de la mise en œuvre du langage JavaScript de SpiderMonkey supportent l'E4X. Il s'agit d'un support natif de XML ainsi que d'un support natif d'une syntaxe d'accès aux données XML (sorte de XPath).

Exemple :

var xml = <menu id="file" value="File">
    <popup>
        <menuitem value="New" onclick="CreateNewDoc()" />
        <menuitem value="Open" onclick="OpenDoc()" />
        <menuitem value="Close" onclick="CloseDoc()" />
    </popup>
</menu>

Exemple d'accès aux données :

xml.popup.menuitem.(@value == "New").@onclick;

L'exemple ci-dessus récupère la fonction correspondant à l'action "New". Le résultat de l'évaluation est "CreateNewDoc()". Autre exemple :

var maVariable = 2;
xml.popup.menuitem[maVariable].@value;

Le résultat de l'évaluation est "Close".

Notes et références[modifier | modifier le code]

  1. Douglas Crockford, dans un conférence à Yahoo! Crockford on JavaScript - Chapter 2: And Then There Was JavaScript, se limite à Java, Scheme et Self comme influence direct de Javascript
  2. (en) http://wiki.commonjs.org/wiki/CommonJS
  3. TechVision: Innovators of the Net: Brendan Eich and JavaScript
  4. a et b (en) NETSCAPE AND SUN ANNOUNCE JAVASCRIPT, THE OPEN, CROSS-PLATFORM OBJECT SCRIPTING LANGUAGE FOR ENTERPRISE NETWORKS AND THE INTERNET
  5. « Nouveautés et historique de JavaScript », sur Mozilla Developer Network (consulté le 16 juillet 2016)
  6. http://blogs.msdn.com/ie/archive/2008/09/10/native-json-in-ie8.aspx
  7. Voir Introduction au shell JavaScript
  8. (en) Ben Alman, « Immediately-Invoked Function Expression (IIFE) », sur benalman.com,‎ (consulté le 14 mai 2016)
  9. (en) Douglas Crockford, « Code Conventions for the JavaScript Programming Language », sur javascript.crockford.com (consulté le 14 mai 2016)
  10. Cet exemple est donné page 25 par : JavaScript - The Definitive Guide, Fourth Edition, David Flanagan, éditions O'Reilly Media, Sebastopol, Californie.

Voir aussi[modifier | modifier le code]

Articles connexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]

Sur les autres projets Wikimedia :