JavaScript – introduction

Le langage ECMAScript, connu sous plusieurs noms, en particulier sous son nom d'origine qu'est JavaScript, est l'un des langages de scripts les plus populaires dans le monde merveilleux du Web. À peu près tous les fureteurs commercialement pertinents supportent au moins un dialecte de ce langage.

Bien que la dénomination JavaScript soit la plus connue et la plus commune, retenez que ECMAScript est le fruit de la standardisation de JavaScript (et de JScript et de Mocha et de LiveScript et...). Un langage de script est habituellement un langage interprété, donc traduit ligne par ligne, méthode par méthode ou instruction par instruction en code exécutable plutôt que compilé une fois pour être exécuté sur une plateforme donnée. Dans les cas qui nous intéressent, les interpréteurs sont les fureteurs Web ou des modules qui leur sont ajoutés.

Malgré son nom, JavaScript n'est pas un dialecte de Java ou un sous-ensemble de Java. Les similitudes syntaxiques de ce langage avec Java ressemblent à celles qui existent entre Java et C ou entre C# et Java. Les deux langages ne viennent même pas d'une souche commune, Java étant un produit de Sun Microsystems alors que JavaScript fut, à la base, mis au point par Brendan Eich de Netscape (aujourd'hui derrière le fureteur Brave).

Le suffixe « Script » tend à faire croire que JavaScript est un langage jouet, mais il se trouve en fait que ce langage entre dans le créneau de ce qu'on nomme les langages dynamiques, de même que dans la catégorie des langages fonctionnels. À plusieurs égards, d'ailleurs, JavaScript est plus près de Lisp que de Java.

Les langages dynamiques ont ceci de particulier que leur structure tend à être fluide et changeante, même une fois qu'un programme a été lancé. Selon les langages, il peut être possible de modifier le système de types, ajouter des classes, ajouter des fonctions et ainsi de suite. En général, pour être en mesure de permettre de telles manœuvres, les langages de scripts offrent aussi un mécanisme d'introspection permettant de décrire le langage dans ses propres termes (les programmeuses et les programmeurs Java et .NET reconnaîtront une similitude avec la réflexivité dans ces langages).

Le caractère interprété et dynamique de JavaScript le rend particulièrement propice à l'injection de comportements dynamiques dans une page Web, donc à l'accroissement de l'expérience de navigation sur Internet. Le fait que les langages dynamiques et, de manière générale, les langages de scripts soient pour la plupart interprétés implique aussi que les programmes écrits dans ces langages soient portables, une qualité indéniable pour le déploiement à travers Internet.

Comment fonctionne JavaScript dans une page Web

Dans une page Web, le code JavaScript peut être intégré directement dans le texte de la page et est en mesure d'interagir avec le modèle DOM du document qu'elle décrit. Son côté script est mis en valeur par le fait que le code dans la page, exécuté par le fureteur, peut réagir aux éléments de la page et les modifier.

Les cas les plus simples de recours à JavaScript, traditionnellement, incluent la génération de fenêtres modales d'avertissement (des popups), les changements d'états de contrôles sur la page alors que la souris se déplace sur eux ou la validation des entrées de l'usager dans un formulaire.

Cela dit, JavaScript est un véritable langage de programmation, très polyvalent, ce qui rend la tâche de sécuriser les fureteurs foncièrement plus complexe qu'il n'y paraît a priori. Certaines attaques (comme les célèbres manœuvres de Cross-Site Scripting , ou XSS) qui permettent, surtout avec certains fureteurs plus fragiles, la réalisation d'opérations dangereuses comme des accès au disque local d'un ordinateur ou la capture d'informations privilégiées. Souvenons-nous en effet que JavaScript interagit avec le DOM d'un document, alors si une manoeuvre de programmation parvient à injecter du code JavaScript discrètement dans une page conçue imprudemment, il peut devenir possible d'envoyer des données confidentielles à un tiers hostile sans que l'humain devant le fureteur n'en soit conscient.

<html>
  <head>
    <title>Titre</title>
    <script type='text/javascript'>
      // le code va ici
    </script>
  </head>
  <body>
    <!-- le code de la page Web -->
  </body>
</html>

Intégrer du code JavaScript directement à une page Web pose problème à plusieurs égards :

• la réutilisation du code devient une opération de copier/ coller
• la séparation de la forme et du fond est compromise
• le code est visible à tout individu examinant les sources de la page; etc.

La vision du Web comme plateforme de développement a plusieurs impacts sur les pratiques de développement qu'on y retrouve, incluant une standardisation des usages et une formalisation de certains vieux trucs sous forme de schémas de conception ou d'idiomes de programmation.

Plusieurs plateformes existent aujourd'hui pour formaliser une démarche plus programmatique que celle rencontrée traditionnellement dans les pages Web. Indiquer, par exemple, que tous les éléments du document qui sont munis d'une même classe ou d'un même nom soient soumis aux mêmes règles de validation (ce qui évite les accidents qui surviennent lorsqu'un humain doit insérer ces indications à la pièce).

<html>
   <head>
      <title>Test</title>
      <script type='text/javascript'>
/* votre code JavaScript va ici */
      </script>
   </head>
<body>
  <!-- peu importe -->
</body>
</html>

<html>
   <head>
      <title>Test</title>
      <script type='text/javascript'
              language="javascript"
              src="moncode.js" />
   </head>
<body>
  <!-- peu importe -->
</body>
</html>

Accéder à un élément de la représentation DOM d'un document

Dans un document HTML, les éléments peuvent être qualifiés par un nom, un identifiant, une classe et ainsi de suite

<!-- peu importe -->
<input class="text" id="val_a" />
<input class="text" id="val_b" />
<button onclick="calculerSomme();">
  Additionner
</button>
<input class="text" id="resultat" />
<!-- peu importe -->

function calculerSomme () {  var x = new Number(
    document.getElementById("val_a").value
  );
  var y = new Number(
    document.getElementById("val_b").value
  );
  var somme = x + y;
  document.getElementById("resultat").value = somme;
}

JavaScript et les événements

Au préalable, le principal rôle de JavaScript était de valider le contenu des formulaires Web avant émission. Cette validation ne remplace pas la validation côté serveur (nécessaire parce que le monde demeure un milieu hostile) mais peut par exemple permettre d'éviter l'envoi d'un formulaire dont certains champs obligatoires n'ont pas été remplis.

<form action="operationCoteServeur" onsubmit="return valider()">
  <!-- peu importe -->
</form>

Si la fonction retourne false ou quelque chose qui, en JavaScript, équivaut au concept de faux, alors il n'y aura pas du tout d'envoi de données vers le serveur, économisant ainsi temps de traitement et bande passante.

<html>
  <head>
    <title>Petite d&eacute;mo</title>
    <style type="text/css">
      #exemple {
        display: none; margin: 3%; padding: 4%;
        background-color: limegreen
      }
    </style>
    <script type="text/javascript">
      function modifierAffichage (id) {
        d=document.getElementById("cacher_ou_non");
        e=document.getElementById(id);
        if (e.style.display == 'none' ||
            e.style.display == "") {
          e.style.display = 'block';
        } else {
          e.style.display = 'none';
        }
      }
    </script>
  </head>
  <body>
    <div>
      <a id="cacher_ou_non"
         href="javascript:modifierAffichage('exemple')">
           Petit exemple chouette
      </a>
    </div>
    <div id="exemple">
      Un exemple pourrait aller ici
    </div>
    <p>Et ainsi de suite...</p>
  </body>
</html>

Bases syntaxiques de JavaScript

Le langage JavaScript a plusieurs particularités. Tout d'abord, à l'instar de plusieurs langages dynamiques, ce n'est pas un langage fortement typé ce qui implique que ses variables sont nommées puis utilisées et que c'est le moteur du langage qui cherche à comprendre pour nous ce que nous cherchons à faire.

Ceci implique aussi qu'il n'y a pas, en JavaScript, de déclaration de variable à proprement dit. Dans ce langage, une variable existe dès qu'on la nomme et dès qu'on commence à l'utiliser. De plus, toutes les variables y sont globales sauf si elles sont préfixées de var lors de leur première utilisation (dans ce cas, elles sont locales au bloc où elles apparaissent). Cet énoncé demeure vrai que la variable soit initialisée dans une fonction ou hors de toute fonction.

function coucou() {
   val = 3;
   alert('Coucou!' + val);
}
function bonjour() {
   alert('Bonjour!' + val);
}

Personnellement, je recommande des saines pratiques de programmation : réduisez les globales au minimum et utilisez var chaque fois que cela s'avère possible.

Comme dans bien des langages à accolades, chaque instruction et chaque déclaration est terminée par un ; et chaque bloc logique d'instructions est délimité par une paire d'accolades. Les commentaires suivent la même forme que ceux en C++ ou en Java. Le langage est sensible aux majuscules et aux minuscules.

Le code JavaScript est analysé de haut en bas par son interpréteur. Le code qui ne se situe pas dans une fonction est du code global qui sera exécuté dans l'ordre.

Opérateurs

L'opérateur + sert à la fois aux additions numériques (var x = 2 + 3; dépose 5 dans x) et à la concaténation de texte (var x = 2 + '3'; dépose '23' dans x).

Les opérateurs arithmétiques usuels (+, évidemment, de même que -, *, / et %) se comportent comme en Java ou en C++. L'affectation s'exprime par l'opérateur =. Les opérateurs ++ et -- (en version préfixée ou postfixée) et les opérateurs +=, -=, *=, /= et %= se comportent aussi comme en Java ou en C++.

Les opérateurs de comparaison habituels dans les langages à accolades (==, !=, <, <=, >, >=) fonctionnent selon les usages. Deux opérateurs s'ajoutent, soit === pour identiques (même valeur, même type) et !== (non identiques).

Les opérateurs logiques &&, || et ! ont le même comportement qu'en C++ pour la majorité des cas (je ne couvrirai pas les subtilités ici mais il y a une subtilité autour de && et ||). Les opérateurs bit à bit <<, >>, & et | ont aussi le comportement attendu (et l'opérateur >>> sort complètement de notre champ d'intérêt). L'opérateur ternaire ?: fonctionne tel qu'attendu.

Scalaires

Les nombres de JavaScript sont tous structurellement équivalent aux nombres à virgule flottante (double précision… des variables de type double) de C++ ou de Java. Ceci implique des risques d'imprécision lors d'affichages et lors de comparaisons (prudence!). Les notations habituelles en C++ ou en Java pour les littéraux numériques sont supportées (3, 3.14159, 2.12e4, 0xff, 0177) mais les variables contenant des nombres demeurent de format double peu importe la forme des littéraux qu'on leur affecte.

function coucou() {
   var val = "3";
   alert('Coucou!' + (val + 4));
}

Pour résoudre de tels imbroglios, on peut remplacer val par new Number(val) dans l'opération (val + 4). Ainsi, alert('Coucou!' + (new Number (val) + 4)) affichera Coucou!7. Le recours à l'instanciation d'un Number clarifie notre intention.

Pour la concaténation de chaînes, les formes x = x + "texte" et x += "texte" mènent toutes deux au même résultat.

Vous remarquerez que les notations 'allo' et "allo" sont toutes deux supportées pour dénoter des chaînes de caractères. Dans une page Web, il arrive que l'une soit plus utile que l'autre selon les circonstances.

function coucou() {
   var texte = "Coucou!";
   var premièreLettre = texte[0];
   alert(texte + " commence par un " + premièreLettre);
   texte[0] = "W"; // illégal
   alert(texte + " commence par un " + premièreLettre);
}

Structures de contrôle

<html>
   <head>
      <title>Division</title>
      <script type='text/javascript'>
function diviser(num, denom) {
  if (denom == 0) {
    throw "tentative de division par zéro!";
  }
  return num / denom;
}
function invoquerDiviser() {
  var numérateur = new Number(
    document.getElementById("numerateur").value
  );
  var dénominateur = new Number(
    document.getElementById("denominateur").value
  );
  var quotient;
  var résultat;
  try {
    quotient = diviser(numérateur, dénominateur);
    résultat = quotient;
  } catch (e) {
    résultat = e;
  } finally {
    document.getElementById("quotient").value =
       résultat;
  }
}
      </script>
   </head>
<body>
  <input class="text" id="numerateur"></input>
  <input class="text" id="denominateur"></input>
  <button onclick="invoquerDiviser();">
    Diviser
  </button>
  <input class="text" id="quotient"></input>
</body>
</html>

Tableaux

function coucou () {
   var ménagerie = new Array(3);
   ménagerie[0] = "chats";
   ménagerie[1] = "lapins";
   ménagerie[2] = "poissons";
   if (ménagerie.length > 0) {
      var texte = "Dans ma maison, il y a: ";
      for (i in ménagerie) {
         texte = " " + texte + "des " + ménagerie[i];
      }
      alert(texte);
   }
}

function coucou() {
   var ménagerie = ["chats", "lapins", "poissons"];
   var texte = "Dans ma maison, il y a: ";
   for (i in ménagerie) {
      texte = " " + texte + "des " + ménagerie[i];
   }
   alert(texte);
}

function coucou () {
   var ménagerie = new Array(3);
   ménagerie["félins"] = "chats";
   ménagerie["lagomorphes"] = "lapins";
   ménagerie["marins"] = "poissons";
   if (ménagerie.length > 0) {
      var texte = "Dans ma maison, il y a: ";
      for (i in ménagerie) {
         texte = " " + texte + "des " + ménagerie[i];
      }
      alert(texte);
   }
}

Fonctions

<html>
  <head>
    <title>Factorielle</title>
    <script type='text/javascript'>
      function factorielle(n) {
        var facto = 1;
        while (n > 0) {
          facto *= n;
          --n;
        }
        return facto;
      }
      function invoquerFactorielle() {
        var n = new Number(
          document.getElementById("valeur_n").value
        );
        var facto = factorielle(n);
        document.getElementById("resultat").value = facto;
      }
    </script>
  </head>
  <body>
    <input class="text" id="valeur_n"></input>
    <button onclick="invoquerFactorielle();">
      Factorielle
    </button>
    <input class="text" id="resultat"></input>
  </body>
</html>

On remarquera que le caractère dynamique du langage est mis en relief par la notation de la fonction : elle n'a pas de type (sinon celui de function), ses variables non plus (bien qu'on remarque le recours à une conversion explicite en Number pour éviter toute ambigüité).

<html>
   <head>
      <title>Test &ndash; 00</title>
      <script type='text/javascript'>
        function choixParDéfaut() {
          return function() {
            return "Vous n'avez pas encore choisi!";
          }
        }
        function choisirA() {
          choix = function() {
            return "Vous avez choisi A";
          }
        }
        function choisirB() {
          choix = function() {
            return "Vous avez choisi B";
          }
        }
        choix = choixParDéfaut();
        function executer() {
          alert(choix());
        }
      </script>
   </head>
<body>
  <button onclick="choisirA();">
    Choisir A
  </button>
  <button onclick="choisirB();">
    Choisir B
  </button>
  <button onclick="executer();">
    Ex&eacute;cuter!
  </button>
</body>
</html>

Notez que comme en Java, les paramètres de fonctions en JavaScript sont passés par valeur mais les objets étant toujours manipulés indirectement, le passage en paramètre d'un objet revient dans la majorité des cas à un passage par référence.

Objets

function Coucou() {
   var ChicProf = {
      nom : "Patrice Roy",
      cours : {
         nom : "Applications Internet",
         sigle : "INF777"
      },
   };
   alert(ChicProf.nom + " est un chic prof de " + ChicProf.cours.sigle);
}

La notation des tableaux est aussi applicable aux objets : dans l'exemple ci-dessus, ChicProf.nom et ChicProf['nom'] sont équivalents. La contrepartie n'est pas vraie : on ne peut pas appliquer la notation .nom à un tableau indicé par le littéral texte 'nom'.

function Bête(nom, espèce, poids) {
  this.nom = nom;
  this.espèce = espèce;
  this.poids = poids;
}
function créerDragon(nom, couleur, poids) {
  return new Bête(
    nom, "Dragon " + couleur, poids
  );
}
function surprise() {
  var Zak = créerDragon("Zak", "rouge", 3000);
  alert(Zak.nom + " est un " + Zak.espèce + " de " + Zak.poids + " Kg.");
}

// constructeur de Bête (inchangé)
// créerDragon() (inchangé)
function surprise() {
  var Zak = créerDragon(
    "Zak", "rouge", 3000
  );
  alert(Zak.nom + " est un " + Zak.espèce + " de " + Zak.poids + " Kg.");
  envol(Zak);
  ajouterAiles(Zak, 'grandes');
  envol(Zak);
  couperAiles(Zak);
  envol(Zak);
}
function ajouterAiles(bête, valeur) {
  bête.ailes = valeur;
}
function couperAiles(bête) {
  if (bête.ailes != null) {
    delete bête.ailes;
  }
}
function envol(bête) {
  if (bête.ailes != null) {
    alert(bête.nom + " peut voler");
  } else {
    alert(bête.nom + " n'a pas d'ailes!");
  }
}

Encapsulation

function Bête(unNom) {
  var nom = unNom;
  this.getNom = function() {
    return nom;
  }
  // ...
}
function surprise() {
  var Zak = new Bête("Zak");
  alert(Zak.getNom()); // etc.
}

Notez qu'en JavaScript, une méthode d'instance privée est une méthode déclarée dans le constructeur de l'objet auquel elle appartient (et donc invisible de l'extérieur).

Selon l'usage en JavaScript, la méthode getNom() d'une Bête est ce qu'on nomme une méthode privilégiée, en ce sens qu'elle a accès à la fois aux membres privés d'une Bête et qu'elle est accessible de l'extérieur, ayant été ajoutée à la Bête en question suivant la forme this.getNom = function() { ... }.

function Bête(unNom) {
  var nom = unNom;
  this.getNom = function() {
    return nom;
  }
  // ...
}
Bête.prototype.grogner = function(texte) {
  return this.getNom() + " fait " + texte;
}
function surprise() {
  var Zak = new Bête("Zak");
  alert(Zak.grogner("grrr")); // etc.
}

Encapsulation et immuabilité sans attributs

function Point(x, y) {
  return {
    getX() : { return x; }
    getY() : { return y; }
  }
}

Héritage

JavaScript ne supporte pas l'héritage au sens classique du terme et ne supporte pas non plus le polymorphisme en ce sens. Cependant, son caractère dynamique fait en sorte qu'un peu comme dans les langages permettant la programmation générique, il soit possible d'implémenter en JavaScript des algorithmes génériques complexes sur la base des signatures des objets.

Quelques liens sur JavaScript

Pour en savoir plus sur JavaScript, voici quelques pistes de lecture. Pour des liens d'ordre général :

• Petite introduction au langage : ../Sujets/Web/JavaScript-Intro.html
• Quelques-uns des principaux outils et quelques-unes des principales bibliothèques de ce langage : ../Sujets/Web/JavaScript-Outils.html
• Le Wiki du langage : http://en.wikipedia.org/wiki/JavaScript (aussi : http://en.wikibooks.org/wiki/Programming:JavaScript)
• La syntaxe du langage : http://en.wikipedia.org/wiki/JavaScript_syntax
• https://developer.mozilla.org/en/a_re-introduction_to_javascript
• La révolution JavaScript, selon Andrew Binstock en 2011 : http://drdobbs.com/open-source/231600203
• L'état de JavaScript en 2012, selon Brendan Eich... en 2012 : http://brendaneich.github.com/Strange-Loop-2012/#/
• Le langage est mieux connu côté client, mais côté serveur? http://en.wikipedia.org/wiki/Server-side_JavaScript
• Le langage JavaScript, présenté comme étant le langage incompris : http://www.crockford.com/javascript/javascript.html
• JavaScript et les threads : http://h-deb.ca/Liens/Multiprogrammation--Liens.html#dossiers-threads-javascript
• CaJa, qui est une sorte de JavaScript sécurisé : http://www.links.org/?p=271
• Des types algébriques en JavaScript : http://w3future.com/weblog/stories/2008/06/16/adtinjs.xml
• Écrire des applications Linux en JavaScript : http://arstechnica.com/open-source/news/2009/01/javascript-gtk-bindings.ars
• JavaScript a gagné la guerre des langages : http://www.jot.fm/issues/issue_2007_11/column3/index.html
• JavaScript en tant que Lingua Franca du Web : http://www.codinghorror.com/blog/archives/000857.html
• D'un point de vue sécurité, JavaScript doit mourir : http://www.jgc.org/blog/2009/09/javascript-must-die.html
• Peu importe ses irritants, JavaScript est important : http://threatpost.com/en_us/blogs/despite-danger-adobe-says-javascript-support-important-010410
• Traduire en XSLT en JavaScript : http://blog.typlab.com/2009/12/reinventing-xslt-in-pure-javascript/
• Affichage et compatibilité avec les moteurs DOM : http://en.wikipedia.org/wiki/Comparison_of_layout_engines_%28DOM%29
• JavaScript a besoin de modules? http://blog.mozilla.com/dherman/2010/07/08/javascript-needs-modules/ Non, il lui faut des macros! http://meta2.tumblr.com/post/787368639/javascript-needs-macros
• Le concours JS1K, ou faire une démo en moins de 1K lignes de code JavaScript :
  • http://js1k.com/home
  • http://blah.thingsinjars.com/post/293/the-quest-for-extreme-javascript-minification/
• http://thinkvitamin.com/dev/john-resig-on-advanced-javascript-to-improve-your-web-app/
• http://clubajax.org/javascript-its-a-real-language/
• Analyser les performances de diverses techniques en JavaScript : http://blog.thejit.org/2010/10/10/javascript-class-performance/
• Activer JavaScript dans un fureteur : http://www.enable-javascript.com/
• JavaScript en dix minutes : http://javascript.infogami.com/Javascript_in_Ten_Minutes/
• Comprendre Repaint et Reflow : http://www.vcarrer.com/2011/02/about-repaint-and-reflow-in-javascript.html
• http://zef.me/3715/three-routes-to-spaghetti-free-javascript
• http://zef.me/3753/planning-ahead-the-async-javascript-problem
• Performances d'un algorithme de manipulation de trie (une sorte d'arbre préfixé) en JavaScript : http://ejohn.org/blog/javascript-trie-performance-analysis/
• Implémenter min et max de manière performante : http://ejohn.org/blog/fast-javascript-maxmin/
• http://sayyouresorryforwhatyouvedone.blogspot.com/2011/04/douglas-crockford-for-javascript-good.
• http://blog.rebeccamurphey.com/modern-javascript
• Le « M » du schéma de conception MVC en JavaScript : http://backbonetutorials.com/what-is-a-model/
• L'expressivité de JavaScript : http://www.joelonsoftware.com/items/2006/08/01.html
• Métriques de performance :
  • http://crockford.com/javascript/performance.html
  • http://ejohn.org/blog/accuracy-of-javascript-time/
  • http://my.opera.com/emoller/blog/2011/05/01/javascript-performance
  • http://blog.mozilla.com/nnethercote/2011/06/21/you-make-what-you-measure/
• http://skilldrick.co.uk/2011/04/closures-explained-with-javascript/
• Compresser les programmes JavaScript : http://www.bitsnbites.eu/?p=20
• Économiser des bytes : https://github.com/jed/140bytes/wiki/Byte-saving-techniques
• http://radar.oreilly.com/2011/06/time-to-learn-javascript.html
• Exécution concurrente : http://qni.dk/2011/06/quick-thoughts-on-concurrent-javascript-execution/
• Bancs d'essais : http://blogs.msdn.com/b/ie/archive/2011/06/30/test262-industry-javascript-standards-test-available.aspx
• JavaScript n'est pas le langage d'assemblage du Web, selon Isaac Z. Schlueter en 2011 : http://blog.izs.me/post/10213512387/javascript-is-not-web-assembly
• Réflexions sur le système de types de JavaScript, textes de 2012 :
  • http://vijayan.ca/blog/2012/02/21/javascript-type-model/
  • http://vijayan.ca/blog/2012/03/12/javascript-a-very-meta-prelude/
• JavaScript et le mot clé this, texte de 2012 : http://henrycode.tumblr.com/post/37627169791/javascript-clarifying-the-keyword-this
• JavaScript serait-il le bytecode du Web? Une opinion émise en 2013 : http://mozakai.blogspot.ca/2013/05/the-elusive-universal-web-bytecode.html
• Selon Rob Conery en 2013, les Frameworks de JavaScript sont fabuleux mais tout le monde se plaint quand même : http://wekeroad.com/2013/08/22/js-frameworks-are-amazing-and-no-one-is-happy

Pédagogie

• https://developer.mozilla.org/en/JavaScript/Guide
• http://bonsaiden.github.com/JavaScript-Garden/
• Livre en ligne :
  • http://braythwayt.com/2013/10/01/javascript-allonge-is-free.html
• Survol rapide du langage, par Kalid Azad en 2013 : http://betterexplained.com/articles/the-single-page-javascript-overview/
• Faire du JavaScript correctement, un site tenu à jour par William Oliveira : http://jstherightway.com/
• http://addyosmani.com/resources/essentialjsdesignpatterns/book/
• http://addyosmani.com/resources/essentialjsdesignpatterns/book/#writingdesignpatterns
• Une table des matières pour plusieurs sujets : http://home.cogeco.ca/~ve3ll/jstutor0.htm
• En 2011, John Resig discute des caractéristiques de JavaScript comme porte d'entrée pour apprendre à programmer : http://ejohn.org/blog/javascript-as-a-first-language/
• Une attaque à travers JavaScript : le Cross-Site Scripting (ou XSS) : http://en.wikipedia.org/wiki/Cross-site_scripting
• Pour re-comprendre ce langage : https://developer.mozilla.org/en/A_re-introduction_to_JavaScript
• Quelques particularités du langage : http://www.ibm.com/developerworks/java/library/j-cb12196/?ca=dgr-lnxw07Javascript-Respect
• Comprendre undefined en JavaScript (ce n'est pas simple!), texte de George Ornbo en 2013 : http://shapeshed.com/the-void-of-undefined-in-javascript/
• Apprendre JavaScript sans se presser : http://kaijaeger.com/articles/javascript-for-people-who-are-in-a-hurry.html
• JavaScript pour étudiant(e)s avancé(e)s : http://ejohn.org/apps/learn/
• Les quatre 'C' de JavaScript : http://dailyjs.com/2010/02/03/four-cs/
• Comprendre les prototypes :
  • http://javascriptweblog.wordpress.com/2010/06/07/understanding-javascript-prototypes/
  • http://blog.vjeux.com/2011/javascript/how-prototypal-inheritance-really-works.html
  • prototypes et héritage en JavaScript, par Scott Allen en 2012 : http://msdn.microsoft.com/en-us/scriptjunkie/ff852808
  • explication par Toby Ho en 2010 : http://tobyho.com/2010/11/22/javascript-constructors-and/
  • la propriété prototype : http://www.devarticles.com/c/a/JavaScript/Object-Oriented-JavaScript-Using-the-Prototype-Property/
• Déclarations de fonctions et expressions de fonctions : http://javascriptweblog.wordpress.com/2010/07/06/function-declarations-vs-function-expressions/
• Comprendre le mot-clé delete : http://perfectionkills.com/understanding-delete/
• Solidifier les programmes en une seule ligne de code : http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/
• Dessiner avec JavaScript ou avec ActionScript? http://www.williammalone.com/articles/flash-vs-html5-canvas-drawing/
• http://neversaw.us/2010/9/7/javascript-the-magic-parts/
• Ce qui est bon pour C# peut ne pas l'être pour JavaScript :
  • http://enterprisejquery.com/2010/10/how-good-c-habits-can-encourage-bad-javascript-habits-part-1/
  • http://enterprisejquery.com/2010/10/how-good-c-habits-can-encourage-bad-javascript-habits-part-2/
• Réaliser des applications partielles de fonctions : http://msdn.microsoft.com/en-US/scriptjunkie/gg575560.aspx
• Oui, JavaScript permet d'écrire des programmes obscurs... http://adamcecc.blogspot.com/2011/01/javascript.html
• Implémenter l'héritage multiple : http://journal.stuffwithstuff.com/2011/02/21/multiple-inheritance-in-javascript/
• Comparatifs des outils de chargement pour JavaScript : https://spreadsheets.google.com/lv?key=tDdcrv9wNQRCNCRCflWxhYQ&toomany=true#gid=0
• L'impact du positionnement des accolades en JavaScript : http://encosia.com/2011/03/21/in-javascript-curly-brace-placement-matters-an-example/
• Mesurer le temps avec précision : http://ejohn.org/blog/accuracy-of-javascript-time/
• Attention aux paramètres de vos fonctions : http://spin.atomicobject.com/2011/04/10/javascript-don-t-reassign-your-function-arguments
• Comprendre les monades avec JavaScript : http://igstan.ro/posts/2011-05-02-understanding-monads-with-javascript.html
• JavaScript et les fonctions : http://newky.posterous.com/functions-in-javascript-javascript-week-off
• Attention aux fuites de mémoires : http://atkinson.posterous.com/javascript-closure-memory-leak
• Tutoriel interactif sur les fermetures : http://nathansjslessons.appspot.com/
• Quelques étrangetés du langage : http://wtfjs.com/
• Les zéros du langage :
  •  http://zero.milosz.ca/
  • en 2012, Axel Rauschmayer explique ce qu'il nomme les deux zéros de JavaScript : http://css.dzone.com/articles/javascripts-two-zeros
• Trouver une manière correcte d'exprimer le code JavaScript : https://gist.github.com/357981
• En 2011, Nick Morgan explique qu'au fond, malgé les apparences, JavaScript a quelques types primitifs : http://skilldrick.co.uk/2011/09/understanding-typeof-instanceof-and-constructor-in-javascript/
• En 2011, Philip Tellis explique comment analyser les caractéristiques d'un réseau avec JavaScript : http://coding.smashingmagazine.com/2011/11/14/analyzing-network-characteristics-using-javascript-and-the-dom-part-1/
• Appeler du code .NET à partir de JavaScript, texte du Code Project : http://www.codeproject.com/KB/scripting/use_code_from_javascript.aspx
• Contourner les défauts du langage, par Matthew Might en 2012 : http://matt.might.net/articles/javascript-warts/
• Utiliser => et this, un texte de Douglas Crockford en 2012 : http://www.yuiblog.com/blog/2012/03/30/what-is-the-meaning-of-this
• Comment bien enrichir JavaScript, texte de 2012 : http://www.websanova.com/tutorials/javascript/extending-javascript-the-right-way
• Façons de faire :
  • l'idiome des « modules » en JavaScript, par Jack Franklin en 2012 : http://javascriptplayground.com/blog/2012/04/javascript-module-pattern
  • le Crockford Pattern, par Joel G. Webber en 2013 : http://blog.j15r.com/blog/2013/08/24/A_Palatable_Javascript_Pattern
• Le JavaScript « moderne », perçu par Justin Etheredge en 2012 : http://www.codethinked.com/preparing-yourself-for-modern-javascript-development
• Quelques principes de programmation de code facile à entretenir en JavaScript, par Jonathan Creamer en 2012 : http://net.tutsplus.com/tutorials/javascript-ajax/principles-of-maintainable-javascript/
• JavaScript et portée lexicale :
  • Petit quiz à propos de la portée des objets avec JavaScript : http://madebyknight.com/javascript-scope/
  • Tout ce que vous devriez savoir sur la portée des variables en JavaScript, texte de 2014 : http://www.coolcoder.in/2014/03/everything-you-need-to-know-about.html
• Les générateurs en JavaScript, par James Long en 2012 : http://jlongster.com/2012/10/05/javascript-yield.html
• Manières d'appeler une fonction en JavaScript, texte de Barry Steyn en 2012 : http://doctrina.org/Javascript-Function-Invocation-Patterns.html
• Organiser le code JavaScript côté client, par Oz Katz en 2012 : http://ozkatz.github.com/structuring-client-side-javascript-code.html
• De l'importance des portées et des fermetures en JavaScript, texte de Barry Steyn en 2012 : http://doctrina.org/JavaScript:Why-Understanding-Scope-And-Closures-Matter.html
• en 2013, Derek Sivers relate son expérience d'apprentissage de JavaScript : http://sivers.org/learn-js
• Espaces nommés et modules en JavaScript, texte de Kenneth Truyers en 2013 : http://www.kenneth-truyers.net/2013/04/27/javascript-namespaces-and-modules/
• Prudence avec les fermetures, comme le rappelle Raymond Chen en 2014 : http://blogs.msdn.com/b/oldnewthing/archive/2014/06/05/10531181.aspx

Futur du langage

• En lien avec JavaScript 6, un texte de 2011 : http://kishorelive.com/2011/11/22/ecmascript-6-looks-promising/
• Propositions de Microsoft, en 2011 : http://blogs.msdn.com/b/ie/archive/2011/11/22/evolving-ecmascript.aspx
• En 2011, Tab Atkins Jr explique les raisons pour lesquelles il est très excité par l'avènement de Names, un système de noms uniques qui se veut sécuritaire : http://www.xanthir.com/b4FJ0
• La montée de JavaScript, par Dan North en 2011 : http://dannorth.net/2011/12/19/the-rise-and-rise-of-javascript/
• Un coup d'oeil sur Harmony, la prochaine version du standard ECMA pour JavaScript, par Andreas Rossberg en 2012 : http://blog.chromium.org/2012/02/future-of-javascript-take-peek-today.html
• Ce qui semble poindre à l'horizon pour 2013, selon Addy Osmani en 2012 : http://addyosmani.com/blog/a-few-new-things-coming-to-javascript/
• En 2013, Lincoln Baxter III explique qu'à son avis, JavaScript est « le nouveau Perl » : http://ocpsoft.org/opensource/javascript-is-the-new-perl/
• En 2013, JavaScript devient le langage par défaut pour développer sous Gnome. Article de Ian Elliott : http://www.i-programmer.info/news/167-javascript/5418-javascript-to-be-the-default-langauge-for-gnome.html
• Les liens entre Google et JavaScript, selon Alex Russell en 2011 : http://infrequently.org/2011/09/google-the-future-of-javascript/
• Comment JavaScript fait évoluer les applications Web, texte de Spike Brehm en 2013 : http://nerds.airbnb.com/isomorphic-javascript-future-web-apps/
• À propos de la popularité croissante de JavaScript en tant que plateforme, texte de 2014 par Rohan Pierce : http://www.techworld.com.au/article/536950/rise_rise_javascript/
• L'état de la situation pour ce qui est du support d'ECMAScript 6 dans Firefox : https://developer.mozilla.org/en/docs/Web/JavaScript/ECMAScript_6_support_in_Mozilla
• Coup d'oeil sur ce qui s'annonce pour ECMAScript 6, par Axel Rauschmayer en 2014 : https://speakerdeck.com/rauschma/ecmascript-6-whats-next-for-javascript-august-2014

Histoire du langage

• Ce qui constituait le RoadMap en 2005, selon l'auteur : http://weblogs.mozillazine.org/roadmap/archives/008325.html
• Histoire du langage, selon Brendan Eich en 2008 : www.computerworld.com.au/article/255293/a-z_programming_languages_javascript/
• JavaScript présenté comme le futur du Web, en 2006 : https://developer.mozilla.org/presentations/xtech2006/javascript/
• JavaScript 2 et le Web 2.0 : http://blog.jeremymartin.name/2008/03/web-20-meet-javascript-20.html
• Survol de ce dont avait l'air ECMAScript 4 : http://www.ecmascript.org/es4/spec/overview.pdf
• Ce en quoi ECMAScript 3 et ECMAScript 4 étaient incompatibles : http://www.ecmascript.org/es4/spec/incompatibilities.pdf
• Une acceptation de ECMAScript 5 (ça a changé depuis) : http://www.h-online.com/open/news/item/New-version-of-JavaScript-approved-878961.html
• Tutoriel de programmation évolutive en JavaScript 2 (ce qui équivaut à ECMAScript 4) : http://www.ecmascript.org/es4/spec/evolutionary-programming-tutorial.pdf
• Le standard ECMAScript (JavaScript avec un nom officiel) tel que proposé en décembre 2009 : http://www.ecma-international.org/publications/standards/Ecma-262.htm
• Des divergences avec ECMAScript 4 : http://ejohn.org/files/Adobe_position_on_ES4_features.pdf
• Le passé et le futur de JavaScript, selon son auteur : http://www.infoworld.com/d/developer-world/javascript-creator-ponders-past-future-704
• ECMAScript 5, selon l'auteur : http://www.sdtimes.com/blog/post/2009/04/16/Brendan-Eich-Explains-ECMAScript-Fifth-Edition-To-You.aspx
• http://brendaneich.com/2011/06/new-javascript-engine-module-owner/
• En 2013, Firefox a retiré l'option de désactiver JavaScript sur les sites Web visités. Armin Ronacher est d'avis qu'il était temps : http://lucumr.pocoo.org/2013/7/1/say-yes-to-javascript/
• En 2013, JavaScript a eu 18 ans :
  • article de 2013 : http://resin.io/blog/happy-18th-birthday-javascript/
  • l'état de la situation en 2014, un rapport : http://thoughtworks.fileburst.com/assets/technology-radar-jan-2014-en.pdf

JavaScript et l'approche orientée objet

Tel que mentionné plus haut, JavaScript n'est pas un langage orienté objet (OO) mais entretient tout de même des liens avec ce monde. À ce sujet, quelques pistes :

• Pourquoi faire du JavaScript OO : http://www.ajaxonomy.com/content/object-oriented-javascript-should-you-use-it
• Texte de 2013 par Ryan Kinal expliquant que l'impression d'utiliser des classes en JavaScript n'est qu'une illusion : http://blog.javascriptroom.com/2013/01/29/the-illusion-of-class/
• JavaScript et l'héritage :
  • texte de Douglas Crockford : http://www.crockford.com/javascript/inheritance.html
  • texte de Manuel Kiessling en 2012 : http://manuel.kiessling.net/2012/03/23/object-orientation-and-inheritance-in-javascript-a-comprehensive-explanation/
• Faire des objets dont on peut hériter, sans utiliser d'objets : http://skilldrick.co.uk/2011/08/making-inheritable-objects-in-javascript-without-objects/
• JavaScript et la la réflexivité : http://www.codeproject.com/KB/cs/JavaScript_Reflection.aspx
• Approche OO en JavaScript et performances : http://zef.me/2913/javascript-oop-style-performance
• Rédiger du code facile à tester : http://www.adequatelygood.com/2010/7/Writing-Testable-JavaScript
• JavaScript et l'encapsulation : http://www.jonathan-jackson.net/encapsulation-in-javascript
• Comprendre le volet OO de JavaScript : http://killdream.github.com/blog/2011/10/understanding-javascript-oop/
• En 2011, Quildreen Motta propose un texte détaillé sur l'approche OO en JavaScript : http://killdream.github.com/blog/2011/10/understanding-javascript-oop/index.html

Trucs et techniques

• JavaScript pour hackers : http://dev.opera.com/articles/view/opera-javascript-for-hackers-1/
• Utiliser JavaScript efficacement, intéressante présentation par Nicholas C. Zakas en 2013 : http://fr.slideshare.net/nzakas/enough-withthejavascriptalready
• http://www.bodo.com/javacool.htm
• http://home.earthlink.net/~mafriedman/jscript.html
• Une table triée :
  • http://friedcellcollective.net/js/SortedTable/
  • http://www.webtoolkit.info/sortable-html-table.html
• Des animations : http://jstween.blogspot.com/
• Du 3D : http://ctho.ath.cx/toys/3d.html
• Des graphiques : http://www.ejschart.com/
• Éviter qu'on bloque votre JavaScript pendant le chargement de votre page  : http://www.webdigi.co.uk/blog/2009/avoid-javascript-blocking-content-download-on-your-website-during-page-load/
• Éviter les erreurs bêtes : http://www.webdigi.co.uk/blog/2009/javascript-gotchas-listed-to-help-avoid-mistakes/
• Quelques techniques avancées : http://sixrevisions.com/javascript/6-advanced-javascript-techniques-you-should-know/
• comment ne pas écrire du JavaScript : http://www.sitepoint.com/blogs/2009/11/12/google-closure-how-not-to-write-javascript/
• Simuler les sauts de ligne de ^T_E^X en JavaScript : http://www.bramstein.com/projects/typeset/
• Amusant : http://www.flickr.com/photos/alikins/4439062727/in/photostream/
• Une simulation de textile : http://www.andrew-hoyer.com/experiments/cloth
• http://www.smashingmagazine.com/2010/04/20/seven-javascript-things-i-wish-i-knew-much-earlier-in-my-career/
• http://james.padolsey.com/javascript/partial-loop-unrolling/
• Un interpréteur Haskell en JavaScript : http://github.com/johang88/haskellinjavascript
• Visualiser dynamiquement les consultations de reddit : http://erqqvg.com/vizeddit/?v=2.0
• Un beau sapin de Noël en moins d'un Ko : http://www.romancortes.com/blog/how-i-did-the-1kb-christmas-tree/
• Conversion de binaires LLVM à JavaScript : ../Divers--cplusplus/outils-compilateurs.html#emscripten
• Triangles tridimensionnels : http://www.uselesspickles.com/triangles/
• À propos des points-virgules, ou « ; », en JavaScript :
  • le « ; » infernal, par Brendan Eich en 2012 : http://brendaneich.com/2012/04/the-infernal-semicolon/
  • gérer l'insertion automatique de « ; » : http://lucumr.pocoo.org/2011/2/6/automatic-semicolon-insertion/
  • une sorte de satire destinée à celles et ceux qui n'aiment pas les « ; », par Ben Alman en 2013 : http://benalman.com/news/2013/01/advice-javascript-semicolon-haters/
• Planifier des tests en JavaScript puis tricher : http://msdn.microsoft.com/en-us/scriptjunkie/gg649850.aspx
• Un langage très simple traité par du JavaScript en quelques expressions à peine : http://artemsmirnov.blogspot.com/2011/03/stack-programming-language-on.html
• Opérateurs en JavaScript :
  • https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
  • l'opérateur , plus précisément : http://javascriptweblog.wordpress.com/2011/04/04/the-javascript-comma-operator/
• http://www.smashingmagazine.com/2011/05/30/10-oddities-and-secrets-about-javascript/
• http://www.codeproject.com/KB/scripting/javascript-gotchas.aspx
• Accélérer le traitement de sources JavaScript : http://blog.mozilla.com/nnethercote/2011/07/01/faster-javascript-parsing/
• http://code.google.com/p/jslibs/wiki/JavascriptTips#language_advanced_Tips_&_Tricks
• Dériver d'objets natifs? http://perfectionkills.com/extending-built-in-native-objects-evil-or-not/
• Modifier les primitifs de JavaScript? Du pour et du contre, selon Angus Croll en 2011 : http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/
• Les objets « reportés », ou Deferred Objects, en JavaScript, par Rob Levin en 2011 : http://developtodesign.com/js/deferred-objects/
• Quelques bizarreries, pour les perverses et les pervers parmi vous : http://sla.ckers.org/forum/read.php?24,33349,33405
• Utiliser JavaScript peut très bien être simple et bref, de l'avis de Jonathan Snook en 2012 : http://snook.ca/archives/javascript/going-simple-with-javascript
• Le pervers Patricio Palladino propose, en 2012, une façon d'écrire du JavaScript qui ressemblerait à du brainfuck, donc avec une courte liste de symboles (les huits symboles suivants, en fait : ()[]{}!+) : http://patriciopalladino.com/blog/2012/08/09/non-alphanumeric-javascript.html
• Écrire du code JavaScript rapide et consommant peu de mémoire vive, selon Addy Osmani en 2012 : http://coding.smashingmagazine.com/2012/11/05/writing-fast-memory-efficient-javascript/
• Définir des propriétés avec JavaScript, par Rudy Jahchan en 2013 : http://blog.carbonfive.com/2013/02/12/sweeter-javascript-defining-properties-to-add-syntactic-sugar/
• Proposition pour ajouter des types dépendants au langage, par Ravi Chugh, David Herman et Ranjit Jhala en 2012 : http://cseweb.ucsd.edu/~rchugh/research/nested/djs.pdf
• Du tracé de rayons presque en temps réel avec JavaScript, par Stephan Boyer en 2013 : http://www.stephanboyer.com/post/30
• Rédiger des applications Web modernes, texte de Ariya Hidayat en 2013 : http://www.sencha.com/blog/toward-modern-web-apps-with-ecmascript-6/
• Des générateurs se rapprochant de ceux de Go, texte de 2013 : http://swannodette.github.io/2013/08/24/es6-generators-and-csp/
• Affectation déstructurante, expliquée par Nick Fitzgerald en 2013 : http://fitzgeraldnick.com/weblog/50/
• Programmer avec JavaScript de manière modulaire, proposition d'Andrew C. Oliver en 2014 : http://www.infoworld.com/d/application-development/code-in-javascript-the-smart-modular-way-238694

Critiques

• Une critique sévère de JavaScript, par Richard Stallman : http://www.gnu.org/philosophy/javascript-trap.html
• Les comparaisons booléennes en JavaScript : http://blog.codekills.net/archives/89-Equality-in-JavaScript.html
• Iuch! http://blog.jgc.org/2009/09/javascript-must-die.html
• Baveux mais drôle : http://i.imgur.com/zWMXc.jpg
• JavaScript partout. Est-ce une bonne idée? http://blog.ianbicking.org/2011/03/30/js-on-server-and-client-is-not-a-big-deal/
• http://ironjs.wordpress.com/2011/06/22/my-gripes-with-javascript/
• JavaScript est une abomination mais demeure incontournable, selon Bruce Eckel en 2011 : http://www.artima.com/weblogs/viewpost.jsp?thread=329840
• La cryptographie en JavaScript serait une mauvaise idée, selon la firme Matsano Security en 2011 : http://www.matasano.com/articles/javascript-cryptography/
• Le futur de JavaScript et le rôle de Dart, selon un mémo interne de Google en 2011 : http://pastebin.com/NUMTTrKj
• Le grand dilemme : améliorer JavaScripot ou le mettre à mort? Réflexion de Neil McAllister en 2011 : http://www.infoworld.com/d/application-development/the-great-javascript-debate-improve-it-or-kill-it-173674
• Certains, comme l'indique ce texte écrit en 2011, estiment qu'il manque certains services essentiels à ce langage : http://swizec.com/blog/javascripts-lack-of-strftime/swizec/3164
• Réflexion sur l'inefficacité de certains opérateurs numériques en JavaScript, par Maxime Chevalier en 2012 : http://pointersgonewild.wordpress.com/2012/04/02/inefficient-numerical-operators/
• Le Pew Pew Manifesto, par Bernd Paradies en 2012, qui proclame essentiellement que JavaScript est le langage d'assemblage du Web et que les applications de grande envergure devraient y être écrites dans d'autres langages puis compilées vers JavaScript : http://blogs.adobe.com/bparadie/2012/05/07/the-pew-pew-manifesto/
• En 2012, Alexei Boronine explique qu'à son avis, JavaScript demeure un langage déficient, mais que les problèmes de ce langage ne sont (selon lui) pas insolubles : http://boronine.com/2012/12/14/Why-JavaScript-Still-Sucks/
• Quelques pièges de JavaScript, colligés par James Fuller en 2013 : http://www.jblotus.com/2013/01/13/common-javascript-gotchas/
• Le Duck-Wrapping, une technique discutable, de l'avis d'Andrew Brehaut en 2013 : http://brehaut.net/blog/2013/duck_wrapping
• Texte de 2013 par Zak Rogoff pour la Free Software Foundation (FSF) réclamant que JavaScript devienne du logiciel libre : https://www.fsf.org/blogs/community/take-action-for-free-javascript
• La gestion un peu folle de la portée des variables en CoffeeScript et JavaScript, par Reginald Braithwaite en 2013 : http://raganwald.com/2013/07/27/Ive-always-been-mad.html
• Critique un peu humoristique de JavaScript et du développement Web en général, par James Mickens en 2014 : https://www.usenix.org/system/files/1403_02-08_mickens.pdf
• De l'avis de Julik Tarkhanov, en 2013, pour un langage qui se veut moderne, JavaScript est un peu merdique : http://live.julik.nl/2013/05/javascript-is-shit
• En 2013, Mathias Bynens explique que JavaScript a un gros problème avec Unicode : http://mathiasbynens.be/notes/javascript-unicode
• Série d'articles sur les problèmes de JavaScript, par Jeff Walker en 2014 :
  • le champ de mines qu'est JavaScript : http://www.walkercoderanger.com/blog/2014/02/javascript-minefield/
  • CoffeeScript n'est pas une solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/03/coffeescript-isnt-the-answer/
  • TypeScript n'est pas une solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/02/typescript-isnt-the-answer/
  • Dart n'est pas une solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/03/dart-isnt-the-answer/
  • l'auteur se questionne à savoir si les outils Lint sont la solution aux problèmes de JavaScript : http://www.walkercoderanger.com/blog/2014/04/are-javascript-linters-the-answer/
• L'« outil » tuplary, pour écrire du JavaScript vraiment difficile à lire... http://tuplary.com/
• JavaScript, les parties étranges... Texte de Charlie Harvey en 2014 : http://charlieharvey.org.uk/page/javascript_the_weird_parts

Exercices

EX00 – Insérez dans une page Web une procédure de validation assurant qu’un champ dans un formulaire soit bel et bien rempli avant envoi vers le serveur.

EX01 – Insérez dans une page Web une procédure de validation assurant que tous les champs d’un formulaire soient remplis avant envoi vers le serveur (truc : construisez un tableau des id des contrôles à valider avant d’invoquer la méthode de validation).

EX02 – Insérez dans une page Web une procédure remplaçant le texte de chaque zone de texte par son équivalent en minuscules avant validation.

EX03 – Insérez dans une page Web une procédure faisant en sorte que les données numériques d’un champ soient inclusivement situées entre 0 et 100.

EX04 – Insérez dans une page Web une procédure faisant en sorte que les champs devant obligatoirement être remplis soient identifiés par une couleur différente s’ils n’ont pas été remplis avant une tentative de soumission.

EX05 – Réalisez un exercice dans la liste allant de EX00 à EX04 inclusivement sur une page générée (au moins en partie) par un Servlet.