Introduction au JavaScript : Au-delà du langage interprété

Introduction

Vous êtes surement tombé sur une définition de JavaScipt similaire a celle ci: JavaScript est un langage haut niveau, interprété, dynamique et le seul langage de programmation nativement compris par les navigateur ce qui en fait un élément fondamental du développement web moderne.

Cependant, cette définition est aujourd’hui incomplète. Les moteurs JavaScript modernes, comme V8 (Chrome), SpiderMonkey (Firefox), utilisent des techniques bien plus avancées que les interpréteurs basique pour améliorer les performances.

Donc en réalité, c’est quoi JavaScript ?

JavaScript est un langage de programmation de haut niveau, dynamique, multi-paradigme et principalement mono-thread. Il est exécuté par des moteurs spécialisés qui combinent interprétation et compilation JIT afin d’obtenir de bonnes performances tout en conservant la flexibilité du langage.

Autrement dit, JavaScript n’est plus simplement un langage interprété : il est aujourd’hui exécuté grâce à une combinaison intelligente d’interprétation et de compilation.

A noter que JavaScript n’est plus le seul language de programmation natif des navigateur,

JIT (Just In Time Compilation)

On a souvent entendu dire que JavaScript est un langage interprété. Historiquement, cette affirmation était correcte. Mais avant de comprendre le fonctionnement du JIT, il faut distinguer interpréteur et compilateur.

Interpréteur

Un interpréteur lit le programme et exécute les instructions au fur et à mesure.

Pour mieux visualiser ce processus, prenons l’exemple suivant :

let sum = 0;

for (let i = 0; i < 10; i++) {
  sum = sum + i;
}

Un interpréteur pur pourrait exécuter le programme de manière conceptuelle comme suit :

Ligne 1 : créer la variable sum = 0

Ligne 2 : créer la variable i = 0
          vérifier i < 10 → vrai

Ligne 3 : calculer sum + i
          stocker le résultat dans sum

Ligne 2 : i++
          vérifier i < 10 → vrai

Ligne 3 : calculer sum + i
          stocker le résultat dans sum

...

À chaque itération, les mêmes instructions doivent être relues et réanalysées avant d’être exécutées.

L’avantage est un démarrage rapide de l’exécution. En revanche, lorsque certaines portions du code sont exécutées des milliers ou des millions de fois, cette approche devient moins efficace.

Compilateur

Un compilateur adopte une approche différente.

Avant l’exécution, il analyse l’ensemble du programme puis le transforme dans une représentation plus proche de la machine.

Le processus est généralement :

Code source
      ↓
Analyse
      ↓
Compilation
      ↓
Code machine
      ↓
Exécution

L’avantage principal est la performance : le programme compilé s’exécute généralement beaucoup plus vite et les erreur sont detecter avant l’execution du programme.

L’inconvénient est qu’il faut attendre la fin de la compilation avant de commencer l’exécution.

JIT

Le JIT (Just In Time Compilation) combine les avantages des deux approches.

Lorsqu’un programme JavaScript démarre :

1. Le moteur lit rapidement le code.
2. Il génère du bytecode exécutable.
3. Le programme commence immédiatement à s’exécuter.
4. Le moteur observe quelles parties du code sont utilisées fréquemment.
5. Les portions les plus exécutées (“hot code”) sont compilées en code machine optimisé le reste n’est pas optimiser.

Le processus peut être résumé ainsi :

Code JavaScript
        ↓
Parsing
        ↓
Bytecode
        ↓
Exécution
        ↓
Détection du code fréquent
        ↓
Compilation JIT
        ↓
Code machine optimisé

Cette stratégie permet d’obtenir un démarrage rapide tout en bénéficiant de performances proches des langages compilés.

Pour clarifier voyons ces deux examples:

console.log("test");
for (let i = 0; i < 10; i++) {
  console.log(test);
}

En executant ce code vous allez remarquer qui ca donne:

Si JavaScript été completement compilé, l’erreur aurait été afficher au tout debut de l’execution pas après le premier console.log.

const sum = 0;
for (let i = O; i < 10; i++) {
  sum = sum + i;
}

La boucle for est execute plusieur fois, le JIT va la considerer comme Hot code et generer son code machine.

Types dynamiques

JavaScript est un langage à typage dynamique.

Le type d’une variable est déterminé au moment de l’exécution et peut changer au cours du programme.

let value = 42; // Number

value = "Bonjour"; // String

value = true; // Boolean

Contrairement aux langages à typage statique comme Java ou C++, il n’est pas nécessaire de déclarer explicitement le type d’une variable.

Multi-paradigme

JavaScript supporte plusieurs styles de programmation.

Programmation procédurale

function add(a, b) {
  return a + b;
}

Programmation orientée objet

class User {
  constructor(name) {
    this.name = name;
  }
}

Programmation fonctionnelle

const numbers = [1, 2, 3];

const doubled = numbers.map((n) => n * 2);

Cette flexibilité permet aux développeurs de choisir le paradigme le plus adapté au problème à résoudre.

Unique Thread

JavaScript est principalement mono-thread.

Cela signifie qu’une seule instruction JavaScript est exécutée à la fois.

console.log("A");
console.log("B");
console.log("C");

La sortie sera toujours :

A
B
C

Pour gérer les opérations longues sans bloquer l’application, JavaScript s’appuie sur L’Event Loop, les Web APIs du navigateur et les mécanismes asynchrones tels que :

• Callbacks
• Promises
• async/await

Garbage Collected

JavaScript dispose d’un ramasse-miettes (Garbage Collector).

Lorsqu’un objet n’est plus accessible par le programme, la mémoire qu’il occupe peut être automatiquement libérée.

let user = {
  name: "Alice",
};

// pas besoin de le faire manuellement, JavaScript le fait automatiquement quant une variables n'est plus utiliser
user = null;

Après cette affectation, l’objet original n’est plus référencé et pourra être supprimé par le Garbage Collector.

Cette gestion automatique de la mémoire simplifie considérablement le développement par rapport à des langages nécessitant une libération manuelle.

Récap en carte mentale

Histoire de JavaScript

JavaScript a été créé en 1995 par Brendan Eich chez Netscape.

Le langage a été développé en seulement dix jours afin d’ajouter de l’interactivité aux pages web, qui étaient jusque-là essentiellement statiques.

Au fil des années, JavaScript a évolué grâce à la standardisation ECMAScript :

• 1995 : création de JavaScript par Brendan Eich, en 10 jours, nomme Motcha puis LiveScript et finalement JavaScript pour des raison marketting car Java été trend a cette époque
• 1997 : première standardisation ECMAScript
• 2009 : ES5
• 2015 : ES6 (ECMAScript 2015)
• Aujourd’hui : nouvelles versions publiées régulièrement (en general chaque année)

Initialement limité au navigateur, JavaScript est désormais utilisé côté serveur grâce à Node.js, ainsi que pour le développement mobile, desktop et même l’Internet des objets.

Conclusion

JavaScript est souvent décrit comme un langage interprété, mais cette définition ne reflète plus complètement la réalité actuelle. Les moteurs modernes utilisent des techniques sophistiquées combinant interprétation et compilation JIT afin d’offrir un excellent compromis entre rapidité de démarrage et performances d’exécution.

Grâce à son typage dynamique, son support de plusieurs paradigmes, son modèle d’exécution basé sur un thread principal et sa gestion automatique de la mémoire, JavaScript est devenu bien plus qu’un simple langage pour animer des pages web : il constitue aujourd’hui l’un des écosystèmes de développement les plus importants au monde.

Ce blog est le premier d’une serie dont on va decomposer chaque concept de JavaScript, Le prochain blog va attaquer les variable est type en profondeur.