A partir de PHP 5.2, existen dos nuevas funciones llamadas
json_encode y
json_decode que permiten serializar variables con contenidos variables en php. La implementación está hecha en C, así que su rendimiento es bastante conveniente.
JSON (JavaScript Object Notation) es un formato de intercambio de datos. Y tiene la peculiaridad de que la cadena generada es siempre una expresión válida en javascript. Además la cadena resultante es muy compacta, y se puede modificar con facilidad. En la actualidad ya es un formato ampliamente usado y soportado de manera oficial en muchos lenguajes de programación.
La forma más eficiente y cómoda que había hasta la fecha para serializar variables, era la opción:
serialize/
unserialize.
A partir de PHP 5.2, con la nueva alternativa de json_*, está la duda: ¿siendo más compatible con otros lenguajes y además compacta y flexible, podría sustituir a la original?
La respuesta es: no siempre.
json_decode puede ser mucho más lento que unserialize en muchos casos.
Mientras que serialize almacena las longitudes de las cadenas, json_encode tiene que recorrerlas para conocer su longitud. Además la entrada de json_encode tiene que ser utf-8 y el parseo es bastante más lento.
He hecho un pequeño programa para probar el rendimiento. El tamaño de la cadena generada por json siempre es más pequeño. El json se codifica mas rápido para arrays y números. Pero para cadenas, el rendimiento empeora mucho.
function & generate_random_var( $maxdepth = 5, $base = 10, $strlen = 999 ) {
$r = array();
for ($n = 0, $l = mt_rand($base / 2, $base); $n < $l; $n++) {
switch (mt_rand(0, 4)) {
case 0: $r[] = mt_rand(); break;
case 1: $r[] = str_repeat( '*', $strlen ); break;
case 2: $r[] = false; break;
case 3: $r[] = (object)array(1 => 2); break;
case 4: if ( $maxdepth > 0 ) $r[] = generate_random_var( mt_rand( 0, $maxdepth - 1), $base, $strlen ); break;
}
}
return $r;
}
mt_srand( 0 );
foreach (array(
array(4, 30, 9),
array(10, 30, 1),
array(0, 8000, 1),
array(0, 8000, 99),
array(0, 8000, 999),
array(4, 30, 99),
array(4, 30, 999),
) as $config) {
list($maxdepth, $base, $strlen) = $config;
printf("config(depth=%d, elements=%d, strlen=%d):\n", $maxdepth, $base, $strlen);
$v = generate_random_var($maxdepth, $base, $strlen);
$t = microtime(true);
for ($n = 0; $n < 60; $n++) {
$s = & serialize($v);
unserialize($s);
}
printf(" serialize : time(%.3f), length(%d)\n", $t_serialize = microtime(true) - $t, $l_serialize = strlen($s));
$t = microtime(true);
for ($n = 0; $n < 60; $n++) {
$s = & json_encode($v);
json_decode($s);
}
printf(" json : time(%.3f), length(%d)\n", $t_json = microtime(true) - $t, $l_json = strlen($s));
printf(" diff: time(%d%%) | strlen(%d%%)\n", $t_json * 100 / $t_serialize, $l_json * 100 / $l_serialize);
printf("\n");
}
?>
Resultados:
config(depth=4, elements=30, strlen=9):
serialize : time(0.236), length(42431)
json : time(0.171), length(19639)
diff: time(72%) | strlen(46%)
config(depth=10, elements=30, strlen=1):
serialize : time(0.767), length(116820)
json : time(0.502), length(47610)
diff: time(65%) | strlen(40%)
config(depth=0, elements=8000, strlen=1):
serialize : time(0.445), length(71185)
json : time(0.277), length(25943)
diff: time(62%) | strlen(36%)
config(depth=0, elements=8000, strlen=99):
serialize : time(0.784), length(289298)
json : time(0.962), length(206929)
diff: time(122%) | strlen(71%)
config(depth=0, elements=8000, strlen=999):
serialize : time(1.371), length(1665092)
json : time(5.630), length(1581304)
diff: time(410%) | strlen(94%)
config(depth=4, elements=30, strlen=99):
serialize : time(0.221), length(73598)
json : time(0.265), length(54542)
diff: time(119%) | strlen(74%)
config(depth=4, elements=30, strlen=999):
serialize : time(0.018), length(30238)
json : time(0.095), length(28817)
diff: time(521%) | strlen(95%)
Conclusión:
- Para datos que se deben serializar pero que únicamente van a ser accedidos por php, casi siempre será mejor usar la opción de serialize. Especialmente con variables que contendrán cadenas muy largas.
- Si se requiere acceder a esos datos desde otros lenguajes o modificarlos manualmente, json es una buena opción. Si se van a serializar objetos complejos, json será siempre más compacto. Si la variable contendrá una cadena, o indirectamente alguna cadena, como elemento o clave de un array y son cadenas muy largas, json está penalizado.
