Informatique

JavaScript, le langage du Web

Écrit en dix jours en mai 1995 pour animer les pages d'un navigateur, JavaScript fait aujourd'hui tourner presque tous les sites du monde, des serveurs, des applications de bureau et de téléphone. Cinq planches pour comprendre ses bizarreries de jeunesse, ses nombres, ses événements, son fonctionnement asynchrone, et pour écrire vos propres programmes. Cette page est elle-même faite de HTML, de CSS et de JavaScript.

Du petit script au langage universel

En 1995, Netscape domine le marché des navigateurs et veut un langage simple pour rendre les pages interactives, à côté de Java, alors très à la mode. Brendan Eich en écrit le prototype en dix jours : il s'appelle d'abord Mocha, puis LiveScript, et prend en décembre 1995 le nom de JavaScript, pour profiter de la notoriété de Java, dont il est pourtant très différent. Microsoft répond avec JScript ; pour éviter que le Web se divise, le langage est normalisé en 1997 par l'organisme Ecma sous le nom d'ECMAScript. Après des années de stagnation, il renaît avec Ajax (2005), le moteur V8 de Google (2008) et Node.js (2009), puis évolue chaque année depuis 2015.

Les éditions de la norme ECMAScript. Après la troisième (1999), la quatrième est abandonnée en 2008 ; depuis ES2015, une nouvelle édition paraît chaque mois de juin. La dix-septième, ES2026, a été approuvée le 30 juin 2026.
Planche 1

Dix jours en mai : les types et leurs conversions

1995 – 1997

Pour ne pas effrayer les débutants, le premier JavaScript ne signale presque jamais d'erreur : si l'on compare un nombre et une chaîne de caractères, il convertit l'un des deux en silence. L'opérateur d'égalité == applique ainsi une cascade de règles, fixées par la norme. Le tableau ci-dessous est calculé par votre navigateur : chaque case indique si la valeur de la ligne est égale à celle de la colonne. Touchez une case pour voir les conversions effectuées, étape par étape. L'égalité stricte ===, ajoutée en 1999, ne convertit rien.

Vert : la comparaison vaut true. La case encadrée est celle dont l'explication est affichée.

Ce que fait le moteur


  

  

    
Cases vraies avec == / avec ===
—

    
L'égalité large n'est pas transitive
—

    
Contrôle : les règles écrites pas à pas reproduisent le == du navigateur
—

    
Contrôle : même tableau calculé par Node.js
—

  

  
Ce qu'il faut retenir. Les conversions automatiques de JavaScript produisent des résultats surprenants : "0" == 0 et 0 == "" sont vrais, mais "0" == "" est faux ; [] == false est vrai ; NaN n'est égal à rien, pas même à lui-même ; deux tableaux identiques ne sont pas égaux, car on compare leurs adresses. Ces choix, faits dans l'urgence de 1995, ne peuvent plus être corrigés : changer le langage casserait des millions de pages existantes. C'est la règle d'or du Web, « ne pas casser le Web ». La pratique moderne est simple : utiliser toujours ===. Le langage TypeScript (Microsoft, 2012) va plus loin en vérifiant les types avant l'exécution.







  
Planche 2
Un seul type de nombre : le double IEEE 754
1985 – 2020

  
Là où d'autres langages distinguent entiers et nombres à virgule, JavaScript n'a longtemps connu qu'un seul type, Number : un nombre à virgule flottante sur 64 bits, selon la norme IEEE 754 de 1985. Un bit donne le signe, onze bits l'exposant (la puissance de 2), cinquante-deux bits la mantisse (les chiffres). Comme la machine compte en base 2, la plupart des décimaux, tel 0,1, ne sont pas représentables exactement : le nombre réellement stocké est le double le plus proche. Choisissez une valeur et observez ses 64 bits.

  

    

    

  

  
En haut, les 64 bits : signe (rouge), exposant (bleu), mantisse (vert). En bas, la droite des nombres autour de la valeur : chaque trait est un double représentable ; entre deux traits voisins, aucun autre nombre n'existe pour la machine.

  

    
Écriture hexadécimale des 64 bits
—

    
Signe × mantisse × 2exposant
—

    
Valeur exacte réellement stockée
—

    
Écart avec le double suivant (ulp)
—

    
Contrôle : bits et valeur exacte calculés par Python
—

  

  
Ce qu'il faut retenir. 0.1 + 0.2 donne 0.30000000000000004 : les doubles stockés pour 0,1 et 0,2 sont un peu trop grands, et leur somme tombe sur le double voisin de celui de 0,3. Ce n'est pas une erreur de JavaScript, c'est le comportement de tous les langages qui utilisent IEEE 754. Les entiers sont exacts jusqu'à 2⁵³ = 9 007 199 254 740 992 ; au-delà, l'écart entre deux doubles dépasse 1, et 2 ** 53 + 1 retombe sur 2 ** 53. Pour les grands entiers exacts (cryptographie, identifiants), ES2020 a ajouté un second type numérique, BigInt, noté avec un n final : 2n ** 53n + 1n vaut bien 9 007 199 254 740 993. Pour l'argent, on compte en centimes entiers.







  
Planche 3
Le DOM et les événements : rendre la page vivante
1995 – 2000

  
Pour JavaScript, une page Web est un arbre d'objets, le DOM (Document Object Model) : chaque balise est un nœud que le programme peut lire, modifier, créer ou supprimer. Le programme réagit aux actions de l'utilisateur grâce aux événements : on « écoute » un clic sur un élément en lui confiant une fonction. Mais un clic sur un bouton est aussi un clic sur la boîte qui le contient, et sur la page entière. Netscape faisait descendre l'événement de la page vers le bouton (la capture), Internet Explorer le faisait remonter (le bouillonnement) ; la norme DOM du W3C (2000) a réuni les deux. Cliquez sur le bouton ou sur une boîte : ce sont de vrais écouteurs qui s'exécutent.

  

    
    
    
  

  

    

      
boîte A (div)
        
boîte B (div)
          
        

      

    

    
Le chemin de l'événement dans l'arbre du DOM : il descend de window jusqu'à la cible (capture, flèches bleues), puis remonte (bouillonnement, flèches rouges). Les écouteurs appelés s'allument dans l'ordre.

  

  

    
Élément cliqué (event.target)
—

    
Écouteurs appelés, dans l'ordre
—

    
Écouteurs installés / appelés
—

    
Contrôle : ordre prévu par la norme DOM
—

  

  
Ce qu'il faut retenir. Un événement parcourt l'arbre en trois phases : capture (de la racine vers la cible), cible, puis bouillonnement (de la cible vers la racine). Par défaut, addEventListener écoute le bouillonnement : c'est ce qui permet la délégation, où un seul écouteur posé sur une liste gère les clics de tous ses éléments, même ceux ajoutés plus tard. Manipuler le DOM d'un navigateur à l'autre a longtemps été un casse-tête ; la bibliothèque jQuery (2006) a aplani ces différences, avant que les navigateurs s'alignent sur les normes. Aujourd'hui, React (2013), Vue ou Svelte modifient le DOM pour nous, à partir d'une description de ce que la page doit afficher.







  
Planche 4
La boucle d'événements : un seul fil, beaucoup d'attentes
2009 – 2017

  
JavaScript n'exécute qu'une chose à la fois, sur un seul fil d'exécution. Pour ne jamais bloquer la page pendant qu'il attend une réponse du réseau ou un minuteur, il confie l'attente au navigateur, puis traite les résultats un par un grâce à la boucle d'événements : quand la pile d'appels est vide, elle exécute d'abord toutes les microtâches (suites de promesses, ES2015), puis la tâche suivante (minuteurs, clics, réponses réseau). Ryan Dahl a eu l'idée en 2009 d'appliquer ce modèle aux serveurs : c'est Node.js. Choisissez un programme et suivez-le pas à pas ; devinez l'ordre d'affichage avant de lancer.

  

    

    
    
    
  

  

    
Le programme

    
La pile d'appels, les deux files d'attente et la console. La ligne en cours est surlignée dans le programme.

  

  

    
Étape
—

    
Ce qui se passe
—

    
Contrôle : ordre obtenu en exécutant vraiment le programme, dans ce navigateur et dans Node.js
—

  

  
Ce qu'il faut retenir. Un setTimeout(…, 0) ne s'exécute pas « tout de suite » : il passe après tout le code synchrone et après toutes les microtâches. Les promesses (ES2015) et la syntaxe async / await (ES2017) ont remplacé les cascades de fonctions de rappel imbriquées : await suspend la fonction sans bloquer le reste du programme, et sa suite revient plus tard comme une microtâche. Ce modèle à un seul fil évite les erreurs de concurrence des programmes à plusieurs fils, mais un calcul trop long fige toute la page : pour les gros calculs, on utilise des Web Workers, qui tournent à part (le bac à sable de la planche 5 en est un).







  
Planche 5 · signature
À vous de programmer
2026

  
Voici un véritable environnement JavaScript : le code que vous écrivez est exécuté par le moteur de votre navigateur, le même qui fait tourner les sites que vous visitez (V8 dans Chrome et Edge, SpiderMonkey dans Firefox, JavaScriptCore dans Safari). Choisissez un exemple, lisez-le, modifiez-le, puis exécutez-le. console.log écrit dans la console ci-dessous ; les variables canvas et ctx donnent accès à la zone de dessin. Le programme tourne dans un Web Worker : une boucle infinie ne bloque pas la page, elle est arrêtée au bout de huit secondes.

  

    

    
    
  

  
  

    
Console

    
La zone de dessin du programme (canvas, 600 × 450 pixels).

  

  

    
Durée d'exécution
—

    
Lignes affichées
—

    
Contrôle : sortie identique à celle de Node.js pour l'exemple d'origine
—

  

  
Ce qu'il faut retenir. Le JavaScript de 1995 était interprété lentement ; en 2008, le moteur V8 de Google le compile à la volée en code machine pendant l'exécution, et le rend des dizaines de fois plus rapide. Cela a permis les grandes applications Web, puis Node.js côté serveur, puis Electron, qui fait de pages Web des applications de bureau (Visual Studio Code en est une). Le langage a gagné les classes, les modules, les promesses, et se modernise chaque année, sans jamais casser les anciens programmes. L'exemple 8 teste les toutes dernières nouveautés dans votre navigateur ; WebAssembly (2017) permet enfin d'exécuter à côté de JavaScript du code compilé depuis C, C++ ou Rust.






  
Où trouve-t-on JavaScript ?

  

    
Dans les navigateurs
C'est le seul langage que tous les navigateurs exécutent nativement. Selon W3Techs, 98,9 % des sites Web l'utilisaient le 27 octobre 2026 : menus, formulaires, cartes interactives, jeux, visioconférence.

    
Sur les serveurs
Node.js (2009), puis Deno (2020) et Bun (2023), exécutent JavaScript hors du navigateur. Le gestionnaire de paquets npm, créé en 2010, est devenu le plus grand dépôt de bibliothèques logicielles au monde.

    
Dans les applications
Avec Electron, des pages Web deviennent des logiciels de bureau, comme Visual Studio Code ; avec React Native, des applications pour téléphones. Les extensions des navigateurs et de nombreux logiciels sont aussi écrites en JavaScript.

    
Chez les développeurs
Dans l'enquête Stack Overflow 2025, 66 % des développeurs disaient l'avoir utilisé dans l'année. Son cousin typé TypeScript est devenu en août 2025 le langage le plus utilisé sur GitHub.

  






  
Frise des jalons

  






  Pour aller plus loin
  
  
Les tableaux d'égalité, les programmes de la boucle d'événements et les exemples de la planche 5 ont été exécutés par Node.js 22 au moment de la fabrication de la page, et les nombres de la planche 2 par Python 3.13 ; leurs résultats sont inclus pour contrôle. Sources des chiffres : W3Techs (octobre 2026), Stack Overflow Developer Survey 2025, GitHub Octoverse 2025.