ArrayAccess::offsetUnset
Serializing child and parent classes:
<?php
class MyClass implements Serializable {
private $data;
public function __construct($data) {
$this->data = $data;
}
public function getData() {
return $this->data;
}
public function serialize() {
echo "Serializing MyClass...\n";
return serialize($this->data);
}
public function unserialize($data) {
echo "Unserializing MyClass...\n";
$this->data = unserialize($data);
}
}
class MyChildClass extends MyClass {
private $id;
private $name;
public function __construct($id, $name, $data) {
parent::__construct($data);
$this->id = $id;
$this->name = $name;
}
public function serialize() {
echo "Serializing MyChildClass...\n";
return serialize(
array(
'id' => $this->id,
'name' => $this->name,
'parentData' => parent::serialize()
)
);
}
public function unserialize($data) {
echo "Unserializing MyChildClass...\n";
$data = unserialize($data);
$this->id = $data['id'];
$this->name = $data['name'];
parent::unserialize($data['parentData']);
}
public function getId() {
return $this->id;
}
public function getName() {
return $this->name;
}
}
$obj = new MyChildClass(15, 'My class name', 'My data');
$serial = serialize($obj);
$newObject = unserialize($serial);
echo $newObject->getId() . PHP_EOL;
echo $newObject->getName() . PHP_EOL;
echo $newObject->getData() . PHP_EOL;
?>
This will output:
Serializing MyChildClass...
Serializing MyClass...
Unserializing MyChildClass...
Unserializing MyClass...
15
My class name
My data
The Serializable interface
(PHP 5 >= 5.1.0)
Introdução
Interface for customized serializing.
Classes that implement this interface no longer support __sleep() and __wakeup(). The method serialize is called whenever an instance needs to be serialized. This does not invoke __destruct() or has any other side effect unless programmed inside the method. When the data is unserialized the class is known and the appropriate unserialize() method is called as a constructor instead of calling __construct(). If you need to execute the standard constructor you may do so in the method.
Resumo da Interface
Serializable
{
/* Métodos */
}Exemplo #1 Basic usage
<?php
class obj implements Serializable {
private $data;
public function __construct() {
$this->data = "My private data";
}
public function serialize() {
return serialize($this->data);
}
public function unserialize($data) {
$this->data = unserialize($data);
}
public function getData() {
return $this->data;
}
}
$obj = new obj;
$ser = serialize($obj);
var_dump($ser);
$newobj = unserialize($ser);
var_dump($newobj->getData());
?>
O exemplo acima irá imprimir algo similar à:
string(38) "C:3:"obj":23:{s:15:"My private data";}"
string(15) "My private data"
Índice
- Serializable::serialize — String representation of object
- Serializable::unserialize — Constructs the object
add a note
User Contributed Notes
Serializable - [3 notes]
marcos dot gottardi at folha dot REM0VE-THIS dot com dot br ¶
1 year ago
Anonymous ¶
1 year ago
You cannot throw an exception inside the serialize() method. This will cause PHP to complain that you are not returning a string or NULL.
The best way to prevent the serialization of an object is to throw an Exception in the __sleep() method:
<?php
class Obj {
public function __sleep() {
throw new BadMethodCallException('You cannot serialize this object.');
}
}
?>
Anonymous ¶
1 year ago
You can prevent an object getting unserialized by returning NULL. Instead of a serialized object, PHP will return the serialized form of NULL:
<?php
class testNull implements Serializable {
public function serialize() {
return NULL;
}
public function unserialize($data) {
}
}
$obj = new testNull;
$string = serialize($obj);
echo $string; // "N;"
?>
That's perhaps better than throwing exceptions inside of the serialize function if you want to prevent serialization of certain objects.