Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Angular et Node.js
  3. Le langage JavaScript
Extrait - Angular et Node.js Optimisez le développement de vos applications web avec une architecture MEAN (2e édition)
Extraits du livre
Angular et Node.js Optimisez le développement de vos applications web avec une architecture MEAN (2e édition) Revenir à la page d'achat du livre

Le langage JavaScript

Introduction à JavaScript

Dans ce chapitre, nous décrirons rapidement le langage JavaScript en supposant que vous maîtrisez au moins un langage informatique et les concepts de base (typage, variables, structures conditionnelles et itératives...) de la programmation.

1. Bref historique

JavaScript est un langage de programmation créé en 1995 par Brendan Eich qui travaillait pour la société Netscape. Le but originel du langage est de créer des scripts, c’est-à-dire des programmes interprétés, qui sont exécutés par un navigateur, principalement pour manipuler les données du DOM (Document Object Model), c’est-à-dire les objets (au sens informatique du terme) représentant les éléments du document balisé (par exemple, une page HTML) et alloués en mémoire du navigateur.

JavaScript a ensuite beaucoup évolué fonctionnellement (par exemple, en permettant l’accès asynchrone à des données fournies par le serveur) et a même récemment investi le « côté serveur » avec l’environnement Node.js.

Malgré son nom qui peut porter à confusion, JavaScript a très peu de liens avec le langage Java (seulement quelques structures syntaxiques qui proviennent en fait du langage C).

Le langage JavaScript se situe à la confluence...

Où coder du code JavaScript ?

Pour une utilisation côté client hors « bundlelisation » (nous verrons ultérieurement ce qu’est un bundle), les codes JavaScript doivent être externalisés dans des fichiers d’extension .js et liés aux codes HTML via la balise <script>, comme dans l’exemple ci-après.

Soit le script JavaScript nommé bonjour.js :

console.log("Bonjour !"); 

Et la page HTML test.html mettant en œuvre ce script :

<html> 
  <head> 
      <script src="bonjour.js" 
              type="text/javascript" language="javascript"> 
      </script> 
  </head> 
  <body> JavaScript vous dit bonjour dans la console </body> 
</html> 

Cet exemple de code est exécuté en étant chargé (ouvert) dans votre navigateur.

Les messages générés par la méthode log() de l’objet console sont affichés dans les consoles qui font partie des outils du navigateur (appuyez sur la touche [F12] pour les faire apparaître).

Si vous utilisez une ancienne version d’un navigateur, il est très important de ne pas utiliser une balise <script> autofermante.

Si vous créez des codes JavaScript avec un framework (par exemple...

Les outils du navigateur et le débogage

Les outils du navigateur (appuyez sur la touche [F12] pour en faire apparaître un certain nombre) vous permettent entre autres :

  • Grâce aux consoles, de visualiser les messages émis :

  • Par l’interpréteur JavaScript, notamment les erreurs de programmation (des liens cliquables vous permettent de vous positionner sur les lignes de code fautives).

  • Par vos codes (comme dans l’exemple précédent).

  • Grâce aux onglets nommés Éléments, HTML..., d’afficher la hiérarchie des balises de la page web.

  • Grâce aux onglets nommés Inspecteur DOM..., d’afficher la hiérarchie des objets alloués en mémoire du navigateur et correspondant à tous les documents chargés dans tous les onglets du navigateur.

Certains navigateurs proposent deux consoles :

  • La console web qui affiche les messages (émis par les scripts JavaScript ou relatifs aux chargements des ressources induites) concernant la ressource chargée dans l’onglet courant.

  • La console du navigateur qui affiche les messages issus des ressources chargées dans tous les onglets.

Les éléments de programmation de base

La syntaxe « de base » de la programmation en JavaScript est celle du langage C, elle-même reprise par le langage Java, mais cette syntaxe est dorénavant standardisée par ECMAScript, qui définit un ensemble de normes de programmation.

1. Les variables

Les variables sont typées dynamiquement (et non pas lors de leurs déclarations). Elles sont déclarées par :

  • Le mot réservé var : la portée de la variable est alors la fonction dans laquelle la variable apparaît (mais pas les fonctions incluses) : depuis la création du mot réservé let, ce typage est fortement déconseillé.

  • Le mot réservé let : la portée de la variable est assujettie au bloc d’instructions.

  • Le mot réservé const : la variable n’est accessible qu’en lecture.

a. Les types internes

JavaScript type (en interne) les variables suivant six types primitifs :

  • Un type booléen : true et false.

  • Un type nul : null.

  • Un type indéfini (en résultat de l’accès à une variable qui n’existe pas ou qui n’a pas de valeur) : undefined.

  • Exemple de variable créée, mais de valeur indéfinie : var i.

  • Un type pour les nombres qu’ils soient entiers ou réels : number.

  • Un type pour les chaînes de caractères : string.

    Les chaînes de caractères peuvent être circonscrites par des simples quotes ou des doubles quotes ; nous prendrons le parti dans nos exemples de généralement les encadrer par des doubles quotes.

  • Un type pour les symboles (ce type est introduit par ECMAScript 6 et ne sera pas développé ici).

Et le type Object dans les autres cas de figure. JavaScript est donc bien un langage objet.

Voici quelques exemples de création de variables scalaires (en rangeant par simplicité dans cette catégorie les chaînes de caractères) :

var bizarre;  // sa valeur est : undefined 
var i = 0; 
let bool = true; 
const nom = "Pierre"; 

Le type d’une variable peut être testé par la fonction typeof().

b. Le transtypage

Différentes fonctions et opérateurs permettent de transtyper une valeur. Les plus utiles en JavaScript sont celles qui transforment une chaîne de caractères...

La programmation fonctionnelle en JavaScript

JavaScript se situe dans le paradigme de la programmation fonctionnelle : dans ce paradigme, les fonctions sont des éléments de premier plan du langage.

En JavaScript :

  • Une fonction peut être passée en paramètre à une fonction hôte. La fonction passée en paramètre est appelée une fonction de callback (ou fonction de rappel).

  • Une fonction (souvent appelée une factory) peut aussi retourner une fonction.

1. Une fonction passée en paramètre (fonction de callback)

L’utilisation des fonctions de callback (ou de rappel) est un élément essentiel du langage JavaScript. 

Passer une fonction en paramètre d’une fonction hôte permet généralement de définir le code :

  • qui doit être exécuté à la fin de l’exécution de la fonction (mais possiblement aussi en cours d’exécution de la fonction) ;

  • qui consomme les données produites par la fonction.

Utiliser des fonctions de callback est un schéma de programmation très fréquent en JavaScript lors de l’accès asynchrone à des données.

Au travers des deux méthodes forEach() et map() appliquées à des listes, nous donnons ci-après deux exemples de l’emploi des méthodes de callback.

a. Exemple avec la méthode...

La programmation objet avec JavaScript

1. Les principes de la programmation objet avec JavaScript

Quasiment tout est objet en JavaScript. Pour autant, ce langage ne gérait pas de classes (contrairement par exemple aux langages Java, C++ ou Python) avant sa normalisation par la norme ECMAScript 6 (en 2015, soit vingt ans après sa création). Nous allons nous appuyer sur cette évolution majeure pour présenter la programmation objet avec JavaScript en trois temps :

  • La gestion classique des objets, sans utilisation de classes pour les instancier.

  • L’introduction des classes et d’un héritage simplifié avec la norme ECMAScript 6.

  • L’utilisation d’extensions du langage JavaScript pour gérer des classes, notamment avec TypeScript (ce dernier point fera l’objet du chapitre suivant).

Dans leur gestion traditionnelle (sans classes), les objets peuvent être créés de deux façons :

  • Soit de manière littérale en utilisant les accolades.

  • Soit en utilisant une fonction constructrice et en appelant cette fonction via l’instruction new.

L’héritage étant assuré par des objets particuliers appelés prototypes : c’est l’héritage par délégation.

2. Les objets littéraux

JavaScript se distingue de nombreux langages de programmation par le fait que les objets peuvent être créés littéralement (et ne sont pas des instances de classes). La syntaxe qui permet de formater ces objets lorsque ceux-ci sont sérialisés est appelée JSON (JavaScript Object Notation). Cette syntaxe est devenue extrêmement populaire dans l’échange de données (au détriment de XML).

La gestion des classes en JavaScript a été introduite via la norme ECMAScript 6 et surtout par des extensions du langage JavaScript comme TypeScript ou Dart (voir la webographie).

Soit un objet topPhone défini comme suit :

let topPhone = { "type": "phone", "brand": "Peach", "name": 
"topPhone"}; 

En utilisant les accolades, l’objet créé hérite du « métaobjet » Object (ce point sera détaillé ultérieurement).

Une propriété d’un objet peut avoir n’importe quelle valeur :

  • Une valeur...

Les principaux apports de la norme ECMAScript 6

1. La norme ECMAScript

ECMAScript est un ensemble de normes de programmation recommandées pour les langages de script. Ces normes sont principalement appliquées par les interpréteurs JavaScript (ceux des navigateurs et par Node.js).

Ces recommandations étant très nombreuses, nous ne détaillerons que quelques-unes de celles définies en 2015 (norme ECMAScript 6), qui ont considérablement fait évoluer le langage et qui sont largement diffusées depuis :

  • le mot réservé let ;

  • l’interpolation des variables dans les chaînes de caractères ;

  • les paramètres par défaut ;

  • la manipulation plus confortable des listes avec :

  • la structure itérative for (... of ...)... ;

  • la méthode includes() pour tester la présence d’un élément ;

  • l’utilisation des fat arrows pour simplifier l’écriture des fonctions de callback ;

  • les classes.

2. Le mot réservé let

Le mot réservé let limite la portée de la variable qu’il introduit au bloc d’instructions courant.

Il est, par exemple, systématiquement utilisé pour les variables locales aux structures itératives :

for (let <variable> in ...) { ... } 
for (let <variable> of ...) { ... } 

Il est possible que vous soyez tenu d’utiliser...

La programmation réactive, les observables et les promises

Les observables sont les éléments clés de la programmation réactive.

Un observable est n’importe quelle entité d’un programme qui peut produire un flux d’événements capturables au cours du temps : cela peut être un contrôle de l’interface qui est activé (par exemple, un bouton qui est cliqué) ou une variable qui va changer de valeur (dans ce cas, les événements sont associés à des valeurs signifiantes). Le but de la programmation réactive est de pouvoir associer de manière asynchrone un traitement aux valeurs émises par l’observable (le traitement est associé à l’observable via un abonnement). Plus particulièrement, une fonction pourra être exécutée pour chaque valeur reçue, une autre en cas d’erreur, et enfin une dernière en cas de fin explicite du flux (les deux dernières fonctions pouvant être occultées). Ces fonctions sont les observateurs (observers) bien connus du patron de conception « observateur ».

Ce paradigme est mis en œuvre en JavaScript via la bibliothèque RxJS (et à l’heure de la rédaction de cet ouvrage, en cours de normalisation sous ECMAScript). 

La bibliothèque RxJS peut être utilisée comme module de Node.js ou comme un fichier à lier à un code HTML.

Pour l’utiliser dans l’écosystème de Node.js (voir le chapitre La plateforme Node.js) en gardant une compatibilité avec des codes JavaScript antérieurs, il faut installer avec le gestionnaire de modules npm les deux modules rxjs et rxjs-compat (l’option save permettant de spécifier ces installations dans le fichier package.json dont l’utilité sera vue plus loin dans cet ouvrage) :

npm install rxjs --save 
npm install rxjs-compat --save 

Pour l’utiliser directement dans un code HTML, il faut également utiliser npm avec la commande npm install -g rx-lite, puis recopier le fichier rx.lite.min.js dans le répertoire où est localisé le code HTML.

Voici la création d’un observable...