Français
Français
Les développeurs peuvent rencontrer des erreurs "ne peuvent pas non désérialiser" lors de l'utilisation des fonctions de sérialisation et de non-série de PHP. Cette erreur indique généralement que PHP ne peut pas désérialiser avec succès une chaîne dans un objet ou un tableau. Cet article couvrira certaines raisons courantes et comment résoudre ce problème.
La fonction sérialize peut convertir une structure de données PHP (telle qu'un objet ou un tableau) en une chaîne, tandis que Unserialize convertit la chaîne à la structure de données d'origine. Cependant, dans certains cas, lors de l'appel de non-série , vous pouvez rencontrer des messages d'erreur similaires à ce qui suit:
Warning: unserialize(): Error at offset 0 of 2 bytes in /path/to/script.php on line 20
Cannot unserialize
Cette erreur se produit généralement pour les raisons suivantes.
L'une des raisons les plus courantes est que les données sérialisées sont falsifiées ou corrompues. Cela peut se produire pendant les transferts, comme lors du stockage des données via une URL ou une base de données. Si les données sérialisées sont modifiées de manière incorrecte, un non-série ne peut pas restaurer sa structure d'origine.
Solution:
Assurez-vous que les données sérialisées ne sont pas corrompues ou modifiées pendant le stockage et la transmission. Si vous passez des données sérialisées à l'aide de paramètres URL, vérifiez s'il y a des caractères spéciaux (tels que & , = ,? ) Qui provoquent des changements de données.
Si vous passez des données sérialisées via URL, veuillez utiliser URLencode pour coder la chaîne sérialisée, et le récepteur utilisera URLDECODE pour décoder pour éviter une interférence de caractères spéciale.
// Utiliser avant le transfert urlencode codage
$serialized_data = urlencode(serialize($data));
// Décoder et désérialiser après avoir reçu
$data = unserialize(urldecode($serialized_data));
Si l'objet sérialisé contient une classe et que la classe ne peut pas être trouvée pendant la désérialisation, PHP lancera une erreur "ne peut pas se désérialiser". Par exemple, il se peut que le fichier de la classe ne soit pas inclus correctement ou que le nom de la classe ait changé.
Solution:
Assurez-vous que toutes les classes requises sont chargées correctement, surtout lorsque vous utilisez des objets. Les fichiers de classe peuvent être chargés automatiquement à l'aide de SPL_autoload_register .
Si la classe a été renommée ou supprimée, vérifiez la version et la structure des données sérialisées pour vous assurer que le nom de classe reste cohérent pendant la désérialisation.
// Chargez automatiquement la classe
spl_autoload_register(function ($class) {
include 'path/to/classes/' . $class . '.php';
});
Si les données sérialisées sont transférées entre différentes versions PHP, il peut y avoir une incompatibilité entre certaines versions PHP. En particulier, PHP 7 et PHP 8 ont apporté certaines modifications dans la sérialisation des objets, ce qui peut entraîner l'échec de la désérialisation.
Solution:
Assurez-vous que les versions PHP sont cohérentes dans tous les environnements d'exécution, ou envisagez un traitement approprié des données avant la désérialisation (par exemple, la conversion en format compatible).
Si vous ne pouvez pas contrôler la version PHP, vous pouvez essayer d'utiliser le format JSON au lieu de la sérialisation.
// utiliser JSON Alternative serialize
$json_data = json_encode($data);
// utiliser json_decode Alternative unserialize
$data = json_decode($json_data, true);
Si vous passez des données sérialisées entre différents systèmes de codage de caractères, vous pouvez rencontrer des jeux de caractères incohérents. Cela entraîne généralement une non-série pour décoder correctement les données.
Solution:
Assurez-vous que le codage du caractère des données est cohérent, en particulier lors du transfert de données. Un jeu de caractères unifié (tel que UTF-8) peut être utilisé lors du stockage des données pour éviter les problèmes d'encodage.
// 设置字符codage为 UTF-8
mb_internal_encoding("UTF-8");
Si l'objet sérialisé contient le type de ressource PHP (tel que les connexions de base de données, les poignées de fichiers, etc.), ces ressources ne peuvent pas être restaurées pendant la désérialisation, ce qui peut entraîner une erreur.
Solution:
Avant de sérialiser l'objet, assurez-vous de supprimer les membres de la ressource de l'objet ou implémentez les méthodes __Sleep et __wakeup pour gérer la libération et la récupération des ressources.
class MyClass {
private $file;
public function __sleep() {
// Supprimer les ressources avant la sérialisation
unset($this->file);
return ['file']; // Renvoie les attributs qui doivent être sérialisés
}
public function __wakeup() {
// Rouvrir la ressource après désérialisation
$this->file = fopen('path/to/file', 'r');
}
}
Lorsque vous rencontrez une erreur "non désérialisée", vous pouvez utiliser certaines techniques de débogage pour résoudre le problème:
Vérifiez l'intégrité des données sérialisées: Sortie de la chaîne sérialisée pour vous assurer qu'elle semble complète et non tronquée.
Activer les rapports d'erreur: utilisez Error_Reporting (E_ALL) et INI_SET ('Display_errors', 1) pour activer les rapports d'erreur détaillés pour afficher les invites possibles.
Vérifiez les données avec var_dump : avant la désérialisation, utilisez var_dump pour vérifier le format et le contenu des données pour vous assurer qu'il répond aux attentes.
var_dump($serialized_data);
Un non-service de l'erreur "ne peut pas nonsérialiser" est généralement liée à l'intégrité des données sérialisées, de l'incompatibilité de la version PHP, des fichiers de classe manquants ou des problèmes d'encodage de caractères. Le problème peut généralement être résolu en vérifiant ces causes communes une par une et en prenant des solutions correspondantes. Si les conditions le permettent, envisagez d'utiliser JSON au lieu de la sérialisation et de la désérialisation, en particulier dans la plate-forme multiples ou les versions, ce qui peut éviter certains problèmes de compatibilité potentiels.
