À 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.
-
Objectifs
- Comprendre le principe d'Ajax: échanger des données avec le serveur sans recharger la page.
- Envoyer une requête
GETet une requêtePOSTavec l'objetXMLHttpRequest. - 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.
-
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'huifetch. Malgré son nom, XHR transporte n'importe quel format : texte, HTML, JSON (le plus courant), fichiers.
-
Une requête GET en quatre étapes
- Créer l'objet :
new XMLHttpRequest(). Un objet sert pour une requête. - Préparer la requête :
xhr.open(methode, url). Un 3e paramètrefalserendrait la requête synchrone (la page serait figée pendant l'attente) : c'est obsolète et à ne jamais utiliser. - Écouter les événements :
loadquand la réponse est arrivée,errorsi le serveur est injoignable,timeoutsi le délai est dépassé. - Envoyer:
xhr.send(), avec éventuellement le corps de la requête en paramètre.
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();
});
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

- La propriété
readyStatepasse de 0 à 4 au fil de la requête, et l'événementreadystatechangeest 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
loadest plus simple : il équivaut à «readyStatevaut 4 et pas d'erreur réseau ».
| Valeur | Constante | Signification |
|---|---|---|
| 0 | UNSENT | Objet créé, open() pas encore appelé |
| 1 | OPENED | open() appelé |
| 2 | HEADERS_RECEIVED | send() appelé, statut et en-têtes reçus |
| 3 | LOADING | Corps de la réponse en cours de réception |
| 4 | DONE | Opération terminée (succès ou échec) |
-
Propriétés et méthodes à connaître
-
Envoyer des données : une requête POST
| Élément | Rô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" |
response | Le corps reçu, converti selon responseType |
responseText | Le corps reçu en texte (seulement si responseType vaut "" ou "text") |
status, statusText | Code 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 |
timeout | Délai maximal en millisecondes |
withCredentials | true pour envoyer les cookies vers un autre domaine (CORS) |
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 Createdavec le stagiaire complet, identifiant compris.
Le point fort qui reste : la progression des envois
- XHR émet des événements
progresspendant 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)
fetchsait 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ère | XMLHttpRequest | fetch |
|---|---|---|
| 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 status | Promesse tenue : tester reponse.ok |
| Annulation, délai | abort(), timeout | AbortController, AbortSignal.timeout() |
| Progression de l'envoi | Oui (xhr.upload.onprogress) | Non (pas simplement) |
| Service Workers, Node.js | Non | Oui |
| Usage aujourd'hui | Code existant, barres de progression d'envoi | Tout nouveau code |
Activités
Activité 1 : reproduire l'exemple
- Dans un dépôt GitHub
js-ajax-fetch, dossierxhr, reproduisez l'exemple et testez-le avec Live Server. Observez la requête dans l'onglet Réseau (filtre Fetch/XHR). - Remplacez
stagiaires.jsonparinexistant.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
timeoutde 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", …)etresponseType = "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
loadest-il déclenché pour une réponse 404 ? Et l'événementerror? - 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(), écouteursload/error/timeout,send(). loadse déclenche même pour un 404 : toujours testerxhr.status.fetchle 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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !