PHP 8.3.6 Released!

serialize

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

serializeGenera una representación apta para el almacenamiento de un valor

Descripción

serialize(mixed $value): string

Genera una representación almacenable de un valor.

Esto es útil para el almacenamiento de valores en PHP sin perder su tipo y estructura.

Para recuperar el valor PHP a partir de la cadena seriada, utilice unserialize().

Parámetros

value

El valor a ser serializado. serialize() maneja todos los tipos, excepto el tipo resource. Puede incluso usar serialize() sobre arrays que contienen referencias a ellos mismos. Las referencias circulares encontradas en el array/objeto que procede a serializar también serán almacenadas. Cualquier otra referencia se perderá.

Cuando se trata de objetos, PHP intentará llamar a la función miembro __sleep() antes de la serialización. Esto permite que el objeto efectúe limpiezas de último minuto, etc. antes de ser serializado. Del mismo modo, cuando el objeto es recuperado usando unserialize(), la función miembro __wakeup() es llamada.

Nota:

Los miembros privados del objeto tienen el nombre de la clase al comienzo de su nombre; los miembros protegidos tienen un '*' al comienzo de su nombre. estos valores antepuestos tienen bytes nulos a ambos lados.

Valores devueltos

Devuelve una cadena que contiene una representación de flujo de bytes del value que puede ser almacenada en cualquier parte.

Observe que esto es una cadena binaria que puede incluir bytes nulos, y necesita ser almacenada y manipulada como tal. Por ejemplo, la salida de serialize() debe ser generalmente almacenada en un campo de tipo BLOB en la base de datos, en vez de en campos de tipo CHAR o TEXT.

Ejemplos

Ejemplo #1 Ejemplo serialize()

<?php
// $datos_sesion contiene un array multi-dimensional con
// información del usuario actual. Usamos serialize() para
// almacenarla en una base de datos al final de la petición.

$con = odbc_connect("bd_web", "php", "gallina");
$sent = odbc_prepare($con,
"UPDATE sesiones SET datos = ? WHERE id = ?");
$datos_sql = array (serialize($datos_sesion), $_SERVER['PHP_AUTH_USER']);

if (!
odbc_execute($sent, &$datos_sql)) {
$sent = odbc_prepare($con,
"INSERT INTO sesiones (id, datos) VALUES(?, ?)");
if (!
odbc_execute($sent, &$datos_sql)) {
/* Algo ha fallado.. */
}
}
?>

Notas

Nota:

Tenga en cuenta que muchos objetos integrados de PHP no se pueden serializar. Sin embargo, aquellos con esta habilidad o implementan la interfaz Serializable o los métodos mágicos __sleep() y __wakeup(). Si una clase interna no cumple cualquiera de esos requisitos, estas seguramente no puedan ser serializadas.

Hay algunas excepciones históricas a la regla anterior, donde algunos objetos internos podrían ser serializados sin implementar la interfaz o la exposición de los métodos. En particular, la clase ArrayObject anterior a PHP 5.2.0.

Advertencia

Cuando serialize() serializa los objetos, la barra inicial no está incluido en el nombre de clase de las clases de espacios de nombres para una máxima compatibilidad.

Ver también

add a note

User Contributed Notes 7 notes

up
352
egingell at sisna dot com
17 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.
*/
?>
up
276
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.
up
20
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.
up
27
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).
up
11
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'
?>
up
7
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>";
?>
up
1
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"
To Top