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

https://stackoverflow.com/questions/804045

03-07-2019
|

Pregunta

Necesito almacenar una matriz asociativa multidimensional de datos en un archivo plano para fines de almacenamiento en caché.Es posible que ocasionalmente me encuentre con la necesidad de convertirlo a JSON para usarlo en mi aplicación web, pero la gran 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 PHP en este archivo de texto?Miré a mi alrededor y parece que en las versiones más recientes de PHP (5.3), json_decode en realidad es más rápido que unserialize.

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

¿Alguien sabe de algún peligro?¿Alguien tiene buenos puntos de referencia para mostrar los beneficios de rendimiento de cualquiera de los métodos?

Solución

Depende de tus prioridades.

Si el rendimiento es su característica de conducción absoluta, entonces utilice el más rápido.Solo asegúrese de comprender completamente las diferencias antes de tomar una decisión.

A diferencia de serialize() necesita agregar un parámetro adicional para mantener intactos los caracteres UTF-8: json_encode($array, JSON_UNESCAPED_UNICODE) (de lo contrario, convierte caracteres UTF-8 en secuencias de escape Unicode).
JSON no tendrá memoria de cuál 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 puedes implementar JsonSerializable para cambiar este comportamiento).
JSON es más portátil

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

Una prueba de velocidad sencilla 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';
}

Otros consejos

JSON es más simple y 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á falso si los datos codificados con JSON son más profundos que 127 elementos. "
Estás almacenando objetos que deben ser no serializados como la clase correcta
Estás interactuando con versiones antiguas de PHP que no admiten json_decode

He escrito una entrada de blog sobre este tema: " Caché una matriz grande: JSON, serialize o var_export? " ;. En esta publicación se muestra que serializar es la mejor opción para matrices de tamaño pequeño a grande. Para matrices muy grandes (& Gt; 70MB) JSON es la mejor opción.

También podría estar interesado en https://github.com/phadej/igbinary , que proporciona un 'motor' de serialización diferente para PHP.

Mis cifras de 'rendimiento' al azar / 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
serializado " Cadena " tamaño: 13993

PHP nativo:

PHP serializado en 2.9125759601593 segundos
PHP no serializado en 6.4348418712616 segundos
serializado " Cadena " tamaño: 20769

Igbinary:

WIN igbinary serializado en 1.6099879741669 segundos
WIN igbinrary no serializado en 4.7737920284271 segundos
WIN serializado " String " Tamaño: 4467

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

Utilicé el código fillArray (0, 3) como el anterior, pero hice que las teclas de la matriz sean cadenas 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 la sesión si así lo desea.

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

Y 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 deserializar 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 utilizar var_export . De esa manera, solo recibes el golpe en & Quot; serializar & Quot; y no en " unserialize " ;.

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

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

Entonces, 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.

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

Obtuve un caso de uso donde algunos " enorme " La tabla debe consultarse 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.

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é 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 dijeron, el mayor inconveniente con json_encode / json_decode es que transforma todo a una instancia (u Objeto) StdClass. Si necesita hacer un bucle, lo que probablemente hará es transformarlo en una matriz, y sí, aumenta el tiempo de transformación

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

Msgpack

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

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

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

IgBinary

@GingerDog menciona igbinary . Tenga en cuenta que he configurado el igbinary.compact_strings=Off porque me importa más la lectura de actuaciones que el tamaño del archivo.

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

Mejor que el paquete de mensajes. Aún así, este también requiere compilación.

`serialize`/`unserialize`

tiempo promedio: 477,2 ms; uso de memoria: 36.25MB; tamaño del archivo de caché: 5.9MB

Mejores rendimientos que JSON, cuanto más grande es la matriz, más lento es <=>, pero eso 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 obtienes casi los mismos resultados que tendrías con una función PHP estándar?

También podemos deducir que, según 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 opción compact.string).
¿No quieres compilar? Usar estándares.

¡Eso es, otra comparación de métodos de serialización para ayudarlo a elegir uno!

* 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 caso de uso, sus estadísticas pueden ser diferentes

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' suena más probable que un caso de 'escritura'.
He tenido problemas con json_encode cuando tengo cadenas con caracteres UTF-8 no válidos. Cuando eso sucede, la cadena termina vacía y causa pérdida de información.

He probado esto muy a fondo en un hash múltiple bastante complejo y 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 json tiene en mis pruebas es su tamaño 'empaquetado' más pequeño.

Estos se realizan en PHP 5.3.3, avíseme si desea 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 también dijeron, unserialize es más rápido que json_decode. json_encode toma aproximadamente 60-70% del tiempo <=>. Entonces la conclusión es bastante simple: Cuando necesite rendimiento en la codificación, use <=>, cuando necesite rendimiento al decodificar, use <=>. Debido a que no puede fusionar las dos funciones, debe elegir dónde necesita más rendimiento.

Mi punto de referencia en pseudo:

Definir array $ arr con algunas claves y valores aleatorios
para x < 100; x ++; serializar 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 ++; deserializar la cadena serializada - tiempo de cálculo
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.5ms sobre 2.5ms.

Antes de tomar su decisión final, tenga en cuenta que el formato JSON no es seguro para las matrices asociativas: json_decode() las 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
)

Consulte los resultados aquí (perdón por el truco al poner el código PHP en el cuadro de código JS):

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

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

Hice un script de prueba con datos del mundo real para comparar json_encode con serialize y json_decode con 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/deserializar) todos los datos y los coloco en una tabla fácil de ver.

Ejecuté esto en un servidor de alojamiento compartido PHP 5.4.

Los resultados fueron muy concluyentes: para estos conjuntos de datos grandes y pequeños, serializar y deserializar fueron los claros ganadores.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 omnipresente aquí.Por lo general, era de 2 a 4 veces (a veces 6 o 7 veces) más rápido que 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>

solo una información: si desea serializar sus datos en algo fácil de leer y entender como JSON pero con más compresión y mayor rendimiento, debe consultar paquete de mensajes.

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

Usé 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 Tecnologías Zend con Zend OPcache v7.0.14, Copyright (c) 1999-2016, por Zend Technologies

Y mis resultados fueron:

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

Entonces claramente , serializar / deserializar 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 de lo que necesita enviar o recibir desde un sistema que no sea PHP, TODAVÍA es mejor usar serializar / unserializar y tener json_encode o json_decode antes de la serialización 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 mediante FTP.

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

THX - para este código de referencia:

Mis resultados en la matriz 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 <=>

Entonces, pruébelo con sus propios datos.

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

(pruebe, por ejemplo, stdClass vs array)

serializar / deserializar:

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' =>

codificación / decodificación json

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 todo a stdClass, lo que no es tan bueno, la información del objeto se perdió ... Así que decida en función de las necesidades, especialmente si no se trata solo de matrices ...

Te sugiero que uses Super Cache, que es un mecanismo de caché de archivos que no usará json_encode o serialize. Es simple de usar y realmente rápido en comparación con otros mecanismos de caché PHP.

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

Ej:

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

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow

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

JSON:

Msgpack

IgBinary

serialize/unserialize

`serialize`/`unserialize`