Variables sérialisées et objets sérialisés en PHP

La sérialisation consiste probablement à convertir certaines variables en un flux d'octets de chaînes, ce qui facilite la transmission et le stockage. Bien sûr, cela n'a rien à voir avec la transmission et le stockage. L'essentiel est qu'il puisse être reconverti sous forme de chaîne et que la structure de données d'origine puisse être conservée.

Il existe de nombreuses fonctions de sérialisation en PHP : serialize() Cette fonction convertit n'importe quelle valeur de variable (à l'exception des variables de ressource) sous la forme d'une chaîne. La chaîne peut être enregistrée dans un fichier, ou enregistrée en tant que session, ou même utiliser curl pour. simulez GET/POST pour transférer des variables afin d'obtenir l'effet de RPC.

Si vous souhaitez convertir des variables sérialisées en valeurs de variables PHP originales, vous pouvez utiliser la fonction unserialize().

1. Sérialisation variable

Prenons un exemple simple pour illustrer la sérialisation et son format de stockage.

Type entier :

$var = 23 ;
echo serialize($var);

Sortie :

i:23;

Type à virgule flottante :

$

var = 1,23;

;

Sortie

 :

d:1.22999999999999982236431605997495353221893310546875 ;

echo sérialiser($var);
$var = "Je suis une variable" ;
echo serialize($var);

Sortie :

s:16:"Ceci est une chaîne";
s:8 : "Je suis une variable" ;

Type booléen :

$var = true ;
echo sérialiser($var);
$var = faux ;
echo sérialiser($var);

Sortie :

b:1 ;
b:0;

La situation après la sérialisation des types de base ci-dessus est très claire.Le format de stockage après la sérialisation est :

de

variable : [longueur variable :] valeur de la variable ;

Représente le fractionnement. La longueur de la variable est facultative, c'est-à-dire qu'elle est disponible dans le type chaîne mais pas dans les autres types. La dernière est la valeur de la variable. Chaque valeur sérialisée se termine par ";".

Par exemple, une fois que notre nombre entier 23 est sérialisé, il est : i:23, alors il n'a pas de longueur, seulement un type et une valeur variable, i représente un entier, séparé par deux points, et la valeur entière 23 est enregistrée plus tard, y compris la virgule flottante. type (double) Type d'octet) est le même. Pour Boolean, le type est b (booléen). Si c'est vrai, la valeur sérialisée est 1. Si c'est faux, la valeur est 0.

Pour les valeurs

de chaîne

Nous nous concentrons ensuite sur la sérialisation des variables de tableau.

Variable de tableau :

$var = array("abc", "def", "xyz", "123");
echo sérialiser($var);

Sortie :

a:4:{i:0;s:3:"abc";i:1;s:3:"def";i:2;s:3:"xyz"; i:3;s:3:"123";}

est la valeur de chaîne obtenue en sérialisant mon tableau $var Notre tableau $var comprend 4 éléments de chaîne, à savoir "abc", "def" , "xyz", "123". , analysons les données sérialisées. Pour plus de simplicité, nous répertorions les données sérialisées sous forme de tableau :

a:4 :
{
je:0;s:3:"abc";
je:1;s:3:"déf";
je:2;s:3:"xyz";
je:3;s:3:"123";
}

L'arrangement est plus clair. Regardez la chaîne de départ : a:4:{...} Tout d'abord, le premier caractère a enregistre le type de variable, qui est le type de tableau (tableau), et le second 4 enregistre les éléments du tableau. Le nombre de , il y en a 4 au total, puis le contenu des éléments du tableau entre {}. Par exemple, le premier élément du tableau : i:0;s:3:"abc"; i représente que le type de valeur d'index de l'élément de tableau actuel est entier, la valeur est 0 et le type de valeur d'élément est s (chaîne ), Le nombre est 3, la valeur spécifique est "abc", se termine par un point-virgule, et ainsi de suite pour les éléments suivants du tableau.

Jetons un coup d'œil à ce qui se passe si nous utilisons des chaînes comme index d'éléments :

$var = array("index1"=＞"abc", "index2"=＞"def", "index3"=＞"xyz", "index4" = ＞"123");
echo serialize($var);

Sortie :

a:4:{s:6:"index1";s:3:"abc";s:6:"index2";s:3:"def";s:6 : "index3";s:3:"xyz";s:6:"index4";s:3:"123";}

après avoir changé le style de tableau :

a:4 :
{
s:6:"index1";s:3:"abc";
s:6:"index2";s:3:"def";
s:6:"index3";s:3:"xyz";
s:6:"index4";s:3:"123";
}

En fait, ce n'est pas très différent de ce qui précède, sauf que l'index de départ prend la forme de chaînes de sauvegarde. Par exemple, le premier élément : s:6: "index1"; le premier élément est l'index Valeur : s:6:"index1" ; s est le type, 6 est la longueur de la chaîne d'index et "index1" est la valeur de l'index. Le s:3:"abc"; suivant est la valeur de l'élément. C'est facile à comprendre, je n'entrerai donc pas dans les détails.

De ce qui précède, nous avons une compréhension générale de la sérialisation des types de données de base. En fait, nous pouvons construire notre propre fonction de sérialisation, ou étendre cette perspective et développer notre propre programme de sérialisation pour faciliter notre échange de variables.

Bien sûr, en fait, nous pouvons également utiliser cette fonction pour sérialiser un tableau ou toute autre variable dans une chaîne, puis utiliser la fonction curl pour simuler la fonction GET/POST afin d'obtenir des données du serveur distant sans que l'utilisateur n'effectue d'actions.

2. Sérialisation d'objets

La sérialisation d'objets est également une fonction relativement courante. Elle peut sérialiser un objet et le transformer en une chaîne, qui peut être enregistrée ou transmise.

Regardons d'abord un exemple :

la classe TestClass
{
var $a;
var $b;

fonction TestClass()
{
$this->a = "Ceci est un" ;
$this->b = "C'est b";
}

fonction getA()
{
retourner $this->a;
}

fonction getB()
{
retourner $this->b;
}
}

$obj = nouvelle ClasseTest ;
$str = sérialiser($obj);
echo $str;

Résultat de sortie :

O:9:"TestClass":2:{s:1:"a";s:9:"Ceci est un";s:1:"b";s:9:"Ceci is b";}

Analysons la chaîne après sérialisation d'un objet.

O:9:"ClasseTest":2 :
{
s:1:"un";s:9:"Ceci est un";
s:1:"b";s:9:"C'est b";
}

Regardez d'abord le contenu de l'objet lui-même : O:9:"TestClass":2:O indique qu'il s'agit d'un type d'objet (objet), puis 9 représente le nom de l'objet et 2 représente le nombre d'objets. propriété. En regardant le contenu des deux attributs :

s:1:"a";s:9:"This is a"; En fait, c'est similaire au contenu du premier élément : s:1:"a. "; est le nom de l'attribut de description. , le deuxième élément s:9 : "Ceci est un" ; décrit la valeur de l'attribut. Les propriétés suivantes sont similaires.

Permettez-moi d'abord de parler d'une application de sérialisation d'objets. Le contenu suivant provient du manuel PHP et le texte original n'a pas été modifié.

Serialize() renvoie une chaîne contenant une représentation de flux d'octets de toute valeur pouvant être stockée en PHP. unserialize() peut utiliser cette chaîne pour reconstruire la valeur originale de la variable. L'enregistrement d'un objet à l'aide de la sérialisation enregistre toutes les variables de l'objet. Les fonctions de l'objet ne sont pas enregistrées, seulement le nom de la classe.

Pour pouvoir désérialiser() un objet, la classe de l'objet doit être définie. Autrement dit, si vous sérialisez l'objet $a de classe A dans page1.php, vous obtiendrez une chaîne pointant vers la classe A et contenant les valeurs de toutes les variables dans $a. Si vous souhaitez le désérialiser dans page2.php et reconstruire l'objet $a de la classe A, la définition de la classe A doit apparaître dans page2.php. Ceci peut être réalisé, par exemple, en plaçant la définition de la classe A dans un fichier d'inclusion et en incluant ce fichier à la fois dans page1.php et page2.php.

<?php
//classa.inc :
classe A
{
var $un = 1;

fonction show_one()
{
echo $this->one;
}
}

// page1.php :
include("classa.inc");

$a = nouveau A;
$s = sérialiser ($a);
// Stockez $s quelque part pour que page2.php puisse le trouver
$fp = fopen("magasin", "w");
fputs($fp, $s);
fclose($fp);

// page2.php :
// Cette ligne est nécessaire pour la désérialisation normale
include("classa.inc");

$s = implode("", @file("store"));
$a = unserialize($s);

// Vous pouvez maintenant utiliser la fonction show_one() de l'objet $a
$a->show_one();
?>

Si vous utilisez une session et utilisez session_register() pour enregistrer des objets, ces objets seront automatiquement sérialisés à la fin de chaque page PHP, et automatiquement désérialisés dans chaque page suivante. Fondamentalement, cela signifie qu'une fois que ces objets font partie d'une session, ils peuvent apparaître sur n'importe quelle page.

Il est fortement recommandé que toutes les pages incluent des définitions de classe pour ces objets enregistrés, même si ces classes ne sont pas utilisées dans toutes les pages. Si cela n'est pas fait et qu'un objet est désérialisé mais que sa classe n'est pas définie, il perdra sa classe associée et deviendra un objet de stdClass sans aucune fonction disponible, ce qui est très inutile.

Ainsi, si $a fait partie de la session en exécutant session_register("a") dans l'exemple ci-dessus, le fichier classa.inc doit être inclus dans toutes les pages, pas seulement page1.php et page2.php.

Bien entendu, les objets sérialisés peuvent être appliqués à de nombreux endroits. Bien sûr, la sérialisation est gérée différemment dans PHP 5. Jetons un coup d'œil à ce que dit le manuel :

serialize() vérifie s'il existe une fonction avec le nom magique __sleep dans la classe. Si tel est le cas, la fonction s'exécutera avant toute sérialisation. Il efface l'objet et doit renvoyer un tableau contenant les noms de toutes les variables de l'objet qui doivent être sérialisées.

Le but de l'utilisation de __sleep est de fermer toutes les connexions à la base de données que l'objet peut avoir, de soumettre des données en attente ou d'effectuer des tâches de nettoyage similaires. De plus, cette fonction est également utile si vous disposez d'objets très volumineux qui n'ont pas besoin d'être stockés complètement.

À l’inverse, unserialize() vérifie l’existence d’une fonction portant le nom magique __wakeup. Cette fonction peut reconstruire toutes les ressources que l'objet peut avoir, s'il est présent.

Le but de l'utilisation de __wakeup est de rétablir toutes les connexions à la base de données qui pourraient avoir été perdues lors de la sérialisation et de gérer d'autres tâches de réinitialisation.