Método preferido para almacenar arrays PHP (codificar json vs serializar)

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

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

He escrito un blogpost sobre este tema: " Cache a large array: JSON, serialize or var_export?". En este post se muestra que serialize es la mejor opción para matrices de tamaño pequeño a grande. Para arreglos muy grandes (> 70MB) JSON es la mejor opción.

También te podría interesar https://github.com/phadej/igbinary - que proporciona un 'motor' de serialización diferente para PHP.

Mis figuras de 'rendimiento' aleatorias/arbitrarias, usando 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 serializado de la "cadena": 13993

PHP nativo:

• PHP serializado en 2.9125759601593 segundos
• PHP sin serializar en 6.4348418712616 segundos
• tamaño serializado de la "cadena": 20769

Igbinary :

• WIN igbinary serializado en 1.6099879741669 segundos
• WIN igbinrary sin serializar en 4.7737920284271 segundos
• WIN Tamaño serializado de la "cadena": 4467

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

Usé el fillArray (0, 3) código como el anterior, pero hizo que las claves del array fueran cadenas más largas.

Igbinary puede almacenar los mismos tipos de datos que el serialize can nativo de PHP (así que no hay problema con objetos, etc.) y puede decirle a PHP5.3 que lo use para el manejo de sesiones si así lo desea.

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

Y acaba de probar serializado y codificar y decodificar json, además del 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 resulta una cadena más pequeña, pero unserialize es más rápido para decodificar la cadena.

Si está almacenando información en caché que finalmente querrá "incluir" en un momento posterior, puede intentar usar var_export. De esa manera solo recibes el golpe en el "serialize" y no en el "unserialize".

Aumenté la prueba para incluir el rendimiento de no serializació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 solicitud y de lo que espera hacer más.

Parece que serialize es la que voy a usar por 2 razones:

• Alguien señaló que unserialize es más rápido que json_decode y un caso' read ' suena más probable que un caso 'write'.

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

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

Tengo un caso de uso donde alguna tabla "enorme" necesita ser consultada 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é php.

Probé 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 de la caché serializada:

JSON:

Como todos ustedes han dicho, el mayor inconveniente con json_encode/json_decode es que transforma todo en una instancia (u Objeto) StdClass. Si necesita 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.5 MB; caché tamaño del archivo: 3.8 MB

Msgpack

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

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

Eso es mejor, pero requiere una nueva extensión; compilar personas a veces asustadas...

IgBinary

@GingerDog menciona igbinary . Tenga en cuenta que he establecido el igbinary.compact_strings=Offporque me importa más leer actuaciones que archivo Tamaño.

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

Mejor que msg pack. Aún así, este también requiere compilación.

serialize/unserialize

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

Mejor rendimiento que JSON, cuanto más grande es el array, más lento es json_decode, pero ya es nuevo.

Esas extensiones externas están reduciendo el tamaño del archivo y parece genial en papel. Los números no mienten*. ¿Cuál es el punto de compilar una extensión si obtiene casi los mismos resultados que tendrí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é el igbinary compacto.opción de cadena).
• ¿No quieres compilar? Use estándares.

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

* Probado con PHPUnit 3.7.31, php 5.5.10-solo decodificación con un disco duro estándar y CPU de doble núcleo antiguo-números promedio en 10 mismas pruebas de casos de uso, sus estadísticas podrían ser diferentes

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

La única ventaja que tiene json en mis pruebas fue su tamaño 'empaquetado' más pequeño.

Estos se hacen bajo PHP 5.3.3, avísame 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 salir en la naturaleza.

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!';
}

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

Mi punto de referencia en pseudo:

• Definir matriz ar arr con unas pocas claves aleatorias y valores
• para x
• para y
• for y
• echo el resultado que fue más rápido

En avarage: unserialize ganó 96 veces sobre 4 veces el código json_decode. Con un avarage de aproximadamente 1.5 ms sobre 2.5 ms.

Antes de tomar su decisión final, tenga en cuenta que el formato JSON no es seguro para los arrays asociativos - json_decode() los devolverá como objetos en su lugar:

$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
)

Solo para su información if 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 messagepack.

Echa un vistazo a los resultados aquí (lo siento por el hack de poner 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 arrays de tamaño variable.

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 ya en la caché, y prueba los tiempos para codificar / decodificar (o serializar / no serializar) todos los datos y los pongo en una tabla fácil de ver.

Ejecuté 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 no serializar fueron los ganadores claros. En particular para mi caso de uso, el json_decode y unserialize son los más importantes para el sistema de almacenamiento en caché. Unserialize era casi un omnipresente ganador 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>

Primero, cambié el script para hacer más benchmarking (y también hacer 1000 corridas 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';
}

Usé esta compilación de PHP 7:

PHP 7.0.14 (cli) ( construido: 18 Ene 2017 19:13:23) (NTS) Copyright (c) 1997-2016 El Grupo PHP 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 () (wins: 999) fue aproximadamente un 10,98% más rápido que json_encode() unserialize () (wins: 987) fue aproximadamente un 33.26% más rápido que json_decode() unserialize () (wins: 987) fue aproximadamente 48.35% más rápido que array json_decode ()

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

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 no-PHP sistema, todavía es mejor usar serialize / unserialize y tenerlo json_encode o json_decode antes de serializar en términos de tiempo.

JSON es mejor si desea hacer una copia de seguridad de los datos y restaurarlos en una máquina diferente o a través de FTP.

Por ejemplo con serialize si almacena datos en un servidor Windows, descargarlos a través de FTP y restaurarlos en un Linux no podría funcionar más debido a la recodificación del charachter, porque serialize almacena la longitud de las cadenas y en la transcodificación Unicode > UTF-8 algunos charachter de 1 byte podrían convertirse en 2 bytes de largo haciendo que el algoritmo se bloquee.

THX-para este código de referencia:

Mis resultados en el array que uso para la configuración son como barbechos: JSON codificado en 0.0031511783599854 segundos
PHP serializado en 0.0037961006164551 segundos
json_encode() fue aproximadamente un 20,47% más rápido que serialize() JSON codificado en 0.0070841312408447 segundos
PHP serializado en 0.0035839080810547 segundos
unserialize() fue aproximadamente un 97,66% más rápido que json_encode()

So - pruébelo en sus propios datos.

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

(prueba por ejemplo stdClass vs array)

Serializar / no serializar:

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 el json_encode/decode convierte todo a stdClass, que no es tan bueno, la información del objeto se pierde... Así que decide en base a necesidades, especialmente si no es solo matrices...

Le sugeriría que use Super Cache, que es un mecanismo de caché de archivos que no usará json_encode o serialize. Es simple de usar y muy 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();
?>