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

Échanger du JSON entre JavaScript et PHP

Cette leçon détaille l'échange de données au format JSON entre le navigateur et PHP. Elle présente JSON.stringify et JSON.parse côté JavaScript, puis json_encode et json_decode côté PHP avec leurs opt...

0 chapitres 0 QCM Accès gratuit
Échanger du JSON entre JavaScript et PHP

À propos de ce cours

Cette leçon détaille l'échange de données au format JSON entre le navigateur et PHP. Elle présente JSON.stringify et JSON.parse côté JavaScript, puis json_encode et json_decode côté PHP avec leurs options et la gestion des erreurs par exceptions, la lecture d'un corps JSON avec php://input, et surtout la sérialisation d'objets métier avec l'interface JsonSerializable. Elle montre comment transformer un JSON reçu en objet de transfert de données validé.

Objectifs de la leçon

  • Convertir des données en JSON et inversement en JavaScript et en PHP.
  • Utiliser les options de json_encode et JSON_THROW_ON_ERROR.
  • Lire un corps de requête JSON en PHP.
  • Sérialiser des objets avec JsonSerializable.
  • Transformer un JSON reçu en DTO validé.

1. Mise en situation

L'application mobile de suivi des notes et l'interface AJAX demandent toutes les deux les bulletins au serveur. Le développeur a écrit json_encode($bulletin): le résultat est {}, car les propriétés de l'objet sont privées. Dans l'autre sens, les données envoyées en JSON par l'application n'apparaissent pas dans $_POST.

JSON est la langue commune entre PHP, JavaScript et les applications mobiles. Pour que des objets la parlent correctement, PHP propose l'interface JsonSerializable; pour les données reçues, on construit des objets de transfert validés.

2. Le format JSON

Le voyage d’un objet en JSON

Le voyage d’un objet en JSON

{
  "etudiant": { "matricule": "20260001", "nom": "Ben Ali", "prenom": "Sara" },
  "moyenne": 13.75,
  "admis": true,
  "mention": "Assez bien",
  "notes": [ { "module": "POO", "valeur": 15 }, { "module": "BD", "valeur": 12.5 } ],
  "remarque": null
}

JSON connaît six types : objet, tableau, chaîne (entre guillemets doubles), nombre, booléen et null. Les dates n'existent pas : on les transmet en chaîne au format ISO 8601 (2026-11-22T10:30:00+01:00).

3. Côté JavaScript

const texte = JSON.stringify({ id: 87, statut: 'en_etude' });   // objet → chaîne
const objet = JSON.parse('{"id":87,"statut":"en_etude"}');          // chaîne → objet
const donnees = await reponse.json();                                // fetch : lit et décode la réponse

4. Côté PHP

<?php
// Encoder
echo json_encode($tableau, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);

// Décoder un corps de requête JSON
try {
    $donnees = json_decode(file_get_contents('php://input'), true, 512, JSON_THROW_ON_ERROR);   // true : tableau associatif
} catch (JsonException) {
    ReponseJson::erreur('JSON invalide', 400)->envoyer();
}
OptionEffet
JSON_UNESCAPED_UNICODE« é » au lieu de « \u00e9 »
JSON_UNESCAPED_SLASHESURL lisibles
JSON_PRETTY_PRINTIndentation (débogage)
JSON_THROW_ON_ERRORException au lieu de false/null
JSON_PRESERVE_ZERO_FRACTION15.0 reste 15.0

5. Encoder des objets : JsonSerializable

<?php
final class Bulletin implements JsonSerializable
{
    // … propriétés privées et méthodes métier

    public function jsonSerialize(): array
    {
        return [
            'etudiant' => $this->etudiant,                     // si Etudiant implémente aussi JsonSerializable
            'moyenne'  => $this->moyenne(),
            'mention'  => $this->mention()?->value,            // énumération → sa valeur
            'admis'    => $this->estAdmis(),
            'notes'    => array_map(fn($l) => ['module' => $l['module']->code, 'valeur' => $l['note']->valeur], array_values($this->lignes)),
            'generele' => (new DateTimeImmutable())->format(DATE_ATOM),
        ];
    }
}

echo json_encode($bulletin);       // appelle automatiquement jsonSerialize()

Sans JsonSerializable, json_encode n'exporte que les propriétés publiques. Avec, c'est la classe qui décide de ce qu'elle expose : on n'envoie jamais par mégarde un hachage de mot de passe ou une donnée interne.

6. Le JSON côté mobile

Une application Flutter ou Android reçoit exactement le même JSON que le navigateur. Une structure stable (mêmes clés, mêmes types, dates ISO) permet de générer automatiquement les classes correspondantes côté mobile, par exemple avec json_serializable en Dart : la méthode jsonSerialize() de PHP devient le contrat entre les deux applications. Évitez donc de renvoyer tantôt un nombre, tantôt une chaîne pour la même clé.

7. Mise en pratique : un DTO pour les données reçues

Dans l'autre sens, un tableau issu de json_decode peut contenir n'importe quoi. On le transforme immédiatement en DTO (objet de transfert de données) typé et validé : le reste du code ne manipule plus jamais de tableau brut.

Un DTO construit depuis le JSON reçu

Diagramme de classe UML de NoteDto

<?php
declare(strict_types=1);

final readonly class NoteDto
{
    private function __construct(public int $etudiantId, public string $module, public float $valeur) {}

    public static function depuisJson(string $json): self
    {
        $d = json_decode($json, true, 16, JSON_THROW_ON_ERROR);
        $erreurs = [];
        if (!is_int($d['etudiant_id'] ?? null) || $d['etudiant_id'] < 1) { $erreurs['etudiant_id'] = 'Identifiant invalide'; }
        if (!is_string($d['module'] ?? null) || !preg_match('/^[A-Z]{2,6}$/', $d['module'])) { $erreurs['module'] = 'Code module invalide'; }
        if (!is_numeric($d['valeur'] ?? null) || $d['valeur'] < 0 || $d['valeur'] > 20) { $erreurs['valeur'] = 'Note entre 0 et 20'; }
        if ($erreurs) {
            throw new ValidationException($erreurs);
        }
        return new self($d['etudiant_id'], $d['module'], (float) $d['valeur']);
    }
}

// api/notes.php
try {
    $dto = NoteDto::depuisJson(file_get_contents('php://input'));
    $note = $service->noter($dto->etudiantId, $dto->module, $dto->valeur);
    ReponseJson::cree($note)->envoyer();                                    // $note implémente JsonSerializable
} catch (JsonException) {
    ReponseJson::erreur('JSON invalide', 400)->envoyer();
} catch (ValidationException $e) {
    ReponseJson::erreur('Données invalides', 422, $e->erreurs())->envoyer();
}
Exercice Activités
  1. Pourquoi json_encode($objet) renvoie-t-il {} pour un objet aux propriétés privées ?
  2. Comment transmettre une date en JSON ?
  3. Pourquoi les données JSON envoyées par fetch n'apparaissent-elles pas dans $_POST?
  4. Faites implémenter JsonSerializable à Formation (code, intitulé, places restantes, date limite).
  5. Que fait JSON_THROW_ON_ERROR avec json_decode('{mauvais')?
  6. Pourquoi transformer immédiatement le JSON reçu en DTO ?
Correction
  1. json_encode n'exporte que les propriétés publiques ; il faut implémenter JsonSerializable.
  2. Sous forme de chaîne au format ISO 8601 : $date->format(DATE_ATOM); en JavaScript, new Date(chaine).
  3. PHP ne remplit $_POST que pour les formulaires encodés (urlencoded ou multipart) ; il faut lire et décoder php://input.
  4. public function jsonSerialize(): array { return ['code' => $this->code, 'intitule' => $this->intitule, 'places' => $this->placesRestantes(), 'dateLimite' => $this->dateLimite->format('Y-m-d')]; }
  5. Il lève une JsonException au lieu de renvoyer null silencieusement.
  6. Pour valider et typer les données une seule fois, à l'entrée ; le reste du code manipule un objet fiable au lieu d'un tableau incertain.

Résumé

  • JSON : objets, tableaux, chaînes, nombres, booléens, null ; dates en ISO 8601.
  • JSON.stringify/JSON.parse; json_encode/json_decode avec JSON_THROW_ON_ERROR.
  • Un corps JSON se lit dans php://input.
  • JsonSerializable: la classe choisit ce qu'elle expose.
  • Un DTO valide et type les données reçues.

Cet article vous a-t-il aidé ?