serialize

(PHP 4, PHP 5, PHP 7, PHP 8)

serialize — Erzeugt eine speicherbare Repräsentation eines Wertes

Beschreibung

serialize(mixed $value): string

Erzeugt eine speicherbare Repräsentation eines Wertes.

Diese Funktion dient der Speicherung oder Übergabe von PHP-Werten, ohne dass diese ihren Typ oder ihre Struktur verlieren.

Um eine serialisierte Zeichenkette wieder als PHP-Wert verfügbar zu machen, verwenden Sie unserialize().

Parameter-Liste

value

Der zu serialisierende Wert. serialize() kann mit allen Typen umgehen, ausgenommen mit dem resource-Typ und einigen object-Typen (siehe Hinweis weiter unten). Sie können sogar Arrays serialisieren, die Referenzen auf sich selbst enthalten. Zirkelbezüge innerhalb des Arrays/Objekts, das Sie serialisieren, werden ebenfalls gespeichert. Alle anderen Referenzen gehen verloren.

Wenn Objekte serialisiert werden, versucht PHP die Methode __serialize() oder __sleep vor der Serialisierung aufzurufen. Dies erlaubt einem Objekt z. B. letzte "Aufräumaktionen", bevor es serialisiert wird. Ebenso wird die Methode __unserialize() oder __wakeup aufgerufen, wenn das Objekt mittels unserialize() wiederhergestellt wird.

Hinweis:
Den Namen der privaten Eigenschaften eines Objekts wird der Klassenname vorangestellt; den Namen geschützter Eigenschaften wird ein '*' vorangestellt. Diese vorangestellten Werte werden von Nullbytes umschlossen.

Rückgabewerte

Gibt einen String zurück, der eine Byte-Stream-Repräsentation von value enthält, die beliebig gespeichert werden kann.

Es ist zu beachten, dass dies ein Binärstring ist, der Null-Bytes enthalten kann, und als solcher gespeichert und behandelt werden muss. Zum Beispiel sollte die Ausgabe von serialize() grundsätzlich in einem BLOB- statt einem CHAR- oder TEXT-Feld in einer Datenbank gespeichert werden.

Beispiele

Beispiel #1 serialize()-Beispiel

<?php
// $session_data enthält ein mehrdimensionales Array mit Session-Informationen
// des aktuellen Benutzers. Wir benutzen serialize() um diese Infos am Ende
// der Anfrage in eine Datenbank zu speichern.

$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, array_reverse($sqldata))) {
        /* Irgendwas ging schief ... */
    }
}
?>

Anmerkungen

Hinweis:
Es ist zu beachten, dass viele eingebaute PHP Objekte nicht serialisiert werden können. Diejenigen mit dieser Eigenschaft implementieren entweder das Serializable-Interface oder die magischen __serialize()/__unserialize()- oder __sleep/__wakeup-Methoden. Wenn eine eingebaute Klasse nicht mindestens eine dieser Voraussetzungen erfüllt, kann sie nicht verlässlich serialisiert werden.

Es gibt einige historische Ausnahmen dieser Regel, bei denen interne Objekte serialisiert werden konnten, ohne das Interface zu implementieren oder die Methoden offenzulegen.

Warnung

Wenn serialize() Objekte serialisiert, ist zwecks größtmöglicher Kompatibilität der führende Backslash nicht im Namen von Klassen in Namensräumen enthalten.

Siehe auch

unserialize() - Erzeugt aus einem gespeicherten Datenformat einen Wert in PHP
var_export() - Liefert den Inhalt einer Variablen als parsbaren PHP-Code
json_encode() - Liefert die JSON-Darstellung eines Wertes
Objekte serialisieren
__sleep
__wakeup
__serialize()
__unserialize()

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 7 notes

down

357

egingell at sisna dot com ¶

18 years ago

<?
/*
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.
*/
?>

down

279

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.

down

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"

down

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.

down

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).

down

frost at easycast dot ru ¶

11 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' 
?>

down

Andrew B ¶

12 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>";

?>

＋add a note