serialize & unserialize

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 49 sur 91.

Lorsque vous avez besoin de convertir un objet en une chaîne de caractères pour le stockage ou la transmission, PHP utilise la sérialisation. Les méthodes magiques __serialize() et __unserialize() vous permettent de contrôler exactement quelles données sont sauvegardées et comment elles sont restaurées.

La méthode __serialize() retourne un tableau de données à sérialiser, tandis que __unserialize() reçoit ce tableau et reconstruit l'objet :

<?php
class Session {
    public function __construct(
        private string $userId,
        private array $data,
        private int $createdAt
    ) {}
    
    public function __serialize(): array {
        return [
            'userId' => $this->userId,
            'data' => $this->data
        ];
    }
    
    public function __unserialize(array $data): void {
        $this->userId = $data['userId'];
        $this->data = $data['data'];
        $this->createdAt = time();
    }
    
    public function getCreatedAt(): int {
        return $this->createdAt;
    }
}

$session = new Session("user123", ["theme" => "dark"], time());
$serialized = serialize($session);

$restored = unserialize($serialized);
echo "User: " . $restored->getCreatedAt();

Remarquez comment createdAt est exclu de la sérialisation et reçoit un nouvel horodatage lors de la désérialisation. Ceci est utile pour exclure des données sensibles, des valeurs temporaires ou des ressources qui ne peuvent pas être sérialisées, comme les connexions à une base de données.

Ces méthodes ont remplacé les anciennes méthodes __sleep() et __wakeup() dans PHP 7.4, offrant une approche plus propre où vous travaillez directement avec des tableaux de données au lieu de noms de propriétés.

Défi

Facile

Construisons un système de mise en cache de profil utilisateur qui démontre comment __serialize() et __unserialize() vous permettent de contrôler quelles données sont sauvegardées et comment elles sont restaurées.

Vous organiserez votre code sur deux fichiers :

UserProfile.php — Créez une classe UserProfile qui représente le profil d'un utilisateur avec des capacités de mise en cache. Utilisez la promotion de constructeur pour définir des propriétés privées pour $userId (string), $username (string), $email (string), et $accessToken (string). Ajoutez une propriété privée $cachedAt qui stocke le moment où le profil a été mis en cache (initialisez-la à "not cached" dans le constructeur). Votre classe a besoin de :
- __serialize() — Retourne un tableau contenant uniquement le userId, username, et email. Le accessToken est sensible et ne doit jamais être sérialisé. L'horodatage cachedAt sera régénéré lors de la restauration.
- __unserialize() — Restaure le userId, username, et email à partir du tableau de données. Définit accessToken à "expired" (car les jetons ne doivent pas persister).
- getInfo() — Retourne une chaîne de caractères au format : "[username] ([email]) - Token: [accessToken] - Cached: [cachedAt]"
main.php — Incluez le fichier UserProfile. Vous recevrez quatre entrées : un ID utilisateur, un nom d'utilisateur, un e-mail et un jeton d'accès. Créez une instance de UserProfile avec ces valeurs. Affichez trois lignes :
- Les informations du profil original (avant sérialisation)
- Sérialisez le profil en utilisant serialize(), puis désérialisez-le en utilisant unserialize() pour créer un profil restauré. Affichez les informations du profil restauré.
- Affichez "Token preserved: yes" ou "Token preserved: no" selon que le jeton du profil restauré correspond ou non à l'original (indice : il ne devrait pas correspondre car les jetons expirent lors de la restauration)

Ce modèle est essentiel pour mettre en cache les données utilisateur en toute sécurité — vous voulez stocker les informations du profil mais ne jamais faire persister des identifiants sensibles comme les jetons d'accès. Lorsque le profil est restauré à partir du cache, le jeton est marqué comme expiré, forçant l'application à en obtenir un nouveau.

Aide-mémoire

Les méthodes magiques __serialize() et __unserialize() contrôlent quelles données sont sauvegardées lors de la sérialisation et comment les objets sont restaurés.

__serialize() retourne un tableau de données à sérialiser :

<?php
public function __serialize(): array {
    return [
        'userId' => $this->userId,
        'data' => $this->data
    ];
}

__unserialize() reçoit le tableau et reconstruit l'objet :

<?php
public function __unserialize(array $data): void {
    $this->userId = $data['userId'];
    $this->data = $data['data'];
    $this->createdAt = time();
}

Utilisez serialize() pour convertir un objet en chaîne de caractères et unserialize() pour le restaurer :

<?php
$serialized = serialize($session);
$restored = unserialize($serialized);

Ces méthodes sont utiles pour exclure des données sensibles, des valeurs temporaires ou des ressources qui ne peuvent pas être sérialisées (comme les connexions à une base de données). Les propriétés peuvent être régénérées avec de nouvelles valeurs lors de la désérialisation.

Essayez vous-même

<?php

require_once 'UserProfile.php';

// Lire les entrées
$userId = trim(fgets(STDIN));
$username = trim(fgets(STDIN));
$email = trim(fgets(STDIN));
$accessToken = trim(fgets(STDIN));

// TODO : Créer une instance de UserProfile avec les valeurs d'entrée

// TODO : Afficher les informations du profil d'origine (avant la sérialisation)

// TODO : Sérialiser le profil, puis le désérialiser pour créer un profil restauré

// TODO : Afficher les informations du profil restauré

// TODO : Afficher "Token preserved: yes" ou "Token preserved: no"
// selon que le jeton du profil restauré correspond ou non à l'original

?>