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...)
- readyState: status quand executée la fonction
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
- Lire le code source de votre framework favori
- JavaScript Éloquent
- Ré-apprendre JavaScript (FR)
- Wiki JavaScript (FR)
- Bien démarrer avec JavaScript (FR) : Principes de bases
- Speaking JavaScript (EN) : Livre complet sur le JavaScript
- Asynchrone FR
- Promesses en JS (FR)
- W3Schools (EN)
- Closures (FR)