Méthode préférée pour stocker des tableaux PHP (json_encode vs serialize)

StackOverflow https://stackoverflow.com/questions/804045

Question

Je dois stocker un tableau associatif multidimensionnel de données dans un fichier plat pour la mise en cache. Je peux parfois avoir besoin de le convertir en JSON pour l'utiliser dans mon application Web, mais la plupart du temps, j'utiliserai directement le tableau en PHP.

Serait-il plus efficace de stocker le tableau en JSON ou en tant que tableau sérialisé PHP dans ce fichier texte? J'ai regardé autour de moi et il semble que dans les dernières versions de PHP (5.3), json_decode est en réalité plus rapide que unserialize.

Je suis actuellement enclin à stocker le tableau au format JSON, car j'estime qu'il est plus facile à lire par un humain si nécessaire. Il peut être utilisé à la fois en PHP et en JavaScript avec très peu d'effort. D'après ce que j'ai lu, pourrait même être plus rapide à décoder (pas sûr du codage, cependant).

Quelqu'un connaît-il des pièges? Quelqu'un a-t-il de bons points de repère pour montrer les avantages en termes de performances de l'une ou l'autre méthode?

Était-ce utile?

La solution

Cela dépend de vos priorités.

Si la performance est votre caractéristique de conduite absolue, utilisez la plus rapide. Assurez-vous simplement de bien comprendre les différences avant de faire un choix

  • Contrairement à serialize(), vous devez ajouter un paramètre supplémentaire pour conserver les caractères UTF-8 inchangés: json_encode($array, JSON_UNESCAPED_UNICODE) (sinon, les caractères UTF-8 sont convertis en séquences d'échappement Unicode).
  • JSON n'aura aucune mémoire sur la classe d'origine de l'objet (elles sont toujours restaurées en tant qu'instances de stdClass).
  • Vous ne pouvez pas exploiter __sleep() et __wakeup() avec JSON
  • Par défaut, seules les propriétés publiques sont sérialisées avec JSON. (dans PHP>=5.4 vous pouvez implémenter JsonSerializable pour modifier ce comportement).
  • JSON est plus portable

Et il y a probablement quelques autres différences auxquelles je n'arrive pas à penser en ce moment.

Un test de vitesse simple pour comparer les deux 

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

Autres conseils

JSON est plus simple et plus rapide que le format de sérialisation PHP et doit être utilisé sauf si :

  • Vous stockez des tableaux profondément imbriqués: json_decode() : & "; Cette fonction retournera la valeur false si les données encodées JSON sont plus profondes que 127 éléments. "
  • Vous stockez des objets qui doivent être non sérialisés en tant que classe correcte
  • Vous interagissez avec d'anciennes versions de PHP qui ne prennent pas en charge json_decode

J'ai écrit un article sur ce sujet sur un blog: & Cachez un grand tableau: JSON, serialize ou var_export? &"; ". Dans cet article, il est montré que la sérialisation est le meilleur choix pour les baies de taille petite à grande. Pour les très grands réseaux (& Gt; 70 Mo), JSON est le meilleur choix.

Vous pourriez également être intéressé par https://github.com/phadej/igbinary - qui fournit un 'moteur' de sérialisation différent pour PHP.

Mes performances aléatoires / arbitraires, en utilisant PHP 5.3.5 sur une plate-forme 64 bits:

JSON:

  • JSON codé en 2.180496931076 secondes
  • JSON décodé en 9.8368630409241 secondes
  • sérialisé " Chaîne " taille: 13993

PHP natif:

  • PHP sérialisé en 2.9125759601593 secondes
  • PHP non sérialisé en 6.4348418712616 secondes
  • sérialisé " Chaîne " taille: 20769

Igbinary:

    igbinaire
  • WIN sérialisé en 1,6099879741669 secondes
  • WIN igbinrary non sérialisée en 4.7737920284271 secondes
  • WIN sérialisé " Chaîne " Taille: 4467

Ainsi, il est plus rapide d'utiliser igbinary_serialize () et igbinary_unserialize () et utilise moins d'espace disque.

J'ai utilisé le code fillArray (0, 3) comme ci-dessus, mais les chaînes du tableau ont été allongées.

igbinary peut stocker les mêmes types de données que la sérialisation native de PHP (aucun problème avec les objets, etc.) et vous pouvez dire à PHP 5.3 de l’utiliser pour la gestion de session si vous le souhaitez.

Voir aussi http://ilia.ws/files/zendcon_2010_hidden_features.pdf - spécifiquement des diapositives 14/15/16

Je viens de tester l’encodage et le décodage sérialisés et JSON, ainsi que la taille de la chaîne stockée. 

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

Nous pouvons en conclure que JSON code plus rapidement et donne une chaîne plus petite, mais que la désérialisation est plus rapide pour décoder la chaîne.

Si vous mettez en cache des informations que vous voudrez finalement & "inclure &"; Plus tard, vous voudrez peut-être essayer d'utiliser var_export . De cette façon, vous ne récupérerez le hit que dans & "; Sérialiser &"; et non dans le " unserialize ".

J'ai augmenté le test pour inclure les performances de désérialisation. Voici les chiffres que j'ai obtenus. 

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

Donc json semble être plus rapide pour l’encodage mais lent pour le décodage. Cela pourrait donc dépendre de votre candidature et de ce que vous espérez faire le plus.

Sujet vraiment sympa et après avoir lu les quelques réponses, je souhaite partager mes expériences sur le sujet.

J'ai un cas d'utilisation où certains & "énormes &"; table doit être interrogé presque chaque fois que je parle à la base de données (ne demandez pas pourquoi, mais un fait). Le système de mise en cache de la base de données n'est pas approprié car il ne mettra pas en cache les différentes requêtes. Je me suis donc intéressé aux systèmes de cache php.

J'ai essayé apcu mais cela ne répond pas aux besoins, la mémoire n'est pas assez fiable dans ce cas. La prochaine étape consistait à mettre en cache un fichier avec une sérialisation.

Le tableau contient 14355 entrées avec 18 colonnes. Ce sont mes tests et statistiques sur la lecture du cache sérialisé:

JSON:

Comme vous l'avez tous dit, l'inconvénient majeur de json_encode / json_decode est qu'il transforme tout en une instance StdClass (ou un objet). Si vous avez besoin de le boucler, vous le ferez probablement en le transformant en tableau, et oui, cela augmente le temps de transformation

  

temps moyen: 780,2 ms; utilisation de la mémoire: 41,5 Mo; taille du fichier cache: 3,8 Mo

Msgpack

@hutch mentionne msgpack . Joli site. Essayons-nous?

  

temps moyen: 497 ms; utilisation de la mémoire: 32 Mo; taille du fichier cache: 2,8 Mo

C’est mieux, mais nécessite une nouvelle extension; compiler parfois des gens qui ont peur ...

IgBinary

@GingerDog mentionne igbinary . Notez que j’ai défini le paramètre igbinary.compact_strings=Off car je me soucie plus des performances de lecture que de la taille du fichier.

  

temps moyen: 411,4 ms; utilisation de la mémoire: 36,75 Mo; taille du fichier cache: 3,3 Mo

Mieux que le pack msg. Néanmoins, celui-ci nécessite également une compilation.

serialize / unserialize

  

temps moyen: 477,2 ms; utilisation de la mémoire: 36,25 Mo; taille du fichier cache: 5,9 Mo

Meilleures performances que JSON, plus le tableau est large, <<> lent, mais vous le savez déjà.

Ces extensions externes réduisent la taille du fichier et semblent super sur papier. Les chiffres ne mentent pas *. Quel est l'intérêt de compiler une extension si vous obtenez presque les mêmes résultats qu'avec une fonction PHP standard?

Nous pouvons également en déduire que, selon vos besoins, vous choisirez autre chose que quelqu'un d'autre:

  • IgBinary est vraiment sympa et fonctionne mieux que MsgPack
  • Msgpack est meilleur pour compresser vos données (notez que je n'ai pas essayé l'igbinary option compact.string).
  • Vous ne voulez pas compiler? Utilisez les normes.

Voilà, une autre comparaison des méthodes de sérialisation pour vous aider à choisir celle!

* Testé avec PHPUnit 3.7.31, php 5.5.10 - décodage uniquement avec un processeur standard double disque dur et ancien - nombres moyens pour 10 tests de cas d'utilisation identiques, vos statistiques pourraient être différentes

On dirait que la sérialisation est celle que je vais utiliser pour 2 raisons:

  • Quelqu'un a fait remarquer que la désérialisation est plus rapide que json_decode et qu'un cas "en lecture" semble plus probable qu'un cas "en écriture".

  • J'ai rencontré des problèmes avec json_encode lors de l'utilisation de chaînes contenant des caractères UTF-8 non valides. Lorsque cela se produit, la chaîne devient vide et entraîne une perte d'informations.

J'ai testé cela de manière approfondie sur un multi-hachage relativement complexe et légèrement imbriqué, contenant toutes sortes de données (chaîne, NULL, entiers), et serialize / unserialize aboutissant beaucoup plus rapidement que json_encode / json_decode.

Le seul avantage que JSON a eu lors de mes tests est sa taille plus compacte.

Celles-ci sont effectuées sous PHP 5.3.3, faites-moi savoir si vous souhaitez plus de détails.

Voici les résultats des tests, puis le code pour les produire. Je ne peux pas fournir les données de test car elles révéleraient des informations que je ne peux pas laisser sortir à l’état sauvage. 

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

J'ai aussi fait une petite référence. Mes résultats étaient les mêmes. Mais j'ai besoin de la performance de décodage. Là où j'ai remarqué, comme l'ont dit quelques personnes ci-dessus, unserialize est plus rapide que json_decode. json_encode prend environ 60 à 70% du temps <=>. Donc la conclusion est assez simple: Lorsque vous avez besoin de performances en codage, utilisez <=>, lorsque vous avez besoin de performances lors du décodage, utilisez <=>. Parce que vous ne pouvez pas fusionner les deux fonctions, vous devez choisir où vous avez besoin de plus de performances.

Mon repère dans le pseudo:

  • Définissez le tableau $ arr avec quelques clés et valeurs aléatoires
  • pour x < 100; x ++; sérialiser et json_encode un array_rand de $ arr
  • pour y < 1000; y ++; json_decode la chaîne encodée en json - calc time
  • pour y < 1000; y ++; désérialiser la chaîne sérialisée - temps de calcul
  • fait écho au résultat qui était plus rapide

En moyenne: unserialize a gagné 96 fois plus de 4 fois le json_decode. Avec une moyenne d'environ 1,5 ms sur 2,5 ms.

Avant de prendre votre décision finale, sachez que le format JSON n'est pas sûr pour les tableaux associatifs - json_decode() les renverra sous forme d'objets: 

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

La sortie est: 

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

Voir les résultats ici (désolé pour le bidouillage mettant le code PHP dans la boîte de code JS):

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

RÉSULTATS: serialize() et unserialize() sont nettement plus rapides en PHP 5.4 sur des tableaux de tailles variables.

J'ai créé un script de test sur des données réelles pour comparer json_encode et serialize et json_decode et unserialize. Le test a été exécuté sur le système de mise en cache d’un site de commerce électronique en production. Il prend simplement les données déjà dans le cache et teste les temps pour encoder / décoder (ou sérialiser / désérialiser) toutes les données et je les mets dans un tableau facile à voir.

Je l'ai exécuté sur un serveur d'hébergement partagé PHP 5.4.

Les résultats ont été très concluants: pour ces grands ensembles de données, les grands gagnants sont la sérialisation et la non-numérotation. En particulier pour mon cas d'utilisation, json_decode et unserialize sont les plus importants pour le système de mise en cache. Unserialize était presque un gagnant omniprésent ici. C'était typiquement 2 à 4 fois (parfois 6 ou 7 fois) aussi vite que json_decode.

Il est intéressant de noter la différence entre les résultats de @ peter-bailey.

Voici le code PHP utilisé pour générer les résultats: 

<?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>

juste un fyi - si vous voulez sérialiser vos données en quelque chose de facile à lire et à comprendre comme JSON mais avec plus de compression et de meilleures performances, vous devriez jeter un oeil à messagepack.

Tout d'abord, j'ai modifié le script pour effectuer des analyses comparatives supplémentaires (et effectuer 1 000 exécutions au lieu d'une seule): 

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

J'ai utilisé cette version de PHP 7:

  

PHP 7.0.14 (cli) (construit le 18 janvier 2017 19:13:23) (NTS) Droits d'auteur (c)   1997-2016 Le groupe PHP Zend Engine v3.0.0, Copyright (c) 1998-2016   Zend Technologies       avec Zend OPcache v7.0.14, Copyright (c) 1999-2016, par Zend Technologies

Et mes résultats ont été:

  

serialize () (victoires: 999) était environ 10,98% plus rapide que json_encode ()   unserialize () (victoires: 987) était environ 33,26% plus rapide que json_decode ()   unserialize () (victoires: 987) était environ 48.35% plus rapide que array   json_decode ()

Donc clairement , sérialiser / désérialiser est la méthode la plus rapide , alors que json_encode / decode est la la plus portable.

Si vous envisagez un scénario dans lequel vous lisez / écrivez des données sérialisées 10 fois ou plus que nécessaire pour envoyer à ou recevoir depuis un système autre que PHP, vous êtes TOUJOURS mieux adapté à la sérialisation / à la non-sérialisation et à l'avoir json_encode ou json_decode. avant la sérialisation en termes de temps.

JSON est préférable si vous souhaitez sauvegarder des données et les restaurer sur un autre ordinateur ou via FTP.

Par exemple avec serialize si vous stockez des données sur un serveur Windows, téléchargez-les via FTP et restaurez-les sur un serveur Linux. Cela ne pouvait plus fonctionner en raison du réencodage du caractère, car serialize stockait la longueur des chaînes et dans le Unicode > Le transcodage UTF-8 sur un caractère d’un octet peut devenir long de 2 octets, ce qui fait planter l’algorithme.

THX - pour ce code de référence:

Mes résultats sur le tableau que j'utilise pour la configuration sont les suivants: JSON encodé en 0.0031511783599854 secondes
PHP sérialisé en 0.0037961006164551 secondes
json_encode() était environ 20,47% plus rapide que serialize() JSON encodé en 0.0070841312408447 secondes
PHP sérialisé en 0.0035839080810547 secondes
unserialize() était environ 97,66% plus rapide que <=>

Alors, testez-le sur vos propres données.

Si pour résumer ce que les gens disent ici, json_decode / encoder semble plus rapide que sérialiser / désérialiser MAIS Si vous effectuez var_dump, le type de l'objet sérialisé est modifié. Si pour une raison quelconque vous souhaitez conserver le type, optez pour sérialiser!

(essayez par exemple stdClass vs array)

sérialiser / désérialiser: 

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 encoder / décoder 

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]

Comme vous pouvez le voir, json_encode / decode convertit le tout en stdClass, ce qui n’est pas si bon, les informations sur les objets sont perdues ... Alors décidez-vous en fonction des besoins, surtout s’il ne s'agit pas uniquement de tableaux ...

Je vous suggérerais d'utiliser Super Cache, qui est un mécanisme de cache de fichier qui n'utilise ni json_encode ni serialize. Il est simple à utiliser et très rapide par rapport aux autres mécanismes de cache 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();
?>
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top