Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Les cours de programmation

AJAX avec l'API fetch et PHP

Cette leçon montre comment utiliser l'API fetch de JavaScript pour dialoguer avec un script PHP. Elle détaille les requêtes GET avec paramètres encodés, les requêtes POST avec FormData pour envoyer un...

0 chapitres 0 QCM Accès gratuit
AJAX avec l'API fetch et PHP

À propos de ce cours

Cette leçon montre comment utiliser l'API fetch de JavaScript pour dialoguer avec un script PHP. Elle détaille les requêtes GET avec paramètres encodés, les requêtes POST avec FormData pour envoyer un formulaire ou un fichier, la syntaxe async et await, la vérification du code de réponse, la gestion des erreurs réseau et applicatives, l'indicateur de chargement et l'envoi du jeton CSRF. Elle construit une petite classe JavaScript qui centralise ces règles.

Objectifs de la leçon

  • Envoyer une requête GET avec paramètres.
  • Envoyer un formulaire en POST avec FormData.
  • Vérifier le statut de la réponse et gérer les erreurs.
  • Afficher un indicateur de chargement et transmettre le jeton CSRF.
  • Organiser les appels dans une classe JavaScript.

1. Mise en situation

Le formulaire de candidature doit vérifier, pendant la saisie, si l'adresse e-mail est déjà utilisée, puis envoyer le formulaire et le CV sans recharger la page, en affichant les erreurs sous chaque champ.

Toutes ces interactions reposent sur fetch. L'appel est simple, mais un code robuste doit gérer des détails souvent oubliés : statut HTTP, erreurs réseau, double clic, jeton CSRF.

2. Une requête GET

Un envoi de formulaire avec fetch

Un envoi de formulaire avec fetch

async function emailDisponible(email) {
  const params = new URLSearchParams({ email });            // encode correctement les caractères spéciaux
  const reponse = await fetch(`/api/email-disponible.php?${params}`);
  if (!reponse.ok) throw new Error(`Erreur HTTP ${reponse.status}`);
  const { disponible } = await reponse.json();
  return disponible;
}

document.querySelector('#email').addEventListener('blur', async (e) => {
  const libre = await emailDisponible(e.target.value);
  e.target.classList.toggle('is-invalid', !libre);
});
<?php
// api/email-disponible.php
$email = filter_input(INPUT_GET, 'email', FILTER_VALIDATE_EMAIL);
if (!$email) {
    ReponseJson::erreur('Adresse invalide', 422)->envoyer();
}
ReponseJson::ok(['disponible' => !$utilisateurs->existeEmail($email)])->envoyer();

3. Envoyer un formulaire en POST

const formulaire = document.querySelector('#candidature');
formulaire.addEventListener('submit', async (e) => {
  e.preventDefault();                                   // empêche l'envoi classique
  const bouton = formulaire.querySelector('button');
  bouton.disabled = true;                               // évite le double envoi
  bouton.textContent = 'Envoi…';
  try {
    const reponse = await fetch(formulaire.action, {
      method: 'POST',
      body: new FormData(formulaire),                   // champs ET fichiers, encodage automatique
      headers: { 'X-CSRF-Token': document.querySelector('meta[name=csrf]').content },
    });
    const resultat = await reponse.json();
    if (reponse.ok) {
      formulaire.replaceWith(Object.assign(document.createElement('div'), { className: 'alert alert-success', textContent: resultat.message }));
    } else {
      afficherErreurs(formulaire, resultat.erreur.details);   // 422 : erreurs par champ
    }
  } catch (err) {
    alert('Connexion impossible. Vérifiez votre réseau.');  // erreur réseau
  } finally {
    bouton.disabled = false;
    bouton.textContent = 'Envoyer';
  }
});

fetch ne rejette la promesse qu'en cas d'erreur réseau. Une réponse 404, 422 ou 500 est une réponse « réussie » du point de vue de fetch : il faut tester reponse.ok (statut 200 à 299).

4. Côté PHP

<?php
// api/candidature.php — FormData arrive dans $_POST et $_FILES comme un formulaire classique
try {
    $dto = CandidatureDto::depuisTableau($_POST);
    $candidature = $service->deposer($dto, $_FILES['cv'] ?? null);
    ReponseJson::cree(['message' => 'Candidature enregistrée. Un e-mail de confirmation vous a été envoyé.', 'id' => $candidature->id()])->envoyer();
} catch (ValidationException $e) {
    ReponseJson::erreur('Formulaire incomplet', 422, $e->erreurs())->envoyer();   // ['email' => '…', 'cv' => '…']
}

5. Envoyer du JSON plutôt que FormData

await fetch('/api/statut.php', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': jeton },
  body: JSON.stringify({ id: 87, statut: 'en_etude' }),
});
// Côté PHP : $donnees = json_decode(file_get_contents('php://input'), true, flags: JSON_THROW_ON_ERROR);

Avec un corps JSON, PHP ne remplit pas $_POST: il faut lire le flux php://input (leçon suivante).

6. Vers la POO : une classe JavaScript ClientApi

Le même raisonnement objet s'applique côté navigateur : une classe ClientApi centralise l'adresse de base, le jeton CSRF, la vérification du statut et la conversion des erreurs. Les pages n'écrivent plus que l'essentiel.

Une classe JavaScript pour les appels AJAX

Diagramme de classe UML de ClientApi

class ErreurApi extends Error {
  constructor(statut, message, details = {}) {
    super(message);
    this.statut = statut;
    this.details = details;
  }
}

class ClientApi {
  #base;
  #jeton;

  constructor(base = '/api') {
    this.#base = base;
    this.#jeton = document.querySelector('meta[name=csrf]')?.content ?? '';
  }

  async #requete(methode, chemin, corps = null) {
    const options = { method: methode, headers: { 'Accept': 'application/json', 'X-CSRF-Token': this.#jeton } };
    if (corps instanceof FormData) options.body = corps;
    else if (corps !== null) { options.body = JSON.stringify(corps); options.headers['Content-Type'] = 'application/json'; }

    const reponse = await fetch(this.#base + chemin, options);
    const donnees = reponse.status === 204 ? null : await reponse.json();
    if (!reponse.ok) throw new ErreurApi(reponse.status, donnees?.erreur?.message ?? 'Erreur', donnees?.erreur?.details);
    return donnees;
  }

  get(chemin, params = {}) { const q = new URLSearchParams(params); return this.#requete('GET', `${chemin}?${q}`); }
  post(chemin, corps) { return this.#requete('POST', chemin, corps); }
  patch(chemin, corps) { return this.#requete('PATCH', chemin, corps); }
  delete(chemin) { return this.#requete('DELETE', chemin); }
}

// Utilisation
const api = new ClientApi();
try {
  const { disponible } = await api.get('/email-disponible.php', { email });
  await api.post('/candidature.php', new FormData(formulaire));
} catch (e) {
  if (e instanceof ErreurApi && e.statut === 422) afficherErreurs(formulaire, e.details);
}

On y retrouve les notions du cours : propriétés privées (#base), méthode privée, héritage d'une classe d'erreur, exceptions typées. La POO n'est pas propre à PHP.

Exercice Activités
  1. Pourquoi fetch ne lève-t-il pas d'erreur pour une réponse 404 ?
  2. Pourquoi désactiver le bouton pendant l'envoi ?
  3. Où PHP trouve-t-il les données envoyées avec FormData? Et avec JSON.stringify?
  4. Écrivez l'appel GET qui charge les délégations d'un gouvernorat et remplit un <select>.
  5. Pourquoi utiliser URLSearchParams pour construire l'URL ?
  6. Ajoutez à ClientApi un délai maximal de 10 secondes.
Correction
  1. fetch ne rejette qu'en cas d'échec réseau ; une 404 est une réponse valide du serveur. Il faut vérifier reponse.ok ou reponse.status.
  2. Pour empêcher un double clic d'envoyer deux fois le formulaire (doublon de candidature).
  3. Dans $_POST et $_FILES; avec un corps JSON, dans file_get_contents('php://input') à décoder.
  4. const liste = await api.get('/delegations.php', { gouvernorat: g }); select.replaceChildren(...liste.map(d => new Option(d.nom, d.id)));
  5. Pour encoder correctement les caractères spéciaux (espaces, &, accents) des paramètres.
  6. Dans #requete: options.signal = AbortSignal.timeout(10000);; une TimeoutError est levée si le serveur ne répond pas à temps.

Résumé

  • GET avec URLSearchParams; POST avec FormData ou JSON.
  • Toujours tester reponse.ok: fetch ne rejette que les erreurs réseau.
  • Bouton désactivé, indicateur de chargement, jeton CSRF dans un en-tête.
  • PHP répond en JSON avec un code HTTP significatif (201, 422…).
  • Une classe ClientApi centralise ces règles côté JavaScript.

Cet article vous a-t-il aidé ?