JavaScript

Introduction

Définition

Langage de scripts (càd langage de programmation interprété). Un script est envoyé au navigateur (par un serveur web) et est exécuté côté client.

JavaScript empreinte quelques particuliarités des autres languages informatiques: Java (syntax, primitive values versus objects), Scheme and AWK (first-class functions), Self (prototypal inheritance), and Perl and Python (strings, arrays, and regular expressions). C'est un mix entre un langage fonctionnel (higher-order functions; built-in map, reduce, etc.) et orienté objet (objets, héritage).

Historique

Naissance de JavaScript

  • Mai 1995 : Brendan Eich développe pour Netscape Communications Corporation, un langage de script, appelé Mocha, puis LiveScript et finalement JavaScript.
  • Mars 1996 : Netscape met en œuvre le moteur JavaScript dans son navigateur Web Netscape Navigator 2.0.

Guerre des navigateurs

  • Août 1996 : Microsoft développe leur propre variante de JavaScript, JScript, qu'il inclut dans Internet Explorer 3.0. JScript possède des fonctionnalités supplémentaires et incompatibles, notamment dans la manipulation du DOM (Document Object Model).

Standardisation EMACScript

  • novembre 1996 : Netscape soumet alors JavaScript à Ecma International pour standardisation.
  • juin 1997 : 1ère édition du standard ECMA-262 qui spécifie le langage ECMAScript.

Moteur V8

  • 2009 : Ryan Dahl exploite le moteur V8 de Google pour le faire tourner côté serveur (NodeJS). Il y ajoute quelques API, notamment une API d'entrée/sortie non bloquantes et des modules.

Principales utilisations

  • interagir avec un document HTML (en particulier le modifier) en utilisant le DOM (Document Object Model)
  • limiter les échanges entre client et serveur web :
    • contrôle des données d’un formulaire avant transmission à un serveur (moins vrai depuis HTML5)
    • envoi de requêtes http sans rechargement de la page: AJAX

Types

Liste des types JavaScript :

  • Number
  • String
  • Boolean
  • Symbol (depuis ES6)
  • Object
    • Function
    • Array
    • Date
    • RegExp
  • null
  • undefined

Number


Fonctions

Les fonctions et variables sont hoisted, c'est-à-dire qu'elles peuvent être appelées avant leurs déclarations. JS remonte automatiquement les déclarations au tout début du contexte.

Ces arguments peuvent être disponibles via la variable spéciale arguments. C'est un array mais sans les méthodes (slice, split...).

> function f() { return arguments }
> var args = f('a', 'b', 'c');
> args.length
3
> args[0]  // read element at index 0
'a'

IIFE: Immediately-invoked Function Expression. Ce sont des fonctions qui s’exécutent immédiatement, et dans un contexte privé.

(function () {
  function Test() { }
  return Test;
}());

Call

La méthode call() est une fonction JavaScript prédéfinie.

Elle peut appelée son propre objet comme premier argument (paramètre).

Avec call(), tu peut utiliser une méthode appartenant à un autre objet (avant ES6 elle servait pour créer un héritage) :

function Vehicule(couleur, nombreRoueMotrice) {
  this.couleur = couleur;
  this.nombreRoueMotrice = nombreRoueMotrice;
  this.moteurAllumer = false;
}

// Une voiture est un véhicule.
function Voiture(couleur, nombreRoueMotrice, nombrePlaceAssise) {
  Vehicule.call(this, couleur, nombreRoueMotrice);
  this.nombrePlaceAssise = nombrePlaceAssise;
}
Voiture.prototype = Object.create(Vehicule.prototype);

arguments

Permet de récupèrer le tableau des paramètres passé dans la fonction. Cela peut servir quand le nombre de paramètres est variable :

function somme(){
  var resultat = 0;
  for (var i = 0; i < arguments.length; i++) {
    resultat += arguments[i];
  }
 return resultat;
}

Depuis ES6, on peut utiliser le rest operator : ...


This et scope

Définition

Le scope est ce qu'on appelle en français le contexte ou la portée, c'est-à-dire la visibilité accordée à une variable. Le scope porte également le contexte dans lequel les instructions vont s'exécuter.

Scope global

Si une déclaration est globale, sa valeur sera accessible partout. Pour le navigateur, le scope global est l'objet window.

Les variables globales ne sont pas immutable, c'est-à-dire peuvent changer de valeur pendant l’exécution du programme. Il est donc recommandé de définir ses variables et ses fonctions dans des scopes locaux.

Scope local

Si une déclaration est locale, sa valeur sera accessible que dans sa fonction. Cela permet d'éviter les effets de bord ce qui limitera les bugs. Quelques patterns viennent à votre rescousse, comme la fonction anonyme auto-appelante (IIFE, Immediately-Invoked Function Expression), comme par exemple :

var noSideEffect = "Hello World!";

function runInGlobalScope() {
  console.log(noSideEffect);
}
(function() {
  var noSideEffect = "Farewell and good night!";

  function runInLocalScope() {
    console.log(noSideEffect);
  }

  runInLocalScope(); //Farewell and good night!
  runInGlobalScope(); //Hello World!
})();

This

Dans de nombreux langages, this est un pointeur vers l'objet courant. C'est un peu différent en JavaScript, this est un pointeur vers le contexte qui exécute les instructions :

  • l'objet window s'il est utilisé dans un contexte de scope global.
  • l'objet portant la fonction qui est appelée, correspondant donc à un scope local.

Asynchrone : callback / promesse

Single thread

Les bons côtés :

  • jamais d’accès concurrents aux données.
  • debuggage nettement simplifié.

Les mauvais côtés :

  • votre application peut être bloquée avec du code un peu trop gourmand.
  • setTimeout et setInterval ont une précision approximative.

Timers

On se donnerait presque l’impression qu’on créé des threads et pourtant … En réalité il ne faut pas voir les timers comme des fonctions asynchrones mais plutôt comme des gestionnaires de queue.

"Dès que tu es dispo après n millisecondes, exécute cette fonction”.

Callback

Pour contrer le fonctionnemnt asynchrome de JavaScript, on utilise des callbacks afin d'attendre le retour d'une valeur pour exécuter une autre fonction.

JavaScript est un langage fonctionnel, c'est à dire que les fonctions sont des valeurs comme les autres. Un callback est l'utilisation d'une fonction comme paramètre d'une autre fonction.

getUser(login, function (user) {
  getRights(user, function (rights) {
  updateMenu(rights);
  });
});

Promesses

Introduite depuis ES6.

Objectifs

  • Simplifier la programmation asynchrone
  • Ne plus se perdre dans les callbacks imbriqués
  • Pouvoir faire des traitements asynchrones de manière simultanée tout en récupérant les résultats une seule fois simplement

Création :

let recupererUtilisateur = function(idUtilisateur) {
  return new Promise(function(resolve, reject) {
    let utilisateur = response.data.utilisateur;
      if(response.status === 200) {
        resolve(utilisateur);
    } else {
        reject('Cet utilisateur n\'existe pas.');
    }
  })
}

Utilisation :

recupereUtilisateur(idUtilisateur)
  .then(function(utilisateur) {
    recupererAmis(utilisateur);
    })
  .then(function(amis) {
    afficherListe(amis);
  });

Une promise a trois états :

  • pending ("en cours") : quand la promise n’est pas réalisée, par exemple quand l’appel serveur n’est pas encore terminé.
  • fulfilled ("réalisée") : quand la promise s’est réalisée avec succès, par exemple quand l’appel HTTP serveur a retourné un status 200-OK.
  • rejected ("rejetée") : quand la promise a échoué, par exemple si l’appel HTTP serveur a retourné un status 404-NotFound.

Quand la promesse est réalisée (fulfilled), alors le callback de succès est invoqué, avec le résultat en argument. Si la promesse est rejetée (rejected), alors le callback d’erreur est invoqué, avec la valeur rejetée ou une erreur en argument.


Évènements

Un évènement HTML peut être une action du navigateur ou de l'utilisateur.

JavaScript permet d'executer un code quand l'évènement est détecté.

Liste des évènements les plus communs :

Event Description
onchange An HTML element has been changed
onclick The user clicks an HTML element
onmouseover The user moves the mouse over an HTML element
onmouseout L'utilisateur bouge la souris hors d'un élément HTML
onkeydown L'utilisateur presse sur une touche du clavier
onload Le navigateur a fini de charger la page

Liste plus complète des évènements


AJAX

AJAX (Asynchronous JavaScript and XML.) permet de charger des parties d'une page web sans recharger toute la page. Uniquement le client peut envoyer une requête au serveur, contrairement aux websokets où le serveur peut également envoyer une requête au client.

Pour cela, il faut utiliser l'objet XMLHttpRequest qui permet ce transfert de données sans rechargement de la page. Tous les navigateurs modernes le supportent.

var http = new XMLHttpRequest();

Pour envoyer des données au serveur, on utilise 2 méthodes, open() et send().

Méthode Open

http.open("GET", "ajax_info.txt", true); // open(méthode, url, asynchrone)
  • méthode (string): la méthode utilisée (GET/POST)
  • url (string): l'url d'un fichier sur le serveur. Le fichier peut être de n'importe quel format (.txt, .json, .asp, .php...).
  • asynchrone (booléen): doit être défini à true pour que la requête se comporte comme du AJAX

Méthode Send

http.send(); // method GET
http.send("string"); // method POST

Event onreadystatechange

Définit la fonction executée quand la requête est finie

http.onreadystatechange = function() {
  if (http.readyState == 4 && http.status == 200) {
    document.getElementById("demo").innerHTML = http.responseText;
  }
};
  • onreadystatechange (function):
    • readyState: status quand executée la fonction
      • 0: request not initialized
      • 1: server connection established
      • 2: request received
      • 3: processing request
      • 4: request finished and response is ready
    • status: status de la requête (200, 404, 503...)

Entêtes de la requête

http.setRequestHeader("Content-type", "application/json; charset=utf-8"); // (header, value)

Exemple

var http = new XMLHttpRequest();
http.onreadystatechange = function() {
  if (http.readyState == 4 && http.status == 200) {
    document.getElementById("demo").innerHTML = http.responseText;
  }
};
http.open("GET", "ajax_info.txt", true);
http.send();

Exceptions

Introduction

JavaScript ne possèdait pas de gestion des exceptions avant ECS3, ce qui explique pourquoi le langage souvent execute des erreurs silencieusement.

Objectifs

  • arrêter une execution quand une erreur survient
  • aide le développeur sur la nature de l'erreur

throw

if (somethingBadHappened) {
    throw new Error('Something bad happened');
}

try-catch-finally

try {
  // essaye l'opération
}
catch (e) {
  switch (e.constructor) {
    case SyntaxError:
        ...
        break;
    case CustomError:
        ...
        break;
  }
}
finally {
  // code toujours executé, utilisé pour nettoyer l'opération
}

Promesses

Objectifs

  • Ne plus se perdre dans les callbacks imbriqués
  • Pouvoir faire des traitements asynchrones de manière simultanée tout en récupérant les résultats une seule fois simplement

Exemple :

recupereUtilisateur(idUtilisateur)
  .then(function(utilisateur) {
    recupererAmis(utilisateur);
    })
  .then(function(amis) {
    afficherListe(amis);
  });

Class

Définition

Introduites avec ES6 (ES2015), les class fournissent uniquement une syntaxe plus simple et plus claire pour créer des objets et manipuler l'héritage, par rapport à l'héritage prototypal. En réalité, les classes sont juste des fonctions spéciales. Ainsi, les classes sont définies de la même façon que les fonctions : par déclaration, ou par expression.

Déclaration

class Rectangle {
  constructor(hauteur, largeur) {
    this.hauteur = hauteur;
    this.largeur = largeur;
  }
}

var p = new Rectangle();

Types de class

  • Buffer : c'est un tampon, permet de lire/écrire des contenus dans le tampon de mémoire.

Héritage

Depuis ES6, on peut utiliser le mot clé extends en JavaScript, et le mot-clé super, pour rattacher le tout à la "superclasse", ou "classe-mère" si vous préférez. Avant il fallait appeler la méthode call pour héritez du constructeur.

class Vehicule {
  constructor(couleur, nombreRoueMotrice, moteurAllumer = false) {
    this.couleur = couleur;
    this.nombreRoueMotrice = nombreRoueMotrice;
    this.moteurAllumer = moteurAllumer;
  }

  demarrer() {
    this.moteurAllumer = true;
  }
}

class Voiture extends Vehicule {
  constructor(couleur, nombreRoueMotrice, moteurAllumer = false, nombrePlaceAssise) {
   super(couleur, nombreRoueMotrice, moteurAllumer);
   this.nombrePlaceAssise = nombrePlaceAssise;
  }
}

Pièges à éviter

Return

return; // returns undefined

// code block that does nothing
{ 
  'ok': false
}

Les fuites de mémoire

JavaScript est un langage haut niveau, elle possède un ramasse-miette pour recycler la mémoire inutilisé. Cependant c'est un langage non-typé des faux-positifs peuvent rester, ainsi que des erreurs créées par les développeurs.

  • utiliser use strict; pour éviter de déclarer des variables globales par accident (sans le var devant).
  • attention à ne pas oublier des setInterval() plus utilisés.
  • enlever des eventListener quand ils ne sont plus utilisés element.removeEventListener('click', onClick);. Les navigateurs modernes les recycle quand même mais cela reste une bonne pratique.
  • quand on enlève un élément du DOM, il faut bien enlever toutes références (fonctions, var) à celui-ci.
  • si un objet utilise d'autres fonctions (closure), il faut être sûre que les variables locales ne pointent plus vers elles.

Mots-clés réservés

Il existe des mots-clés réservés. Ce sont des mots qui sont inutilisable comme noms de variables, de fonctions ou de méthodes, car JavaScript a une utilité spéciale pour eux.

Voici quelques exemples de mots-clés: if, else, new, var, for, class ou super.

Liste exhaustive des mots-clés réservés JavaScript (ES6 compris).


Libraries

Librarie date js : - luxon - moment


Sources