À propos de ce cours
Objectifs de la leçon
- Convertir des données en JSON et inversement en JavaScript et en PHP.
- Utiliser les options de
json_encodeetJSON_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
{
"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();
}
| Option | Effet |
|---|---|
JSON_UNESCAPED_UNICODE | « é » au lieu de « \u00e9 » |
JSON_UNESCAPED_SLASHES | URL lisibles |
JSON_PRETTY_PRINT | Indentation (débogage) |
JSON_THROW_ON_ERROR | Exception au lieu de false/null |
JSON_PRESERVE_ZERO_FRACTION | 15.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.
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
- Pourquoi
json_encode($objet)renvoie-t-il{}pour un objet aux propriétés privées ? - Comment transmettre une date en JSON ?
- Pourquoi les données JSON envoyées par fetch n'apparaissent-elles pas dans
$_POST? - Faites implémenter
JsonSerializableàFormation(code, intitulé, places restantes, date limite). - Que fait
JSON_THROW_ON_ERRORavecjson_decode('{mauvais')? - Pourquoi transformer immédiatement le JSON reçu en DTO ?
Correction
- json_encode n'exporte que les propriétés publiques ; il faut implémenter
JsonSerializable. - Sous forme de chaîne au format ISO 8601 :
$date->format(DATE_ATOM); en JavaScript,new Date(chaine). - PHP ne remplit
$_POSTque pour les formulaires encodés (urlencoded ou multipart) ; il faut lire et décoderphp://input. public function jsonSerialize(): array { return ['code' => $this->code, 'intitule' => $this->intitule, 'places' => $this->placesRestantes(), 'dateLimite' => $this->dateLimite->format('Y-m-d')]; }- Il lève une
JsonExceptionau lieu de renvoyernullsilencieusement. - 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_decodeavecJSON_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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !