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

L'objet XMLHttpRequest : présentation

Découvrez le principe d'Ajax et l'objet XMLHttpRequest : requête GET en quatre étapes, événements load, error et timeout, états readyState, propriétés et méthodes, requête POST en JSON, suivi de la pr...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Découvrez le principe d'Ajax et l'objet XMLHttpRequest : requête GET en quatre étapes, événements load, error et timeout, états readyState, propriétés et méthodes, requête POST en JSON, suivi de la progression d'un envoi de fichier, enveloppe dans une promesse, et comparaison détaillée avec fetch. Avec des activités corrigées, dont la lecture de code ancien.
  1. Objectifs

    • Comprendre le principe d'Ajax: échanger des données avec le serveur sans recharger la page.
    • Envoyer une requête GET et une requête POST avec l'objet XMLHttpRequest.
    • Connaître les états (readyState), les propriétés et les événements de l'objet.
    • Savoir lire du code existant qui utilise XHR, et savoir quand il reste utile face à fetch.
  2. Ajax : le principe

    • Sans Ajax, chaque action de l'utilisateur (envoyer un formulaire, changer de page de résultats, filtrer une liste) demande au serveur une nouvelle page complète: l'écran blanchit, tout est rechargé, la position de lecture est perdue.
    • Avec Ajax (Asynchronous JavaScript And XML), JavaScript envoie la requête en arrière-plan, reçoit seulement les données utiles, et met à jour une partie de la page avec le DOM. L'utilisateur peut continuer à utiliser la page pendant l'échange : c'est le sens du mot asynchrone (chapitre 18).
    • Exemples de tous les jours : les suggestions pendant une recherche, le « J'aime » qui s'incrémente, les messages qui arrivent dans une messagerie, la carte qui se complète quand on la déplace, le formulaire qui vérifie si un identifiant est déjà pris.
    • Ajax n'est pas une technologie, mais une façon de combiner HTML, CSS, le DOM, JavaScript et un objet capable d'envoyer des requêtes : historiquement XMLHttpRequest (XHR), aujourd'hui fetch. Malgré son nom, XHR transporte n'importe quel format : texte, HTML, JSON (le plus courant), fichiers.
  3. Une requête GET en quatre étapes

  4. Exemple : charger la liste des stagiaires depuis un fichier JSON quand on clique sur un bouton.

    stagiaires.json:

    [
      { "id": 1, "nom": "Amira Ben Ali", "groupe": "DEV-101", "moyenne": 15.5 },
      { "id": 2, "nom": "Youssef Trabelsi", "groupe": "DEV-102", "moyenne": 12 },
      { "id": 3, "nom": "Sana Gharbi", "groupe": "DEV-101", "moyenne": 17.25 }
    ]

    index.html:

    <!doctype html>
    <html lang="fr">
      <head>
        <meta charset="utf-8" />
        <title>XMLHttpRequest</title>
        <script src="xhr.js" defer></script>
      </head>
      <body>
        <h1>Liste des stagiaires</h1>
        <button id="btn-charger" type="button">Charger les stagiaires</button>
        <p id="etat"></p>
        <ul id="liste"></ul>
      </body>
    </html>

    xhr.js:

    const etat = document.getElementById("etat");
    const liste = document.getElementById("liste");
    
    document.getElementById("btn-charger").addEventListener("click", () => {
      // 1. Créer l'objet
      const xhr = new XMLHttpRequest();
    
      // 2. Préparer la requête : méthode, adresse (asynchrone par défaut)
      xhr.open("GET", "stagiaires.json");
      xhr.responseType = "json"; // la réponse sera convertie automatiquement
      xhr.timeout = 5000; // abandon au bout de 5 secondes
    
      // 3. Réagir à la réponse
      xhr.addEventListener("load", () => {
        if (xhr.status >= 200 && xhr.status < 300) {
          etat.textContent = `${xhr.response.length} stagiaire(s) chargé(s).`;
          liste.replaceChildren(
            ...xhr.response.map((stagiaire) => {
              const li = document.createElement("li");
              li.textContent = `${stagiaire.nom} (${stagiaire.groupe}) : ${stagiaire.moyenne}/20`;
              return li;
            }),
          );
        } else {
          etat.textContent = `Erreur HTTP ${xhr.status}`; // 404, 500…
        }
      });
      xhr.addEventListener("error", () => (etat.textContent = "Erreur réseau (serveur injoignable)."));
      xhr.addEventListener(
        "timeout",
        () => (etat.textContent = "Le serveur met trop de temps à répondre."),
      );
    
      // 4. Envoyer
      etat.textContent = "Chargement…";
      xhr.send();
    });
    1. Créer l'objet : new XMLHttpRequest(). Un objet sert pour une requête.
    2. Préparer la requête : xhr.open(methode, url). Un 3e paramètre false rendrait la requête synchrone (la page serait figée pendant l'attente) : c'est obsolète et à ne jamais utiliser.
    3. Écouter les événements : load quand la réponse est arrivée, error si le serveur est injoignable, timeout si le délai est dépassé.
    4. Envoyer: xhr.send(), avec éventuellement le corps de la requête en paramètre.
    Attention : l'événement load se déclenche dès que le serveur a répondu, même avec une erreur 404 ou 500. Il faut donc toujours tester xhr.status. L'événement error ne concerne que les problèmes de réseau (pas de connexion, serveur éteint, CORS refusé).
  • Testez avec Live Server : en ouvrant le fichier directement (file://), le navigateur bloque la requête.
  • Les états de la requête : readyState

  • XMLHttpRequest : les cinq valeurs de readyState, les propriétés et les événements

    • La propriété readyState passe de 0 à 4 au fil de la requête, et l'événement readystatechange est déclenché à chaque changement. Dans le code ancien (avant 2012), on trouve presque toujours cette forme :
    const xhr = new XMLHttpRequest();
    xhr.onreadystatechange = () => {
      console.log("readyState =", xhr.readyState);
      if (xhr.readyState === XMLHttpRequest.DONE && xhr.status === 200) {
        console.log("Réponse :", xhr.responseText);
      }
    };
    xhr.open("GET", "stagiaires.json");
    xhr.send();
    // Console : readyState = 1, 2, 3, 4 (DONE)
    • Aujourd'hui, l'événement load est plus simple : il équivaut à « readyState vaut 4 et pas d'erreur réseau ».
    ValeurConstanteSignification
    0UNSENTObjet créé, open() pas encore appelé
    1OPENEDopen() appelé
    2HEADERS_RECEIVEDsend() appelé, statut et en-têtes reçus
    3LOADINGCorps de la réponse en cours de réception
    4DONEOpération terminée (succès ou échec)
    1. Propriétés et méthodes à connaître

    2. ÉlémentRôle
      open(methode, url)Prépare la requête
      setRequestHeader(nom, valeur)Ajoute un en-tête (après open(), avant send())
      send(corps)Envoie la requête ; corps: texte, FormData, Blob…
      abort()Annule la requête en cours
      responseType"" ou "text" (défaut), "json", "blob", "arraybuffer", "document"
      responseLe corps reçu, converti selon responseType
      responseTextLe corps reçu en texte (seulement si responseType vaut "" ou "text")
      status, statusTextCode de statut (200, 404…) et son libellé ; 0 en cas d'erreur réseau
      getResponseHeader(nom)Lit un en-tête de la réponse
      timeoutDélai maximal en millisecondes
      withCredentialstrue pour envoyer les cookies vers un autre domaine (CORS)
    3. Envoyer des données : une requête POST

    4. Pour créer un stagiaire sur une API REST (par exemple celle de la leçon 5, lancée avec npx json-server db.json), on envoie un corps JSON en précisant son format :

      const xhr = new XMLHttpRequest();
      xhr.open("POST", "http://localhost:3000/stagiaires");
      xhr.setRequestHeader("Content-Type", "application/json");
      xhr.responseType = "json";
      xhr.addEventListener("load", () => {
        if (xhr.status === 201) {
          console.log("Créé avec l'identifiant", xhr.response.id);
        }
      });
      xhr.send(JSON.stringify({ nom: "Ines Haddad", groupe: "DEV-102", moyenne: 14 }));
    • setRequestHeader("Content-Type", "application/json") indique au serveur que le corps est du JSON.
    • JSON.stringify() convertit l'objet en texte : send() n'envoie pas d'objet JavaScript tel quel.
    • Le serveur répond 201 Created avec le stagiaire complet, identifiant compris.
  • Le point fort qui reste : la progression des envois

    • XHR émet des événements progress pendant le téléchargement de la réponse et, grâce à xhr.upload, pendant l'envoi du corps. On peut ainsi afficher une barre de progression lors de l'envoi d'un gros fichier (vidéo, PDF scanné, archive de projet) :
    // Envoi d'un fichier avec une barre de progression : le point fort de XMLHttpRequest
    const fichier = document.getElementById("fichier").files[0];
    const barre = document.getElementById("barre"); // <progress id="barre" max="100" value="0">
    
    const donnees = new FormData();
    donnees.append("document", fichier);
    
    const xhr = new XMLHttpRequest();
    xhr.upload.addEventListener("progress", (event) => {
      if (event.lengthComputable) {
        barre.value = Math.round((event.loaded / event.total) * 100);
      }
    });
    xhr.addEventListener("load", () => console.log("Envoi terminé :", xhr.status));
    xhr.open("POST", "/api/documents");
    xhr.send(donnees); // pas de Content-Type : le navigateur l'ajoute (multipart/form-data)
    • fetch sait suivre la réception d'une réponse (en lisant son flux), mais n'offre toujours pas d'équivalent simple pour la progression d'un envoi. C'est la principale raison d'utiliser encore XHR dans un code récent. La bibliothèque Axios, très utilisée, repose d'ailleurs sur XHR dans le navigateur.
  • Envelopper XHR dans une promesse

    • Les événements de XHR s'enchaînent mal quand il faut faire plusieurs requêtes à la suite (« l'enfer des callbacks », chapitre 18). On peut l'envelopper dans une promesse pour l'utiliser avec await:
    function requeteXhr(methode, url, corps = null) {
      return new Promise((resolve, reject) => {
        const xhr = new XMLHttpRequest();
        xhr.open(methode, url);
        xhr.responseType = "json";
        if (corps !== null) {
          xhr.setRequestHeader("Content-Type", "application/json");
        }
        xhr.addEventListener("load", () => {
          if (xhr.status >= 200 && xhr.status < 300) {
            resolve(xhr.response);
          } else {
            reject(new Error(`Erreur HTTP ${xhr.status}`));
          }
        });
        xhr.addEventListener("error", () => reject(new Error("Erreur réseau")));
        xhr.send(corps === null ? null : JSON.stringify(corps));
      });
    }
    
    const stagiaires = await requeteXhr("GET", "stagiaires.json");
    • C'est exactement ce que fait fetch, de façon native et plus complète : c'est pourquoi on l'utilise pour tout nouveau code (leçon 4).
  • XMLHttpRequest ou fetch ?

  • CritèreXMLHttpRequestfetch
    StyleÉvénements (callbacks)Promesses, async/await
    LisibilitéVerbeux (créer, ouvrir, écouter, envoyer)Une seule fonction
    Erreur HTTP (404, 500)Événement load: tester statusPromesse tenue : tester reponse.ok
    Annulation, délaiabort(), timeoutAbortController, AbortSignal.timeout()
    Progression de l'envoiOui (xhr.upload.onprogress)Non (pas simplement)
    Service Workers, Node.jsNonOui
    Usage aujourd'huiCode existant, barres de progression d'envoiTout nouveau code
  • Activités

  • Activité 1 : reproduire l'exemple

    • Dans un dépôt GitHub js-ajax-fetch, dossier xhr, reproduisez l'exemple et testez-le avec Live Server. Observez la requête dans l'onglet Réseau (filtre Fetch/XHR).
    • Remplacez stagiaires.json par inexistant.json: quel message obtenez-vous ? Puis arrêtez Live Server et cliquez de nouveau : quel événement est déclenché ?
    • Dans DevTools → Réseau, choisissez le débit Slow 3G et un timeout de 500 ms : vérifiez le message de délai dépassé.

    Activité 2 : filtrer par groupe

    • Ajoutez une liste déroulante « Groupe » (Tous, DEV-101, DEV-102) qui filtre l'affichage sans renvoyer de requête : les données sont gardées dans une variable après le premier chargement.
    • Affichez la moyenne du groupe sélectionné, arrondie à deux décimales.

    Activité 3 : lire du code ancien

    • Expliquez ligne par ligne le code suivant, puis réécrivez-le avec addEventListener("load", …) et responseType = "json":
    var req = new XMLHttpRequest();
    req.onreadystatechange = function () {
      if (req.readyState == 4) {
        if (req.status == 200) {
          var data = JSON.parse(req.responseText);
          document.getElementById("nb").innerHTML = data.length;
        } else {
          alert("Erreur " + req.status);
        }
      }
    };
    req.open("GET", "stagiaires.json", true);
    req.send(null);

    Activité 4 : questions

    • Que signifie le « A » de Ajax ? Pourquoi est-ce important pour l'utilisateur ?
    • L'événement load est-il déclenché pour une réponse 404 ? Et l'événement error?
    • Dans quel cas choisiriez-vous encore XHR plutôt que fetch?
    Corrigés. Activité 1 : inexistant.json affiche « Erreur HTTP 404 » (événement load) ; serveur arrêté : événement error, « Erreur réseau ». Activité 3 : le code teste readyState == 4 (terminé) puis le statut 200, convertit le texte en objet avec JSON.parse et affiche le nombre d'éléments ; le true de open() (asynchrone) est la valeur par défaut. Version moderne : xhr.responseType = "json"; xhr.addEventListener("load", () => { if (xhr.status === 200) { nb.textContent = xhr.response.length; } else { … } }); (et textContent plutôt qu'innerHTML). Activité 4 : Asynchronous, la page reste utilisable pendant l'échange ; load oui (le serveur a répondu), error non ; pour afficher la progression de l'envoi d'un gros fichier, ou pour maintenir un code existant.
  • À retenir

    • Ajax : échanger des données en arrière-plan et ne mettre à jour qu'une partie de la page.
    • XHR : new XMLHttpRequest(), open(), écouteurs load / error / timeout, send().
    • load se déclenche même pour un 404 : toujours tester xhr.status.
    • fetch le remplace dans le code neuf ; XHR reste utile pour la progression des envois et pour comprendre le code existant.

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



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