dans Programmation 101
10 secrets sur JavaScript
Ah! JavaScript… Nous avons tous vu, au début des années 2000, ce à quoi JS servait : faire des animations! Certains se souviendront, notamment, des textes « néons » et autres absurdités qui se faisaient jadis.
Heureusement, notre perception du langage a évolué et nous utilisons maintenant JS comme un véritable langage de programmation impératif. Aujourd’hui, je vous présente 10 secrets sur JavaScript qui en font le langage qu’il est.
1 – Node.js n’a rien inventé
Le 4 décembre 1995 (~23 ans), JS voit le jour chez Netscape. Quelques jours plus tard, toujours en décembre 1995, Netscape développe un langage script côté serveur qu’on nommera Server-Side JavaScript (SSJS). En 1996, Microsoft lance un module IIS pour JScript, sa copie du JavaScript. Il faudra attendre à 2009 pour que node voit le jour, soit pratiquement 15 ans.
2 – Le langage s’appellait initialement LiveScript
Lors de la première intégration du langage au navigateur Netscape Navigator (ouch… les souvenirs!), le nom de code était Mocha, puis a été renommé LiveScript en septembre 1995. Finalement, le nom JavaScript a été adopté le 3 décembre 1995.
3 – JS ne possède aucune abstraction
Pas de classe abstraite, pas d’interface. Difficile de se conformer aux principes SOLID…
4 – JS n’a aucun concept privé/public/protégé
Il est impossible d’avoir des membres privés sur nos objets. Tous les membres sont exposés publiquement.
5 – JavaScript fait 2 passes d’analyse du code
Prenons l’exemple suivant :
|
1 2 3 4 5 6 7 |
log(test); var test; function log(what) { console.log(what); } |
Ce code produit undefined dans la console au lieu de ReferenceError: test is not defined. JavaScript analyse le code une première fois pour charger les fonctions et les variables déclarées en utilisant var. Ceci fait en sorte que la variable test et la fonction log existent avant d’être déclarées.
6 – Il existe plus qu’un types de portée (scope) pour les variables
Comme vu au point 5, les variables créées avec var existent avant d’être déclarées physiquement dans le code. Ceci est dû au fait que var crée la variable lors de la première passe d’analyse du code, ce qu’on appelle function-scoped. Au contraire, const et let produisent des variables traditionnelles qui existent au niveau du bloc d’instructions, soit bloc-scoped.
|
6 |
var var1; // function-scoped, existe partout dans la fonction courante |
Ce code produit 1 en sortie.
|
6 |
let var1; // bloc-scoped, existe à partir d'ici |
Ce code produit ReferenceError: test is not defined.
7 – Le mot clé this n’est pas l’instance de l’objet courant
En JS, this fait référence au contexte de l’appelant et non à l’instance de l’objet courant. Par exemple :
|
1 2 3 4 5 6 7 8 |
var myObject = { test: function () { console.log(this); // this = setTimeout } } setTimeout(myObject.test, 0); // Délégation // ^---- Context de appellant |
Ici, this est égal à setTimeout. Par contre :
|
1 2 3 4 5 6 7 8 |
var myObject = { test: function () { console.log(this); // this = myObject } } setTimeout(function () { myObject.test(); }, 0); // Délégation // ^---- Context de appellant |
Ici, this est égal à l’instance de l’objet en cours, soit myObject. Pour changer this, on peut faire :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
var myThis = { isThis: true }; var myObject = { test: function () { console.log(this); // this = myThis } } setTimeout(function () { myObject.test.call(myThis); // ^---- Context de appellant }, 0); |
Dans ce dernier exemple, this devient un autre objet…
8 – Même si c’est impossible, on peut avoir des variables privées-ish
Grâce au module pattern propre à JS, il est possible d’utiliser les portées de variable (scope) pour émuler le concept de membres privés :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
var myObject = (function () { // function-scoped, n'existent qu'à // l'intérieur de cette fonction. var privateVariable = 'Hello World'; function privateMember() { console.log(privateVariable); } function publicMember() { privateMember(); } return { publicMember: publicMember // Exposition publique }; })(); myObject.publicMember(); myObject.privateMember(); // Boom |
9 – C’est possible d’avoir du polymorphisme sur les prototypes
Étant un langage basé sur les prototypes, soit une sous-classes de l’orienté-objet, il est possible pour nos objets d’avoir plusieurs types en clonant les prototypes :
|
1 2 3 4 5 6 7 |
function A() {} function B() {} B.prototype = Object.create(A.prototype); console.log(new B() instanceof Object); // Affiche true console.log(new B() instanceof A); // Affiche true console.log(new B() instanceof B); // Affiche true |
10 – C’est possible de hacker JavaScript
Le terme est peut-être un peu fort, mais c’est possible de modifier le code natif de JavaScript pour le remplacer par le nôtre. Par exemple :
|
1 2 3 4 5 6 7 8 9 10 |
function hackConsole() { var delegate = console.log; // Garder la ref console.log = function (what) { delegate(new Date() + ' ' + what); } } hackConsole(); console.log('Hello world'); // Affiche la date + Hello world |
Vous pourriez, par exemple, désactiver tous les console.log en production en écrasant la méthode avec une fonction qui ne fait rien 😉
Conslusion
Vous avez appris aujourd’hui, je l’espère, 10 petits secrets sur JavaScript. Pour poursuivre votre apprentissage, je vous invite à consulter la documentation officielle de JS. Faites-en votre bible 🙂
Je vous invite aussi lire ou relire cet article qui traite de TypeScript, un langage qui se transpile en JavaScript. De plus, si vous vous sentez généreux, vous pouvez me payer une bière pour m’encourager à produire du contenu gratuit et sans publicité pour vous, merveilleuse communauté de développeurs francophones.
Merci de partager avec vos amis et collègues sur les réseaux sociaux!
Commentaires
Laisser un commentaire