Hallo guys,

Ik werd vandaag getipt over de Serializable interface, dat die handig zou zijn als je objecten gaat cachen.

Op php.net zie ik dit voorbeeld:

<?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());

?>
Het resultaat op mijn scherm is:


string(38) "C:3:"obj":23:{s:15:"My private data";}"
string(15) "My private data"


Als ik nu de Serializable interface niet implement, en ik de "serialize" en "unserialize" methods verwijder, krijg je dit:

<?php

class obj {
private $data;
public function __construct() {
$this->data = "My private data";
}

public function getData() {
return $this->data;
}
}

$obj = new obj;
$ser = serialize($obj);

var_dump($ser);

$newobj = unserialize($ser);

var_dump($newobj->getData());

?>
Het resultaat op mijn scherm is:


string(53) "O:3:"obj":1:{s:9:"objdata";s:15:"My private data";}"
string(15) "My private data"

Wat is nu eigenlijk het verschil? Ik zie wel dat de 1e regel op mijn scherm korter is in het 1e voorbeeld dan in het 2e voorbeeld.
Ik snap je voorbeeld, maar in een situatie als deze:

<?php
class Foo {

private $data;
private $locked = false;

}
?>
Heeft het dan ook zin om serialize en unserialize te gebruiken? In jouw voorbeeld gaat het om 2 strings en dan begrijp ik wat je bedoelt. Maar hier gaat het om een array ($data). Kun je dan ook zo'n truc doen, of voegt het niks toe?

O:3:"Foo":2:{s:9:"?Foo?data";a:2:{i:0;s:3:"foo";i:1;s:3:"fiz";}s:11:"?Foo?locked";b:0;}
C:3:"Foo":37:{a:2:{i:0;s:3:"foo";i:1;s:3:"fiz";}||0}


Eerste is zoals jij het nu hebt, tweede is met:
<?php
class Foo implements Serializable {

private $data = array('foo', 'fiz');
private $locked = false;

public function serialize()
{
return serialize($this->data).'||'.($this->locked ? 1 : 0);
}

public function unserialize($serialized)
{
list($data, $locked) = explode('||', $serialized, 2);
$this->data = unserialize($data);
$this->locked = (boolean) $locked;
}
}
?>
Ah oké. Dat is inderdaad wel grappig.

Begrijp ik dus goed dat je zo'n constructie vooral gebruikt om ruimte te besparen?

Waarom kies je in je 1e voorbeeld voor %$% als scheidingsteken, en in je 2e voorbeeld voor || ?
>> Begrijp ik dus goed dat je zo'n constructie vooral gebruikt om ruimte te besparen?

Dat is inderdaad wel 1 van de hoofdfeiten voor het gebruik van Serializable. Ruimte en bepalen welke properties elke keer opnieuw moeten geset worden en dus niet gecached of welke properties er wel verstuurd mogen worden naar een 3rd party.

>> Waarom kies je in je 1e voorbeeld voor %$% als scheidingsteken, en in je 2e voorbeeld voor || ?

Beetje willekeurig. Je moet een teken bedenken die niet snel gebruikt kan worden in de properties die je hebt. Iets als %$% zal je niet vaak tegenkomen.
Allright. Ik ga er eens wat mee spelen ;)

Reageren