<?
/*
Anatomy of a serialize()'ed value:
String
s:size:value;
Integer
i:value;
Boolean
b:value; (does not store "true" or "false", does store '1' or '0')
Null
N;
Array
a:size:{key definition;value definition;(repeated per element)}
Object
O:strlen(object name):object name:object size:{s:strlen(property name):property name:property definition;(repeated per property)}
String values are always in double quotes
Array keys are always integers or strings
"null => 'value'" equates to 's:0:"";s:5:"value";',
"true => 'value'" equates to 'i:1;s:5:"value";',
"false => 'value'" equates to 'i:0;s:5:"value";',
"array(whatever the contents) => 'value'" equates to an "illegal offset type" warning because you can't use an
array as a key; however, if you use a variable containing an array as a key, it will equate to 's:5:"Array";s:5:"value";',
and
attempting to use an object as a key will result in the same behavior as using an array will.
*/
?>
serialize
(PHP 4, PHP 5, PHP 7)
serialize — Generează o reprezentare ce poate fi stocată a unei valori
Descrierea
Generează o reprezentare ce poate fi stocată a unei valori.
Aceasta este utilă pentru păstrarea sau interpretarea valorilor PHP fără a pierde tipul sau structura lor.
Pentru a transforma invers un string serializat într-o valoare PHP, utilizați unserialize().
Parametri
-
value -
Valoarea ce trebuie serializată. serialize() prelucrează toate tipurile, cu excepția resource și unele object (a se vedea nota de mai jos). Puteți chiar aplica serialize() asupra tablourilor ce conțin referințe la sine însele. Referințele circulare din interiorul tabloului/obiectului pe care îl serializați de asemenea vor fi stocate. Orice altă referință va fi pierdută.
La serializarea obiectelor, PHP va încerca să apeleze una din funcțiile-membru __serialize() sau __sleep() înainte de serializare. Aceasta se efectuează pentru a-i permite obiectului să efectueze orice curățiri, etc. înainte de a fi serializat. La fel, când obiectul este restabilit cu ajutorul unserialize() funcția-membru __unserialize() sau __wakeup() este apelată.
Notă:
Membrii privați ai obiectului au denumirea clasei prefixată la denumirea membrului; membrii privați au un '*' prefixat la denumirea membrului. Aceste valori prefixate au câte un octet nul din ambele părți.
Valorile întoarse
Întoarce un string conținând reprezentarea value sub
formă de byte-stream care poate fi stocată oriunde.
Atrageți atenția că acesta este un șir de caractere binar, ce poate include octeți null, de aceea trebuie stocat și manipulat ca atare. De exemplu, rezultatele funcției serialize() la general ar trebui stocate într-un câmp BLOB într-o bază de date, și nu într-un câmp CHAR sau TEXT.
Exemple
Example #1 Exemplu serialize()
<?php
// $session_data conține un tablou multi-dimensional cu informație despre
// sesiune pentru utilizatorul curent. Vom utiliza serialize() pentru a
// stoca această informație într-o bază de date după încheierea interpelării.
$conn = odbc_connect("webdb", "php", "chicken");
$stmt = odbc_prepare($conn,
"UPDATE sessions SET data = ? WHERE id = ?");
$sqldata = array (serialize($session_data), $_SERVER['PHP_AUTH_USER']);
if (!odbc_execute($stmt, $sqldata)) {
$stmt = odbc_prepare($conn,
"INSERT INTO sessions (id, data) VALUES(?, ?)");
if (!odbc_execute($stmt, $sqldata)) {
/* Ceva nu este în regulă.. */
}
}
?>
Note
Notă:
Atrageți atenția că multe obiecte PHP încorporate nu pot fi serializate. Însă cele ce permit acest lucru implementează interfața Serializable sau metodele magice __serialize()/__unserialize() sau __sleep()/__wakeup(). Dacă o clasă internă nu îndeplinește cel puțin una dintre aceste cerințe, ea nu poate fi serializată cu siguranță.
Există unele excepții istorice de la această regulă, când unele obiecte interne pot fi serializate fără a implementa interfața sau a expune metodele. Cel mai elocvent exemplu este ArrayObject în versiunile anterioare PHP 5.2.0.
Avertizare
Când serialize() serializează obiecte, primul backslash din denumirea clasei, în cazul claselor cu spații de nume, este exclus pentru a maximiza compatibilitatea.
A se vedea și
- unserialize() - Creează o valoare PHP dintr-o reprezentare stocată
- var_export() - Afișează sau întoarce o reprezentare string, ce poate fi prelucrată, a unei variabile
- json_encode() - Întoarce o reprezentare JSON pentru valoarea dată
- Serializarea Obiectelor
- __sleep()
- __wakeup()
- __serialize()
- __unserialize()
add a note
User Contributed Notes 7 notes
egingell at sisna dot com ¶
17 years ago
Anonymous ¶
12 years ago
Please! please! please! DO NOT serialize data and place it into your database. Serialize can be used that way, but that's missing the point of a relational database and the datatypes inherent in your database engine. Doing this makes data in your database non-portable, difficult to read, and can complicate queries. If you want your application to be portable to other languages, like let's say you find that you want to use Java for some portion of your app that it makes sense to use Java in, serialization will become a pain in the buttocks. You should always be able to query and modify data in the database without using a third party intermediary tool to manipulate data to be inserted.
I've encountered this too many times in my career, it makes for difficult to maintain code, code with portability issues, and data that is it more difficult to migrate to other RDMS systems, new schema, etc. It also has the added disadvantage of making it messy to search your database based on one of the fields that you've serialized.
That's not to say serialize() is useless. It's not... A good place to use it may be a cache file that contains the result of a data intensive operation, for instance. There are tons of others... Just don't abuse serialize because the next guy who comes along will have a maintenance or migration nightmare.
MC_Gurk at gmx dot net ¶
18 years ago
If you are going to serialie an object which contains references to other objects you want to serialize some time later, these references will be lost when the object is unserialized.
The references can only be kept if all of your objects are serialized at once.
That means:
$a = new ClassA();
$b = new ClassB($a); //$b containes a reference to $a;
$s1=serialize($a);
$s2=serialize($b);
$a=unserialize($s1);
$b=unserialize($s2);
now b references to an object of ClassA which is not $a. $a is another object of Class A.
use this:
$buf[0]=$a;
$buf[1]=$b;
$s=serialize($buf);
$buf=unserialize($s);
$a=$buf[0];
$b=$buf[1];
all references are intact.
nh at ngin dot de ¶
11 years ago
Serializing floating point numbers leads to weird precision offset errors:
<?php
echo round(96.670000000000002, 2);
// 96.67
echo serialize(round(96.670000000000002, 2));
// d:96.670000000000002;
echo serialize(96.67);
// d:96.670000000000002;
?>
Not only is this wrong, but it adds a lot of unnecessary bulk to serialized data. Probably better to use json_encode() instead (which apparently is faster than serialize(), anyway).
frost at easycast dot ru ¶
10 years ago
Closures cannot be serialized:
<?php
$func = function () {echo 'hello!';};
$func(); // prints "hello!"
$result = serialize($func); // Fatal error: Uncaught exception 'Exception' with message 'Serialization of 'Closure' is not allowed'
?>
Andrew B ¶
11 years ago
When you serialize an array the internal pointer will not be preserved. Apparently this is the expected behavior but was a bit of a gotcha moment for me. Copy and paste example below.
<?php
//Internal Pointer will be 2 once variables have been assigned.
$array = array();
$array[] = 1;
$array[] = 2;
$array[] = 3;
//Unset variables. Internal pointer will still be at 2.
unset($array[0]);
unset($array[1]);
unset($array[2]);
//Serialize
$serializeArray = serialize($array);
//Unserialize
$array = unserialize($serializeArray);
//Add a new element to the array
//If the internal pointer was preserved, the new array key should be 3.
//Instead the internal pointer has been reset, and the new array key is 0.
$array[] = 4;
//Expected Key - 3
//Actual Key - 0
echo "<pre>" , print_r($array, 1) , "</pre>";
?>
mark at bvits dot co dot uk ¶
1 year ago
There is a type not mentioned in the user notes so far, 'E'. This is the newer Enum class that can be utilised:
login_security|E:25:"Permission:manageClient"
