Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

Historique de l'objet xmlhttprequest

Retracez l'histoire des échanges asynchrones sur le web : invention de XMLHTTP par Microsoft en 1999 pour Outlook Web Access, adoption par Mozilla, Safari et Opera, Gmail et Google Maps, naissance du ...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Retracez l'histoire des échanges asynchrones sur le web : invention de XMLHTTP par Microsoft en 1999 pour Outlook Web Access, adoption par Mozilla, Safari et Opera, Gmail et Google Maps, naissance du mot Ajax en 2005, jQuery, normalisation au W3C puis au WHATWG, XMLHttpRequest Level 2, arrivée de fetch en 2015, async/await et fetch dans Node.js. Avec une frise chronologique et des activités corrigées.
  1. Objectifs

    • Retracer l'histoire de XMLHttpRequest, de son invention par Microsoft à sa normalisation.
    • Comprendre comment Gmail, Google Maps et le mot « Ajax » ont transformé le web à partir de 2004.
    • Expliquer pourquoi l'API fetch a été créée et ce qu'elle a changé.
    • Situer les outils actuels (fetch, Axios, bibliothèques de requêtes) dans cette évolution.
  2. Avant 1999 : le web « page par page »

    • Dans les années 1990, le web fonctionne comme un livre : chaque clic charge une nouvelle page complète envoyée par le serveur. Un formulaire mal rempli renvoie toute la page avec un message d'erreur, et l'on attend à chaque étape, avec des modems de 56 kbit/s.
    • JavaScript, né en 1995 (chapitre 1), sert alors surtout à vérifier des formulaires et à animer quelques éléments. Il ne sait pas dialoguer avec le serveur.
    • Les développeurs bricolent des astuces : une iframe cachée dont on change l'adresse pour charger des données, des images invisibles dont l'adresse contient des paramètres, ou des applets Java. Cela fonctionne, mais c'est fragile et difficile à maintenir.

    Frise chronologique de XMLHttpRequest à fetch, de 1999 à 2026

  3. 1999 : Microsoft invente XMLHTTP

    • L'équipe de Microsoft qui développe Outlook Web Access, la version web de la messagerie d'entreprise Exchange, veut une boîte de réception aussi réactive qu'un logiciel installé : nouveaux messages qui apparaissent seuls, lecture sans recharger la page.
    • Un de ses développeurs, Alex Hopmann, crée pour cela un composant capable d'envoyer des requêtes HTTP depuis JavaScript. Il est livré en mars 1999 avec Internet Explorer 5, sous la forme d'un contrôle ActiveX nommé Microsoft.XMLHTTP, dans la bibliothèque XML de Windows (MSXML). D'où le « XML » dans son nom : à l'époque, XML était le format de données à la mode.
    • Pour l'utiliser, il fallait écrire un code propre à Internet Explorer :
    // Code de l'époque (Internet Explorer 5 et 6 uniquement)
    var xhr = new ActiveXObject("Microsoft.XMLHTTP");
    xhr.open("GET", "messages.xml", true);
    xhr.onreadystatechange = function () {
      if (xhr.readyState == 4 && xhr.status == 200) {
        var doc = xhr.responseXML; // un document XML à parcourir
      }
    };
    xhr.send(null);
    • L'invention passe presque inaperçue : peu de développeurs savent qu'elle existe, et elle ne fonctionne que dans Internet Explorer sous Windows.
  4. 2002-2006 : les autres navigateurs adoptent l'objet

    • Les développeurs de Mozilla (l'ancêtre de Firefox) réalisent l'intérêt de l'outil et créent un objet natif, sans ActiveX, avec la même interface : new XMLHttpRequest(). Il est disponible dans Mozilla 1.0, en 2002.
    • Safari (version 1.2, en 2004) et Opera (version 8, en 2005) suivent. Microsoft lui-même ajoute l'objet natif dans Internet Explorer 7 en 2006.
    • Pendant des années, chaque script commence donc par un test pour savoir quel objet utiliser :
    // La fonction que tout le monde copiait au milieu des années 2000
    function creerRequete() {
      if (window.XMLHttpRequest) {
        return new XMLHttpRequest(); // Firefox, Safari, Opera, IE7+
      }
      return new ActiveXObject("Microsoft.XMLHTTP"); // IE5 et IE6
    }
  5. 2004-2005 : Gmail, Google Maps et la naissance du mot « Ajax »

    • Avril 2004 : Gmail. La messagerie de Google s'ouvre aux premiers utilisateurs. Classement des messages, recherche, écriture : tout se passe dans une seule page, sans rechargement. Avec 1 Go d'espace (énorme à l'époque), elle donne l'impression d'un vrai logiciel.
    • Février 2005 : Google Maps. On fait glisser la carte avec la souris et les morceaux manquants se chargent pendant le déplacement. Les concurrents obligeaient à cliquer sur des flèches et à recharger toute la page pour se déplacer : le choc est immense.
    • 18 février 2005 : le mot « Ajax ». Jesse James Garrett, de l'agence Adaptive Path, publie l'article « Ajax: A New Approach to Web Applications ». Il donne un nom, Ajax (Asynchronous JavaScript and XML), à cette façon de construire des pages avec HTML, CSS, le DOM, JavaScript et XMLHttpRequest. Le mot se répand en quelques semaines : livres, conférences, offres d'emploi.
    • C'est le début de l'époque dite du « Web 2.0 » : des sites qui se comportent comme des applications, où les utilisateurs participent (Flickr, Facebook, YouTube, Wikipédia…).
  1. 2005-2012 : les bibliothèques simplifient Ajax

    • Écrire un code Ajax qui fonctionne dans tous les navigateurs est laborieux : objets différents, bogues propres à chacun, gestion des états. Des bibliothèques masquent ces différences : Prototype.js (Ajax.Request, 2005), Dojo, YUI de Yahoo, MooTools et surtout jQuery (2006), qui devient l'outil le plus utilisé du web :
    // jQuery : une ligne au lieu d'une vingtaine
    $.ajax({ url: "stagiaires.json", dataType: "json" })
      .done(function (stagiaires) { console.log(stagiaires.length); })
      .fail(function () { alert("Erreur"); });
    
    // ou encore plus court
    $.getJSON("stagiaires.json", function (stagiaires) { /* … */ });
    • Le format JSON, popularisé par Douglas Crockford, remplace progressivement XML : plus léger et directement utilisable en JavaScript. Le nom « XMLHttpRequest » devient trompeur, mais il est trop tard pour le changer.
    • Le chapitre 22 vous montrera $.ajax(): vous le rencontrerez encore dans de nombreux sites existants.
  2. La normalisation : du W3C au WHATWG

    • XMLHttpRequest a été utilisé pendant des années sans norme écrite. Le W3C, organisme qui normalise le web, publie un premier brouillon de spécification en avril 2006, pour décrire ce que les navigateurs font déjà.
    • En 2008, une deuxième version, « XMLHttpRequest Level 2 », ajoute des fonctions très attendues :
    NouveautéCe qu'elle permet
    Requêtes entre domaines (CORS)Interroger l'API d'un autre site si celui-ci l'autorise (auparavant interdit, on utilisait une astuce appelée JSONP)
    Objet FormDataEnvoyer un formulaire complet, fichiers compris
    Événements progress, load, error, timeoutBarres de progression, gestion d'erreur plus simple que readystatechange
    responseType et responseRecevoir directement du JSON, des fichiers binaires (Blob, ArrayBuffer)
    • Les deux versions sont fusionnées. Depuis 2012, la norme est maintenue par le WHATWG (groupe formé par les éditeurs de navigateurs, qui maintient aussi la norme HTML) sous la forme d'un « Living Standard » : un document unique, mis à jour en continu plutôt que par versions numérotées.
  3. 2015 : l'arrivée de fetch

    • Malgré ces améliorations, XMLHttpRequest garde son interface des années 1990 : un objet à configurer, des événements, et un code qui devient illisible dès qu'on enchaîne plusieurs requêtes. Pendant ce temps, JavaScript adopte les promesses (normalisées dans ES2015).
    • Le WHATWG conçoit alors une nouvelle API, fetch, fondée sur les promesses. Elle arrive dans Chrome 42 et Firefox 39 en 2015, puis dans Edge (2016) et Safari (2017). Elle introduit des objets clairs : Request, Response, Headers.
    • Avec async / await (ES2017), le code devient presque aussi lisible que du code synchrone :
    // La même requête en 2026
    const reponse = await fetch("stagiaires.json");
    const stagiaires = await reponse.json();
    • fetch apporte aussi : l'annulation avec AbortController (2017-2018), la lecture de la réponse en flux (afficher le début d'un long texte avant la fin, comme les assistants conversationnels), et une intégration naturelle avec les Service Workers qui rendent possible le mode hors ligne.
  4. Aujourd'hui

    • fetch est partout : dans tous les navigateurs, mais aussi côté serveur depuis Node.js 18 (2022, en expérimental, puis stable avec Node.js 21 en 2023), Deno et Bun. Le même code fonctionne dans le navigateur et sur le serveur.
    • XMLHttpRequest est toujours là : les navigateurs le gardent pour ne pas casser des millions de sites, et il reste utile pour suivre la progression de l'envoi d'un fichier (leçon 2).
    • Les bibliothèques ont évolué : jQuery est en recul pour les nouveaux projets. On utilise fetch directement, ou des outils construits par-dessus : Axios (très populaire, avec intercepteurs et transformation automatique du JSON), ky (petit enrobage de fetch), et des bibliothèques de gestion des données comme TanStack Query, qui ajoutent cache, nouvelles tentatives et rafraîchissement automatique.
    • Ajax est devenu la norme : le mot est moins employé, mais toutes les applications modernes (Angular, React, Vue, chapitre 24) reposent sur ce principe, poussé à l'extrême avec les applications monopages (chapitre 21).
    AnnéeÉvénement
    1999Microsoft.XMLHTTP dans Internet Explorer 5 (Outlook Web Access)
    2002Objet natif XMLHttpRequest dans Mozilla
    2004Gmail ; XMLHttpRequest dans Safari 1.2
    2005Google Maps ; article de Jesse James Garrett et naissance du mot « Ajax »
    2006Premier brouillon du W3C ; jQuery ; objet natif dans Internet Explorer 7
    2008XMLHttpRequest Level 2 (CORS, FormData, progression)
    2012La norme est maintenue par le WHATWG (Living Standard)
    2015API fetch dans Chrome 42 et Firefox 39 ; promesses dans ES2015
    2017async / await (ES2017) ; fetch dans tous les navigateurs récents
    2022-2023fetch natif dans Node.js (18, puis stable dans la version 21)
  5. Activités

  6. Activité 1 : frise chronologique

  • Sans regarder la leçon, replacez dans l'ordre : article sur Ajax, Internet Explorer 5, fetch dans Chrome, XMLHttpRequest Level 2, Google Maps, objet natif dans Mozilla, async/await, fetch dans Node.js.

Activité 2 : du code de 2006 au code de 2026

  • Le code suivant charge un fichier formations.json et affiche le nombre de formations. Réécrivez-le avec fetch et async/await, en gérant les erreurs HTTP et réseau :
var xhr = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
xhr.onreadystatechange = function () {
  if (xhr.readyState == 4) {
    if (xhr.status == 200) {
      var liste = eval("(" + xhr.responseText + ")");
      document.getElementById("total").innerHTML = liste.length + " formations";
    }
  }
};
xhr.open("GET", "formations.json", true);
xhr.send(null);
  • Le code utilise eval() pour lire le JSON, ce qui était courant avant JSON.parse() (2009). Pourquoi est-ce dangereux ?

Activité 3 : exposé

  • Par groupes de deux, préparez un exposé de 5 minutes sur l'un des sujets : l'impact de Google Maps en 2005 ; jQuery, de 2006 à aujourd'hui ; JSONP et la naissance de CORS ; Axios ou fetch ?

Activité 4 : questions

  • Pourquoi l'objet s'appelle-t-il « XMLHttpRequest » alors qu'on l'utilise surtout avec JSON ?
  • Qui a inventé le mot « Ajax », et en quelle année ?
  • Citez deux avantages de fetch sur XMLHttpRequest et un cas où XMLHttpRequest reste utile.
Corrigés. Activité 1 : Internet Explorer 5 (1999), Mozilla (2002), Google Maps puis article sur Ajax (2005), XHR Level 2 (2008), fetch dans Chrome (2015), async/await (2017), fetch dans Node.js (2022). Activité 2 : const reponse = await fetch("formations.json"); if (!reponse.ok) throw new Error(`HTTP ${reponse.status}`); const liste = await reponse.json(); total.textContent = `${liste.length} formations`; dans un try / catch; eval() exécute n'importe quel code JavaScript reçu : un serveur piraté pourrait faire exécuter un script malveillant. Activité 4 : il a été créé en 1999 pour la bibliothèque XML de Microsoft, quand XML était le format d'échange dominant ; Jesse James Garrett, en février 2005 ; promesses et async/await, disponible dans les Service Workers et Node.js, annulation par signal ; la progression de l'envoi d'un fichier.
  • À retenir

    • 1999 : Microsoft crée XMLHTTP pour Outlook Web Access ; 2002-2006 : tous les navigateurs l'adoptent.
    • 2004-2005 : Gmail et Google Maps révèlent sa puissance ; Jesse James Garrett nomme la méthode « Ajax ».
    • 2008 : XHR Level 2 (CORS, FormData, progression) ; la norme est aujourd'hui un « Living Standard » du WHATWG.
    • 2015 : fetch, fondé sur les promesses, devient l'outil moderne, disponible aussi dans Node.js depuis 2022.

    Sources : MDN Web Docs, WHATWG (XMLHttpRequest, Fetch), IETF, open-meteo.com.



  • Cet article vous a-t-il aidé ?