with - Método preferido para almacenar matrices PHP(json_encode vs serialize)

serialize array php

Question

Necesito almacenar una matriz asociativa multidimensional de datos en un archivo plano para propósitos de almacenamiento en caché. Ocasionalmente, puedo encontrar la necesidad de convertirlo a JSON para usar en mi aplicación web, pero la mayoría de las veces usaré la matriz directamente en PHP.

¿Sería más eficiente almacenar la matriz como JSON o como una matriz serializada de PHP en este archivo de texto? He mirado a mi alrededor y parece que en las versiones más recientes de PHP (5.3), json_decode es en realidad más rápido que unserialize .

Actualmente me inclino por almacenar la matriz como JSON, ya que creo que es más fácil de leer por un humano si es necesario, puede usarse tanto en PHP como en JavaScript con muy poco esfuerzo, y por lo que he leído, incluso podría ser Más rápido para decodificar (aunque no estoy seguro acerca de la codificación).

¿Alguien sabe de alguna trampa? ¿Alguien tiene buenos puntos de referencia para mostrar los beneficios de rendimiento de cualquiera de los métodos?

Answer 1

Acaba de probar la codificación y decodificación serializada y json, más el tamaño que tomará la cadena almacenada.

JSON encoded in 0.067085981369 seconds. Size (1277772)
PHP serialized in 0.12110209465 seconds. Size (1955548)
JSON decode in 0.22470498085 seconds
PHP serialized in 0.211947917938 seconds
json_encode() was roughly 80.52% faster than serialize()
unserialize() was roughly 6.02% faster than json_decode()
JSON string was roughly 53.04% smaller than Serialized string

Podemos concluir que JSON codifica más rápido y da como resultado una cadena más pequeña, pero unserialize es más rápido para decodificar la cadena.

Answer 2

Antes de tomar su decisión final, tenga en cuenta que el formato JSON no es seguro para matrices asociativas; json_decode() devolverá como objetos:

$config = array(
''Frodo'' => ''hobbit'',
''Gimli'' => ''dwarf'',
''Gandalf'' => ''wizard'',
);
print_r($config);
print_r(json_decode(json_encode($config)));

La salida es:

Array
(
[Frodo] => hobbit
[Gimli] => dwarf
[Gandalf] => wizard
)
stdClass Object
(
[Frodo] => hobbit
[Gimli] => dwarf
[Gandalf] => wizard
)

Answer 3

Aumenté la prueba para incluir el rendimiento de deserialización. Aquí están los números que tengo.

Serialize
JSON encoded in 2.5738489627838 seconds
PHP serialized in 5.2861361503601 seconds
Serialize: json_encode() was roughly 105.38% faster than serialize()
Unserialize
JSON decode in 10.915472984314 seconds
PHP unserialized in 7.6223039627075 seconds
Unserialize: unserialize() was roughly 43.20% faster than json_decode()

Así que json parece ser más rápido para la codificación pero lento en la decodificación. Por lo tanto, podría depender de su aplicación y de lo que espera hacer más.

Answer 4

Depende de tus prioridades.

Si el rendimiento es su característica de conducción absoluta, entonces use la más rápida. Solo asegúrese de tener una comprensión completa de las diferencias antes de tomar una decisión

• A diferencia de serialize() , debe agregar un parámetro adicional para mantener los caracteres UTF-8 intactos: json_encode($array, JSON_UNESCAPED_UNICODE) (de lo contrario, convierte los caracteres UTF-8 en secuencias de escape de Unicode).
• JSON no tendrá memoria de lo que era la clase original del objeto (siempre se restauran como instancias de stdClass).
• No puedes aprovechar __sleep() y __wakeup() con JSON
• De forma predeterminada, solo las propiedades públicas se serializan con JSON. (en PHP>=5.4 puede implementar JsonSerializable para cambiar este comportamiento).
• JSON es más portátil

Y probablemente hay algunas otras diferencias que no puedo pensar en este momento.

Una prueba de velocidad simple para comparar los dos

<?php
ini_set(''display_errors'', 1);
error_reporting(E_ALL);
// Make a big, honkin test array
// You may need to adjust this depth to avoid memory limit errors
$testArray = fillArray(0, 5);
// Time json encoding
$start = microtime(true);
json_encode($testArray);
$jsonTime = microtime(true) - $start;
echo "JSON encoded in $jsonTime seconds/n";
// Time serialization
$start = microtime(true);
serialize($testArray);
$serializeTime = microtime(true) - $start;
echo "PHP serialized in $serializeTime seconds/n";
// Compare them
if ($jsonTime < $serializeTime) {
printf("json_encode() was roughly %01.2f%% faster than serialize()/n", ($serializeTime / $jsonTime - 1) * 100);
}
else if ($serializeTime < $jsonTime ) {
printf("serialize() was roughly %01.2f%% faster than json_encode()/n", ($jsonTime / $serializeTime - 1) * 100);
} else {
echo "Impossible!/n";
}
function fillArray( $depth, $max ) {
static $seed;
if (is_null($seed)) {
$seed = array(''a'', 2, ''c'', 4, ''e'', 6, ''g'', 8, ''i'', 10);
}
if ($depth < $max) {
$node = array();
foreach ($seed as $key) {
$node[$key] = fillArray($depth + 1, $max);
}
return $node;
}
return ''empty'';
}

Answer 5

Echa un vistazo a los resultados aquí (perdón por el hack que puso el código PHP en el cuadro de código JS):

http://jsfiddle.net/newms87/h3b0a0ha/embedded/result/

RESULTADOS: serialize() y unserialize() son significativamente más rápidos en PHP 5.4 en arreglos de diferentes tamaños.

Hice un script de prueba en datos del mundo real para comparar json_encode vs serialize y json_decode vs unserialize. La prueba se ejecutó en el sistema de almacenamiento en caché de un sitio de comercio electrónico en producción. Simplemente toma los datos que ya están en el caché, y prueba los tiempos para codificar / decodificar (o serializar / no serializar) todos los datos y los puse en una tabla fácil de ver.

Corrí esto en el servidor de alojamiento compartido PHP 5.4.

Los resultados fueron muy concluyentes de que para estos conjuntos de datos grandes a pequeños, serializar y unserialize fueron los ganadores claros. En particular para mi caso de uso, json_decode y unserialize son los más importantes para el sistema de almacenamiento en caché. Unserialize fue casi un ganador ubicuo aquí. Normalmente era de 2 a 4 veces (a veces 6 o 7 veces) tan rápido como json_decode.

Es interesante notar la diferencia en los resultados de @ peter-bailey.

Aquí está el código PHP utilizado para generar los resultados:

<?php
ini_set(''display_errors'', 1);
error_reporting(E_ALL);
function _count_depth($array)
{
$count = 0;
$max_depth = 0;
foreach ($array as $a) {
if (is_array($a)) {
list($cnt, $depth) = _count_depth($a);
$count += $cnt;
$max_depth = max($max_depth, $depth);
} else {
$count++;
}
}
return array(
$count,
$max_depth + 1,
);
}
function run_test($file)
{
$memory = memory_get_usage();
$test_array = unserialize(file_get_contents($file));
$memory = round((memory_get_usage() - $memory) / 1024, 2);
if (empty($test_array) || !is_array($test_array)) {
return;
}
list($count, $depth) = _count_depth($test_array);
//JSON encode test
$start = microtime(true);
$json_encoded = json_encode($test_array);
$json_encode_time = microtime(true) - $start;
//JSON decode test
$start = microtime(true);
json_decode($json_encoded);
$json_decode_time = microtime(true) - $start;
//serialize test
$start = microtime(true);
$serialized = serialize($test_array);
$serialize_time = microtime(true) - $start;
//unserialize test
$start = microtime(true);
unserialize($serialized);
$unserialize_time = microtime(true) - $start;
return array(
''Name'' => basename($file),
''json_encode() Time (s)'' => $json_encode_time,
''json_decode() Time (s)'' => $json_decode_time,
''serialize() Time (s)'' => $serialize_time,
''unserialize() Time (s)'' => $unserialize_time,
''Elements'' => $count,
''Memory (KB)'' => $memory,
''Max Depth'' => $depth,
''json_encode() Win'' => ($json_encode_time > 0 && $json_encode_time < $serialize_time) ? number_format(($serialize_time / $json_encode_time - 1) * 100, 2) : '''',
''serialize() Win'' => ($serialize_time > 0 && $serialize_time < $json_encode_time) ? number_format(($json_encode_time / $serialize_time - 1) * 100, 2) : '''',
''json_decode() Win'' => ($json_decode_time > 0 && $json_decode_time < $serialize_time) ? number_format(($serialize_time / $json_decode_time - 1) * 100, 2) : '''',
''unserialize() Win'' => ($unserialize_time > 0 && $unserialize_time < $json_decode_time) ? number_format(($json_decode_time / $unserialize_time - 1) * 100, 2) : '''',
);
}
$files = glob(dirname(__FILE__) . ''/system/cache/*'');
$data = array();
foreach ($files as $file) {
if (is_file($file)) {
$result = run_test($file);
if ($result) {
$data[] = $result;
}
}
}
uasort($data, function ($a, $b) {
return $a[''Memory (KB)''] < $b[''Memory (KB)''];
});
$fields = array_keys($data[0]);
?>
<table>
<thead>
<tr>
<?php foreach ($fields as $f) { ?>
<td style="text-align: center; border:1px solid black;padding: 4px 8px;font-weight:bold;font-size:1.1em"><?= $f; ?></td>
<?php } ?>
</tr>
</thead>
<tbody>
<?php foreach ($data as $d) { ?>
<tr>
<?php foreach ($d as $key => $value) { ?>
<?php $is_win = strpos($key, ''Win''); ?>
<?php $color = ($is_win && $value) ? ''color: green;font-weight:bold;'' : ''''; ?>
<td style="text-align: center; vertical-align: middle; padding: 3px 6px; border: 1px solid gray; <?= $color; ?>"><?= $value . (($is_win && $value) ? ''%'' : ''''); ?></td>
<?php } ?>
</tr>
<?php } ?>
</tbody>
</table>

Answer 6

He escrito una entrada de blog sobre este tema: " ¿Almacenar en caché una matriz grande: JSON, serializar o var_export? ". En esta publicación se muestra que serializar es la mejor opción para arreglos de tamaño pequeño a grande. Para arreglos muy grandes (> 70MB) JSON es la mejor opción.

Answer 7

He probado esto muy a fondo en un multi-hash bastante complejo, ligeramente anidado con todo tipo de datos (cadena, NULL, enteros), y serializar / deserializar terminó mucho más rápido que json_encode / json_decode.

La única ventaja que tengo json en mis pruebas es que es más pequeño y compacto.

Esto se hace bajo PHP 5.3.3, déjame saber si quieres más detalles.

Aquí están los resultados de las pruebas y luego el código para producirlos. No puedo proporcionar los datos de la prueba ya que revelaría información que no puedo dejar que salga a la luz.

JSON encoded in 2.23700618744 seconds
PHP serialized in 1.3434419632 seconds
JSON decoded in 4.0405561924 seconds
PHP unserialized in 1.39393305779 seconds
serialized size : 14549
json_encode size : 11520
serialize() was roughly 66.51% faster than json_encode()
unserialize() was roughly 189.87% faster than json_decode()
json_encode() string was roughly 26.29% smaller than serialize()
// Time json encoding
$start = microtime( true );
for($i = 0; $i < 10000; $i++) {
json_encode( $test );
}
$jsonTime = microtime( true ) - $start;
echo "JSON encoded in $jsonTime seconds<br>";
// Time serialization
$start = microtime( true );
for($i = 0; $i < 10000; $i++) {
serialize( $test );
}
$serializeTime = microtime( true ) - $start;
echo "PHP serialized in $serializeTime seconds<br>";
// Time json decoding
$test2 = json_encode( $test );
$start = microtime( true );
for($i = 0; $i < 10000; $i++) {
json_decode( $test2 );
}
$jsonDecodeTime = microtime( true ) - $start;
echo "JSON decoded in $jsonDecodeTime seconds<br>";
// Time deserialization
$test2 = serialize( $test );
$start = microtime( true );
for($i = 0; $i < 10000; $i++) {
unserialize( $test2 );
}
$unserializeTime = microtime( true ) - $start;
echo "PHP unserialized in $unserializeTime seconds<br>";
$jsonSize = strlen(json_encode( $test ));
$phpSize = strlen(serialize( $test ));
echo "<p>serialized size : " . strlen(serialize( $test )) . "<br>";
echo "json_encode size : " . strlen(json_encode( $test )) . "<br></p>";
// Compare them
if ( $jsonTime < $serializeTime )
{
echo "json_encode() was roughly " . number_format( ($serializeTime / $jsonTime - 1 ) * 100, 2 ) . "% faster than serialize()";
}
else if ( $serializeTime < $jsonTime )
{
echo "serialize() was roughly " . number_format( ($jsonTime / $serializeTime - 1 ) * 100, 2 ) . "% faster than json_encode()";
} else {
echo ''Unpossible!'';
}
echo ''<BR>'';
// Compare them
if ( $jsonDecodeTime < $unserializeTime )
{
echo "json_decode() was roughly " . number_format( ($unserializeTime / $jsonDecodeTime - 1 ) * 100, 2 ) . "% faster than unserialize()";
}
else if ( $unserializeTime < $jsonDecodeTime )
{
echo "unserialize() was roughly " . number_format( ($jsonDecodeTime / $unserializeTime - 1 ) * 100, 2 ) . "% faster than json_decode()";
} else {
echo ''Unpossible!'';
}
echo ''<BR>'';
// Compare them
if ( $jsonSize < $phpSize )
{
echo "json_encode() string was roughly " . number_format( ($phpSize / $jsonSize - 1 ) * 100, 2 ) . "% smaller than serialize()";
}
else if ( $phpSize < $jsonSize )
{
echo "serialize() string was roughly " . number_format( ($jsonSize / $phpSize - 1 ) * 100, 2 ) . "% smaller than json_encode()";
} else {
echo ''Unpossible!'';
}

Answer 8

JSON es mejor si desea hacer una copia de seguridad de los datos y restaurarla en una máquina diferente o mediante FTP.

Por ejemplo, con serializar si almacena datos en un servidor Windows, descárguelo a través de FTP y restaure en Linux, ya no podría funcionar debido a la recodificación de caracteres, ya que serializar almacena la longitud de las cadenas y en Unicode. > La transcodificación UTF-8 de un carácter de 1 byte podría tener una longitud de 2 bytes haciendo que el algoritmo se bloquee.

Answer 9

Le sugiero que use Super Cache, que es un mecanismo de caché de archivos que no usa json_encode ni serialize . Es fácil de usar y realmente rápido en comparación con otros mecanismos de caché PHP.

https://packagist.org/packages/smart-php/super-cache

Ex:

<?php
require __DIR__.''/vendor/autoload.php'';
use SuperCache/SuperCache as sCache;
//Saving cache value with a key
// sCache::cache(''<key>'')->set(''<value>'');
sCache::cache(''myKey'')->set(''Key_value'');
//Retrieving cache value with a key
echo sCache::cache(''myKey'')->get();
?>

Answer 10

Muy buen tema y después de leer las pocas respuestas, quiero compartir mis experimentos sobre el tema.

Tengo un caso de uso en el que es necesario consultar una tabla "enorme" casi cada vez que hablo con la base de datos (no pregunte por qué, solo un hecho). El sistema de almacenamiento en caché de la base de datos no es apropiado ya que no almacenará en caché las diferentes solicitudes, así que pensé en los sistemas de almacenamiento en caché de php.

Intenté apcu pero no se ajustaba a las necesidades, la memoria no es lo suficientemente confiable en este caso. El siguiente paso fue almacenar en caché en un archivo con serialización.

La tabla tiene 14355 entradas con 18 columnas, esas son mis pruebas y estadísticas sobre la lectura del caché serializado:

JSON:

Como todos ustedes dijeron, el mayor inconveniente con json_encode / json_decode es que transforma todo en una instancia de StdClass (u Objeto). Si necesita realizar un bucle, transformarlo en una matriz es lo que probablemente hará, y sí, está aumentando el tiempo de transformación

tiempo promedio: 780.2 ms; uso de memoria: 41.5MB; tamaño de archivo de caché: 3.8MB

Msgpack

@hutch menciona msgpack . Bonito sitio web. Vamos a intentarlo, ¿vale?

tiempo promedio: 497 ms; uso de la memoria: 32MB; tamaño de archivo de caché: 2.8MB

Eso es mejor, pero requiere una nueva extensión; compilando a veces gente asustada ...

IgBinary

@GingerDog menciona https://github.com/phadej/igbinary . Tenga en cuenta que he configurado igbinary.compact_strings=Off porque me importa más el rendimiento de la lectura que el tamaño del archivo.

Tiempo promedio: 411.4 ms; uso de memoria: 36.75MB; tamaño de archivo de caché: 3.3MB

Mejor que el paquete de mensajes. Sin embargo, este requiere la compilación también.

serialize / unserialize

Tiempo promedio: 477.2 ms; uso de la memoria: 36.25MB; tamaño de archivo de caché: 5.9MB

Mejor rendimiento que JSON, cuanto más grande es la matriz, más json_decode es json_decode , pero ya eres nuevo en eso.

Esas extensiones externas están reduciendo el tamaño del archivo y parece genial en papel. Los números no mienten *. ¿Para qué compilar una extensión si obtiene casi los mismos resultados que obtendría con una función PHP estándar?

También podemos deducir que dependiendo de sus necesidades, elegirá algo diferente a otra persona:

• IgBinary es realmente agradable y funciona mejor que MsgPack
• Msgpack es mejor para comprimir sus datos (tenga en cuenta que no probé la opción igbinary compact.string).
• ¿No quieres compilar? Utilizar normas.

Eso es todo, ¡otra comparación de métodos de serialización para ayudarte a elegir el!

* Probado con PHPUnit 3.7.31, php 5.5.10 - solo decodificación con una unidad de disco duro estándar y una CPU de doble núcleo antigua - números promedio en 10 pruebas de casos de uso idéntico, sus estadísticas pueden ser diferentes

Answer 11

Parece que serializar es el que voy a usar por 2 razones:

• Alguien señaló que unserialize es más rápido que json_decode y un caso de "lectura" parece más probable que un caso de "escritura".

• He tenido problemas con json_encode al tener cadenas con caracteres UTF-8 no válidos. Cuando eso sucede, la cadena termina siendo vacía causando la pérdida de información.

Answer 12

Primero, cambié la secuencia de comandos para hacer más evaluaciones comparativas (y también hacer 1000 ejecuciones en lugar de solo 1):

<?php
ini_set(''display_errors'', 1);
error_reporting(E_ALL);
// Make a big, honkin test array
// You may need to adjust this depth to avoid memory limit errors
$testArray = fillArray(0, 5);
$totalJsonTime = 0;
$totalSerializeTime = 0;
$totalJsonWins = 0;
for ($i = 0; $i < 1000; $i++) {
// Time json encoding
$start = microtime(true);
$json = json_encode($testArray);
$jsonTime = microtime(true) - $start;
$totalJsonTime += $jsonTime;
// Time serialization
$start = microtime(true);
$serial = serialize($testArray);
$serializeTime = microtime(true) - $start;
$totalSerializeTime += $serializeTime;
if ($jsonTime < $serializeTime) {
$totalJsonWins++;
}
}
$totalSerializeWins = 1000 - $totalJsonWins;
// Compare them
if ($totalJsonTime < $totalSerializeTime) {
printf("json_encode() (wins: $totalJsonWins) was roughly %01.2f%% faster than serialize()/n", ($totalSerializeTime / $totalJsonTime - 1) * 100);
} else {
printf("serialize() (wins: $totalSerializeWins) was roughly %01.2f%% faster than json_encode()/n", ($totalJsonTime / $totalSerializeTime - 1) * 100);
}
$totalJsonTime = 0;
$totalJson2Time = 0;
$totalSerializeTime = 0;
$totalJsonWins = 0;
for ($i = 0; $i < 1000; $i++) {
// Time json decoding
$start = microtime(true);
$orig = json_decode($json, true);
$jsonTime = microtime(true) - $start;
$totalJsonTime += $jsonTime;
$start = microtime(true);
$origObj = json_decode($json);
$jsonTime2 = microtime(true) - $start;
$totalJson2Time += $jsonTime2;
// Time serialization
$start = microtime(true);
$unserial = unserialize($serial);
$serializeTime = microtime(true) - $start;
$totalSerializeTime += $serializeTime;
if ($jsonTime < $serializeTime) {
$totalJsonWins++;
}
}
$totalSerializeWins = 1000 - $totalJsonWins;
// Compare them
if ($totalJsonTime < $totalSerializeTime) {
printf("json_decode() was roughly %01.2f%% faster than unserialize()/n", ($totalSerializeTime / $totalJsonTime - 1) * 100);
} else {
printf("unserialize() (wins: $totalSerializeWins) was roughly %01.2f%% faster than json_decode()/n", ($totalJsonTime / $totalSerializeTime - 1) * 100);
}
// Compare them
if ($totalJson2Time < $totalSerializeTime) {
printf("json_decode() was roughly %01.2f%% faster than unserialize()/n", ($totalSerializeTime / $totalJson2Time - 1) * 100);
} else {
printf("unserialize() (wins: $totalSerializeWins) was roughly %01.2f%% faster than array json_decode()/n", ($totalJson2Time / $totalSerializeTime - 1) * 100);
}
function fillArray( $depth, $max ) {
static $seed;
if (is_null($seed)) {
$seed = array(''a'', 2, ''c'', 4, ''e'', 6, ''g'', 8, ''i'', 10);
}
if ($depth < $max) {
$node = array();
foreach ($seed as $key) {
$node[$key] = fillArray($depth + 1, $max);
}
return $node;
}
return ''empty'';
}

Utilicé esta compilación de PHP 7:

PHP 7.0.14 (cli) (construido: 18 de enero de 2017 19:13:23) (NTS) Copyright (c) 1997-2016 The PHP Group Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies con Zend OPcache v7.0.14, Copyright (c) 1999-2016, por Zend Technologies

Y mis resultados fueron:

serialize () (victorias: 999) fue aproximadamente un 10.98% más rápido que json_encode () unserialize () (victorias: 987) fue aproximadamente un 33.26% más rápido que json_decode () unserialize () (victorias: 987) fue aproximadamente un 48.35% más rápido que array json_decode ()

Así que claramente , serializar / unserialize es el método más rápido , mientras que json_encode / decode es el más portátil.

Si considera un escenario en el que lee / escribe datos serializados 10 veces o más a menudo de lo que necesita enviar o recibir de un sistema que no sea PHP, AÚN ES MEJOR para usar serialize / unserialize y tener json_encode o json_decode antes de la serialización en términos de tiempo.

Answer 13

Si está almacenando en caché información que finalmente querrá "incluir" en un momento posterior, puede intentar usar var_export . De esa manera solo tomas el hit en "serializar" y no en "deserializar".

Answer 14

Si para resumir lo que dice la gente aquí, json_decode / encode parece más rápido que serializar / unserialize PERO Si lo hace var_dump, el tipo del objeto serializado cambia. Si por alguna razón desea mantener el tipo, vaya con serializar!

(intente por ejemplo stdClass vs array)

serializar / unserialize:

Array cache:
array (size=2)
''a'' => string ''1'' (length=1)
''b'' => int 2
Object cache:
object(stdClass)[8]
public ''field1'' => int 123
This cache:
object(Controller/Test)[8]
protected ''view'' =>

json codificar / decodificar

Array cache:
object(stdClass)[7]
public ''a'' => string ''1'' (length=1)
public ''b'' => int 2
Object cache:
object(stdClass)[8]
public ''field1'' => int 123
This cache:
object(stdClass)[8]

Como puede ver, json_encode / decode convierte todos a stdClass, lo que no es tan bueno, la información del objeto se pierde ... Así que decida en función de las necesidades, especialmente si no son solo arreglos ...

Answer 15

THX - para este código de referencia:

Mis resultados en la matriz que utilizo para la configuración son los siguientes: JSON codificado en 0.0031511783599854 segundos
PHP serializado en 0.0037961006164551 segundos
json_encode() fue aproximadamente 20.47% más rápido que serialize() JSON codificado en 0.0070841312408447 segundos
PHP serializado en 0.0035839080810547 segundos
unserialize() fue aproximadamente 97.66% más rápido que json_encode()

Entonces, pruébalo con tus propios datos.

Answer 16

También hice un pequeño punto de referencia. Mis resultados fueron los mismos. Pero necesito la decodificación del rendimiento. Donde me di cuenta, como dijeron también algunas de las personas anteriores, unserialize es más rápido que json_decode . unserialize toma aproximadamente el 60-70% del tiempo json_decode . Entonces, la conclusión es bastante simple: cuando necesite rendimiento en la codificación, use json_encode , cuando necesite rendimiento al descodificar, use unserialize . Debido a que no puede combinar las dos funciones, tiene que hacer una elección donde necesita más rendimiento.

Mi punto de referencia en pseudo:

• Defina array $ arr con algunas claves y valores aleatorios
• para x <100; x ++; serialize y json_encode un array_rand de $ arr
• para y <1000; y ++; json_decode la cadena codificada json - tiempo de cálculo
• para y <1000; y ++; unserialize la cadena serializada - tiempo de calc.
• echo el resultado que fue más rápido

En promedio: unserialize ganó 96 veces más de 4 veces el json_decode. Con un promedio de aproximadamente 1,5 ms en 2,5 ms.

Answer 17

También puede interesarle https://github.com/phadej/igbinary , que proporciona un ''motor'' de serialización diferente para PHP.

Mis cifras aleatorias / arbitrarias de ''rendimiento'', utilizando PHP 5.3.5 en una plataforma de 64 bits muestran:

JSON:

• JSON codificado en 2.180496931076 segundos
• JSON decodificado en 9.8368630409241 segundos
• Tamaño "String" serializado: 13993

PHP nativo:

• PHP serializado en 2.9125759601593 segundos
• PHP sin ser serializado en 6.4348418712616 segundos
• Tamaño "String" serializado: 20769

Igbinario:

• WIN igbinary serializado en 1.6099879741669 segundos
• WIN igbinrary sin ser serializado en 4.7737920284271 segundos
• WIN serializado "String" Tamaño: 4467

Por lo tanto, es más rápido igbinary_serialize () y igbinary_unserialize () y utiliza menos espacio en disco.

Utilicé el código fillArray (0, 3) como anteriormente, pero hice que las claves de matriz fueran más largas.

igbinary puede almacenar los mismos tipos de datos que la serialización nativa de PHP (así que no hay problema con los objetos, etc.) y puede decirle a PHP5.3 que lo use para el manejo de sesiones si así lo desea.

Ver también http://ilia.ws/files/zendcon_2010_hidden_features.pdf - específicamente diapositivas 14/15/16

Answer 18

solo un fyi: si desea serializar sus datos a algo fácil de leer y entender como JSON pero con más compresión y mayor rendimiento, debe revisar el msgpack

Answer 19

JSON es más simple y más rápido que el formato de serialización de PHP y debe usarse a menos que :

• Estás almacenando matrices profundamente anidadas: json_decode() : "Esta función devolverá false si los datos codificados en JSON son más profundos que los 127 elementos".
• Estás almacenando objetos que necesitan ser sin ser serializados como la clase correcta
• Estás interactuando con versiones antiguas de PHP que no admiten json_decode