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

j'ai besoin de stocker un tableau associatif multi-dimensionnel de données dans un fichier plat à des fins de mise en cache. Je pourrais parfois rencontré le besoin de le convertir en JSON pour les utiliser dans mon application web, mais la grande majorité du temps, je vais utiliser le tableau directement en PHP.

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

je penche actuellement pour stocker le tableau comme JSON car je sens qu'il est plus facile à lire par un humain si nécessaire, il peut être utilisé en PHP et JavaScript avec très peu d'effort, et de ce que j'ai lu, il pourrait même être plus rapide à décoder (pas sûr de l'encodage, cependant).

est-ce que quelqu'un connaît des pièges? Quelqu'un a-t-il de bons points de repère pour démontrer les avantages de l'une ou l'autre méthode?

559
demandé sur Jeffrey Bosboom 2009-04-30 00:09:43
la source

19 ответов

Dépend de vos priorités.

si la performance est votre caractéristique de conduite absolue, alors par tous les moyens utiliser le plus rapide. Assurez-vous juste que vous avez une pleine compréhension des différences avant de faire un choix

  • contrairement à serialize() vous devez ajouter un paramètre supplémentaire pour garder les caractères UTF-8 intacts: json_encode($array, JSON_UNESCAPED_UNICODE) (sinon il convertit les caractères UTF-8 en séquences D'échappement Unicode).
  • JSON n'aura aucun souvenir de la classe d'origine de l'objet (ils sont toujours restaurés comme des instances de stdClass).
  • Vous ne pouvez pas l'effet de levier __sleep() et __wakeup() JSON
  • par défaut, seules les propriétés publiques sont sérialisées avec JSON. (dans PHP>=5.4 vous pouvez implémenter Jsonserialisable pour changer ce comportement).
  • JSON est plus portable

et il y a probablement d'autres différences auxquelles je ne peux pas penser pour le moment.

Un simple test de vitesse de 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';
}
520
répondu Peter Bailey 2018-04-16 11:24:17
la source

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

  • vous stockez des tableaux profondément imbriqués: json_decode() : "cette fonction retournera false si les données encodées par JSON sont plus profondes que 127 éléments."
  • vous stockez des objets qui doivent être unserialized comme la classe correcte
  • vous êtes interagir avec D'anciennes versions PHP qui ne prennent pas en charge json_decode
224
répondu Greg 2009-04-30 00:13:32
la source

j'ai écrit un billet de blog sur ce sujet: " Cache un large tableau: JSON, serialize ou var_export? ". Dans ce post, il est montré que serialize est le meilleur choix pour les tableaux de petite à grande taille. Pour les très grands tableaux (>70MB) JSON est le meilleur choix.

56
répondu Taco 2015-03-02 13:02:48
la source

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

Mon random/arbitraire de la "performance" des chiffres, à l'aide de PHP 5.3.5 sur une plate-forme 64 bits spectacle :

JSON:

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

Natives de PHP :

  • PHP sérialisé dans 2.9125759601593 secondes
  • PHP Non numérisé en 6.4348418712616 secondes
  • sérialisé "Chaîne" taille : 20769

Igbinary:

  • GAGNER igbinary sérialisé dans 1.6099879741669 secondes
  • GAGNER igbinrary désérialisé dans 4.7737920284271 secondes
  • GAGNER sérialisé "Chaîne" Taille : 4467

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

j'ai utilisé le code fillArray(0, 3) comme ci-dessus, mais j'ai rendu les chaînes de touches plus longues.

igbinary peut stocker les mêmes types de données que Le serialize natif de PHP peut (donc pas de problème avec les objets etc) et vous pouvez le dire à PHP5.3 pour l'utiliser pour le traitement de session si vous le souhaitez.

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

50
répondu David Goodwin 2011-01-27 21:53:54
la source

y vient de tester serialized et JSON encodent et décodent, plus la taille qu'il prendra 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 conclure que JSON code plus rapidement et produit une chaîne plus petite, mais unserialize est plus rapide pour décoder la chaîne.

23
répondu Blunk 2010-07-11 03:44:29
la source

si vous mettez en cache des informations que vous allez finalement vouloir" inclure "à un moment ultérieur, vous pouvez essayer d'utiliser var_export . De cette façon, vous ne prenez le coup dans le "serialize" et pas dans le "unserialize".

14
répondu Jordan S. Jones 2009-04-30 03:04:23
la source

j'ai augmenté le test pour inclure les performances de non-pérégralisation. Voici les numéros que j'ai eu.

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 encoder mais lent pour décoder. Ainsi, il pourrait dépendre de votre application et de ce que vous attendez le plus.

11
répondu Jeff Whiting 2009-11-23 22:14:59
la source

semble comme serialize est celui que je vais utiliser pour 2 raisons:

  • Quelqu'un a fait remarquer que unserialize est plus rapide que json_decode et qu'un cas de "lecture" semble plus probable qu'un cas d'écriture.

  • j'ai eu des problèmes avec json_encode quand j'ai des chaînes avec des caractères UTF-8 invalides. Lorsque cela se produit, la chaîne finit par être vide, ce qui entraîne une perte d'information.

8
répondu urraka 2010-06-27 04:46:40
la source

Vraiment beau sujet et après avoir lu les quelques réponses, je veux partager mes expériences sur le sujet.

j'ai eu un cas d'utilisation où une certaine" énorme " table doit être questionnée presque chaque fois que je parle à la base de données (ne demandez pas pourquoi, juste un fait). Le système de mise en cache de la base de données n'est pas approprié car il ne cache pas les différentes requêtes, donc j'ai réfléchi à propos des systèmes de mise en cache php.

j'ai essayé apcu mais il ne correspondait pas aux besoins, la mémoire n'est pas assez fiable dans ce cas. L'étape suivante a été de mettre en cache dans un fichier avec sérialisation.

Table a 14355 entrées avec 18 colonnes, ce sont mes tests et statistiques à la lecture du cache sérialisé:

JSON:

comme vous l'avez tous dit, le principal inconvénient avec json_encode / json_decode est qu'il transforme tout en une instance StdClass (ou objet). Si vous avez besoin de le boucler, le transformer en un tableau est ce que vous probablement faire, et oui il augmente le temps de transformation

durée moyenne: 780.2 ms; utilisation de la mémoire: 41.5 MB; Taille du fichier de cache: 3.8 MB

Msgpack

@hutch mentionne msgpack . Joli site web. Nous allons lui donner un essai allons-nous?

durée moyenne: 497 ms; mémoire utilisée: 32 Mo; cache Taille du fichier: 2.8 MB

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

IgBinary

@GingerDog mentionne igbinary . Notez que j'ai mis le igbinary.compact_strings=Off parce que je me soucie plus des performances de lecture que de la taille du fichier.

temps moyen: 411.4 ms; mémoire utilisée: 36.75 MB; cache Taille du fichier: 3.3 MB

meilleur que msg pack. Pourtant, celui-ci nécessite de compiler aussi.

serialize / unserialize

durée moyenne: 477,2 ms; mémoire utilisée: 36,25 MB; cache Taille du fichier: 5,9 MB

meilleures performances que JSON, plus le tableau est grand, plus lent json_decode est, mais vous déjà nouveau que.

ces extensions externes rétrécissent la taille du fichier et semble grande sur le papier. Les chiffres ne mentent pas*. Quel est le point de compiler une extension si vous obtenez presque les mêmes résultats que vous obtiendriez avec une fonction PHP standard?

nous pouvons aussi en déduire que selon vos besoins, vous choisirez quelque chose de différent de quelqu'un d'autre:

  • IgBinary est vraiment agréable et plus performant que MsgPack
  • Msgpack est meilleur à la compression de vos données (notez que je n'ai pas essayé l'igbinary Compact.option de chaîne).
  • vous ne voulez pas compiler? Les normes d'utilisation.

Que c'est, un autre méthodes de sérialisation de comparaison pour vous aider à choisir le!

*Testé avec PHPUnit 3.7.31, php 5.5.10-seulement le décodage avec un standard hardrive et de vieux CPU à double noyau-nombre moyen sur 10 même cas d'utilisation tests, vos stats pourraient être différents

7
répondu soyuka 2014-04-18 20:46:46
la source

j'ai testé ceci très minutieusement sur un multi-hachage assez complexe, légèrement imbriqué avec toutes sortes de données (string, NULL, entiers), et serialize/unserialize fini beaucoup plus vite que json_encode/json_decode.

le seul avantage de json dans mes tests était sa taille plus petite.

ceux-ci sont faits sous PHP 5.3.3, faites-moi savoir si vous voulez plus de détails.

Voici les résultats des tests puis le code à produire ils. Je ne peux pas fournir les données des tests car ça révélerait des informations que je ne peux pas laisser sortir dans la nature.

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!';
}
6
répondu Mr. Sox 2010-11-17 03:14:31
la source

j'ai aussi fait un petit benchmark. Mes résultats étaient les mêmes. Mais j'ai besoin de le décoder les performances. Là où j'ai remarqué, comme quelques personnes au-dessus l'ont dit aussi, unserialize est plus rapide que json_decode . unserialize prend environ 60-70% du temps json_decode . La conclusion est donc assez simple.: Lorsque vous avez besoin de performances en encodage, utilisez json_encode , lorsque vous avez besoin de performances en décodage, utilisez unserialize . Parce que vous ne pouvez pas fusionner les deux fonctions, vous devez faire un choix lorsque vous avez besoin de plus de performance.

Ma référence en matière de pseudo:

  • Define array $arr avec un peu aléatoire des clés et des valeurs
  • 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 json - calc temps
  • pour y < 1000; y++; unserialize la chaîne sérialisée - calc temps
  • l'écho de la résultat qui a été plus rapide

Sur avarage: unserialize remporté 96 fois plus de 4 fois la fonction json_decode. Avec une avarage d'environ 1,5 ms sur 2,5 ms.

5
répondu Jelmer 2012-11-12 14:18:39
la source

avant de prendre votre décision finale, soyez conscient que le format JSON n'est pas sûr pour les tableaux associatifs - json_decode() les retournera comme objets à la place:

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

sortie:

Array
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)
stdClass Object
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)
2
répondu too much php 2009-10-21 07:34:54
la source

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

1
répondu Hutch 2013-04-12 16:40:22
la source

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

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

résultats: serialize() et unserialize() sont tous deux significativement plus rapides en PHP 5.4 sur des tableaux de différentes tailles.

j'ai fait un script de test sur les données du monde réel pour comparer json_encode vs serialize et json_decode vs unserialize. Le test a été effectué 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 serialize / unserialize) toutes les données et je le mets dans une table facile à voir.

j'ai lancé ceci sur le serveur D'hébergement partagé PHP 5.4.

les résultats ont été très concluants que pour ces grands à petits ensembles de données serialize et unserialize étaient le clair gagnant. En particulier pour mon cas d'utilisation, le json_decode et unserialize sont les plus importants pour le système de cache. Unserialize était presque un gagnant omniprésent ici. Il était généralement de 2 à 4 fois (parfois 6 ou 7 fois) aussi rapide que json_decode.

Il est intéressant de noter la différence dans les résultats de @pierre-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>
1
répondu newms87 2015-01-21 00:46:45
la source

tout d'abord, j'ai changé le script pour faire plus de benchmarking (et aussi faire 1000 runs au lieu de 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';
}

j'ai utilisé cette construction de PHP 7:

PHP 7.0.14 (cli) (built: Jan 18 2017 19:13:23) ( NTS ) Copyright (c) 1997-2016 le groupe PHP Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies avec Zend OPcache v7.0.14, le droit d'Auteur (c) 1999-2016, par Zend Technologies

et mes résultats étaient:

serialize () (wins: 999) était environ 10.98% plus rapide que json_encode() unserialize () (wins: 987) était environ 33.26% plus rapide que json_decode() unserialize () (wins: 987) était à peu près 48.35% plus rapide que le tableau la fonction json_decode()

Donc clairement , serialize/unserialize est le le plus rapide la méthode, tout en json_encode/décodage est le la plupart des appareils portables.

si vous considérez un scénario où vous lisez/écrivez des données sérialisées 10x ou plus souvent que vous avez besoin d'envoyer ou de recevoir à partir d'un système non-PHP, vous êtes encore mieux à partir d'utiliser serialize/unserialize et l'avoir json_encode ou json_decode avant la sérialisation en termes de temps.

1
répondu Shawn Tolidano 2017-02-05 07:37:58
la source

JSON est mieux si vous voulez sauvegarder des données et les restaurer sur une autre machine 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, il ne pouvait plus fonctionner en raison du ré-encodage charachter, car serialize stocke la longueur des chaînes et dans L'Unicode > UTF-8 transcodage quelque 1 byte charachter pourrait devenir de 2 octets de long faisant planer l'algorithme.

0
répondu Informate.it 2011-11-26 14:31:43
la source

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

mes résultats sur le tableau que j'utilise pour la configuration sont comme des jachères: JSON codé en 0.0031511783599854 secondes

PHP sérialisé en 0.0037961006164551 secondes

json_encode() était d'environ 20,47% plus rapide que serialize() JSON codé en 0.0070841312408447 secondes

PHP sérialisé dans 0.0035839080810547 secondes

unserialize() a été à peu près 97,66% plus rapide que json_encode()

essai sur vos propres données.

0
répondu mk182 2012-01-10 16:10:04
la source

si pour résumer ce que les gens disent ici, json_decode / encode semble plus rapide que serialize / unserialize mais Si vous ne var_dump le type de l'objet sérialisé est changé. Si pour une raison quelconque vous voulez garder le type, allez avec serialize!

(essayer par exemple stdClass vs array)

serialize / 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 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 voir le json_encode / decode convertit tout en stdClass, qui n'est pas si bon, information objet perdu... Donc décider en fonction des besoins, surtout si ce n'est pas seulement des tableaux...

0
répondu David Constantine 2017-07-30 22:51:27
la source

je vous suggérerais D'utiliser Super Cache, qui est un mécanisme de cache de fichiers qui n'utilisera pas json_encode ou serialize . Il est simple à utiliser et vraiment rapide par rapport à D'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();
?>
0
répondu shabeer 2018-06-19 11:10:47
la source

Autres questions sur php performance arrays json serialization