Veja neste artigo um conceito de serialização e como usa-la com PHP através de um exemplo simples e prático. Basicamente é o processo de salvar dados de um objeto, mas não obrigatoriamente um objeto, em algum lugar ou transmiti-lo pela rede, num formato binário eu de texto. Sendo que esses bytes poderão ser utilizados para reconstruir perfeitamente o que foi serializado.

1. Atenção, este é um post gratuito publicado no site da Devmedia e publicado no Slideshare
na conta da própria Devmedia. Sua republicação não é autorizada.
Para ler este e outros artigos de seu interesse, acesse http://www.devmedia.com.br
Serialização de dados em PHP
Veja neste artigo um conceito de serialização e como usa-la com PHP através de um exemplo simples e
prático. Basicamente é o processo de salvar dados de um objeto, mas não obrigatoriamente um objeto,
em algum lugar ou transmiti-lo pela rede, num formato binário eu de texto. Sendo que esses bytes
poderão ser utilizados para reconstruir perfeitamente o que foi serializado.
O que é Serialização de dados?
Basicamente é o processo de salvar dados de um objeto, mas não obrigatoriamente um objeto, em algum lugar
ou transmiti-lo pela rede, num formato binário eu de texto. Sendo que esses bytes poderão ser utilizados para
reconstruir perfeitamente o que foi serializado.
Um exemplo muito claro disso, que muitos usam, pois é muito bom, é que quando você está jogando um
joginho e precisa fazer uma parada, mas não quer perder o estado do jogo, o que você faz? Salva (“serializa”)
em algum lugar para depois carregar (“deserializa”) o jogo e tudo volta de onde parou.
Serializando no PHP
Primeiro quero dizer que a Serialização não é coisa nova não e muito menos exclusivo do PHP.
No PHP ela é feita de forma extremamente simples, usamos o método serialize() que recebe o que deve ser
serializado. Vejam:
Listagem 01: Serializando
1<?php
2$array = array( "a","b","c","d","e" );
3$serializado = serialize($array);
4echo $serializado;
5//resultado a:5:{i:0;s:1:"a";i:1;s:1:"b";i:2;s:1:"c";i:3;s:1:"d";i:4;s:1:"e";}
?>
6
Lembrando que não podemos serializar recursos, ou seja, arquivos, conexão como banco de dados, etc. E que
tudo que você coloca numa variável de sessão é serializado automaticamente.

2. Restaurando os Dados
Para restaurar os dados serializados usamos a função unserialize() que recebe o dado serializado, interpreta a
string e traz de volta o que foi serializado. Vejam como ficaria para o exemplo da Listagem 01:
Listagem 02: Restaurando os dados
1
<?php
2
$serialziado = 'a:5:{i:0;s:1:"a";i:1;s:1:"b";i:2;s:1:"c";i:3;s:1:"d";i:4;s:1:"e";}';
3
$array = unserialize($serialziado);
4
var_dump($array);
5 /*
6 array(5) {
7 [0]=> string(1) "a"
8 [1]=> string(1) "b"
9 [2]=> string(1) "c"
[3]=> string(1) "d"
10
[4]=> string(1) "e"
11
}
12
*/
13
?>
14
Caso a string passada não seja uma string serializada o método retornará falsee um E_NOTICE.
Serialização de objetos
Bem, nós já serializamos e restauramos um array e com objetos o processo é exatamente o mesmo porem
pode fazer uso de dois métodos muito úteis, __sleep() e __wakeup().
o __sleep(): é invocado quando um objeto é serializado, ou seja, no momento da execução de serialize(),
usamos ele para informar quais dados devem ser serializados, para isso devemos retornar um array com
o nome dos campos que devem ser serializados. Lembrando que ele será executado tanto quando
usamos serialize() diretamente ou quando enviamos uma variável para a sessão.
o __wakeup(): faz o contrario de __sleep(), ele é invocado quando estamos restaurando um objeto por
meio de unserialize() ou quando chamamos uma variável de sessão. Usamos para setar valores padrões
para quando restauramos os dados.
Vejamos na Listagem 03 o uso desses dois métodos construindo uma classe Jogador.
Listagem 03: Implementando __sleep() e __wakeup()

3. 1
2 <?php
//arquivo jogador.php
3
class Jogador {
4
private $nome;
5
private $hp;
6
private $score;
7
public function __construct($nome){
8 $this->nome = $nome;
9 $this->hp = 100;
10 $this->score = 0;
11 }
12 /* get's e set's aqui */
13 public function __sleep(){
return array(
14
"nome","score"
15
);
16
}
17
public function __wakeup(){
18
$this->hp = 100;
19
}
20}
21?>
22
Dissemos aqui ao PHP para serializar apenas o nome e o score do jogador e que quando restaurarmos o hp
deve ser igual a 100.
Salvando e Lendo de arquivos
Uma forma de persistir os dados serializados é salvar em um arquivo para isso podemos usar
file_put_contents() que recebe o nome do arquivo e o conteúdo e então a partir de um arquivo gravado
podemos lê-lo, com file_get_contents(), e restaurar os dados. Vamos aproveitar a classe criada na Listagem 03
para demonstrar a persistência e leitura em arquivo na Listagem 04.
Listagem 04: Salvando e lendo dados em arquivo

4. 1
<?php
2
//serializaFile.php
3
include_once 'jogador.php';
4
$jogador = new Jogador("Allan");
5
$jogador->setHp(1);
6
$jogador->setScore(1500);
7 $serializado = serialize($jogador);
8 file_put_contents("jogo.save",$serializado);
9 echo ("jogo salvo!");
10?>
<?php
11
//restauraFile.php
12
include 'jogador.php';
13
$dados = file_get_contents("jogo.save");
14
$jogador = unserialize($dados);
15
echo " nome ".$jogador->getNome()." score ".$jogador->getScore()." hp ".$jogador->ge
16?>
17
O que é feito aqui é muito simples, em serializaFile.php criamos um novo jogador e setamos alguns valores
para ele e salvamos no arquivo jogo.save enquanto em restauraFile.php realizamos a leitura do arquivo e
restauramos o objeto serializado.
Bem pessoal fico por aqui espero que tenham gostado, cometem, compartilhem e até a próxima.
Leia mais em: Serialização de dados em PHP http://www.devmedia.com.br/serializacao-de-dados-
em-php/25224#ixzz25gtqLqr0