La méthode préférée pour stocker les tableaux PHP (json_encode vs sérialiser)

Dépend de vos priorités.

Si la performance est votre absolu de conduite caractéristique, puis par tous les moyens l'utilisation la plus rapide possible. 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 intacte: json_encode($array, JSON_UNESCAPED_UNICODE) (sinon, il convertit les caractères UTF-8 Unicode séquences d'échappement).
• JSON n'aura aucun souvenir de ce que l'origine de l'objet de classe a (ils sont toujours restaurés comme des instances de stdClass).
• Vous ne pouvez pas tirer parti de __sleep() et __wakeup() avec JSON
• Par défaut, seules les propriétés publiques sont sérialisés avec JSON. (en PHP>=5.4 vous pouvez mettre en œuvre JsonSerializable pour modifier ce comportement).
• JSON est plus portable

Et il y a probablement quelques autres différences que 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';
}

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

Y viens de tester sérialisé et json de coder et de décoder, en plus de la taille, 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-encode plus rapide et les résultats d'un petit string, mais unserialize est plus rapide à décoder la chaîne.

J'ai enrichi le test d'inclure unserialization performance. 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 l'encodage, mais lente dans le décodage. Ainsi, il pourrait dépendre de votre application et de ce que vous attendez le plus.

Semble que serialize est celui que je vais utiliser pour 2 raisons:

• Quelqu'un a fait remarquer que unserialize est plus rapide que la fonction json_decode et un "lire" cas semble plus probable qu'un 'écrire' cas.

• J'ai eu du mal avec json_encode quand avoir des chaînes de caractères non UTF-8 caractères. Lorsque cela se produit, la chaîne finit par être vide, entraînant une perte de l'information.

J'ai fait un petit test ainsi. Mes résultats étaient les mêmes. Mais j'ai besoin de le décoder les performances. Où j'ai remarqué, que quelques personnes ci-dessus dit ainsi, unserialize est plus rapide que json_decode. unserialize prend environ 60-70% de la json_decode temps. Donc la conclusion est assez simple:
Lorsque vous avez besoin de la performance dans l'encodage, l'utilisation json_encode, lorsque vous avez besoin de performances lors du décodage, l'utilisation unserialize. Parce que vous ne pouvez pas fusionner les deux fonctions que vous avez à faire un choix lorsque vous avez besoin de plus de performance.

Mon point de repère dans 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
• echo le résultat qui a été plus rapide

Sur avarage: unserialize remporté 96 fois plus de 4 fois la fonction json_decode. Avec un avarage de près de 1,5 ms à plus de 2,5 ms.

Découvrez les résultats ici (désolé pour le hack de mettre le code PHP dans le code JS à cocher):

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

RÉSULTATS: serialize() et unserialize() sont à la fois beaucoup plus rapide dans le PHP 5.4 sur des tableaux de taille variable.

J'ai fait un script de test sur les données du monde réel pour comparer json_encode vs sérialiser et json_decode vs unserialize. Le test a été exécuté sur le système de mise en cache d'une production de site e-commerce. Il faut simplement les données qui sont déjà dans le cache, et les tests à la fois pour encoder /décoder (ou serialize /unserialize) toutes les données et je l'ai mis dans un format facile à voir le tableau.

J'ai couru ce sur PHP 5.4 serveur d'hébergement mutualisé.

Les résultats ont été très concluants que pour ces grands aux petits ensembles de données serialize et unserialize ont été les grands vainqueurs. En particulier, pour mon cas d'utilisation, la fonction json_decode et unserialize sont les plus importants pour le système de mise en cache. Unserialize était presque omniprésente gagnant ici. Il est généralement de 2 à 4 fois (parfois 6 ou 7 fois) aussi rapide que la fonction 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>

Tout d'abord, j'ai modifié le script pour faire un peu plus de benchmarking (et aussi faire de la 1000 pistes au lieu de simplement 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 version de PHP 7:

PHP 7.0.14 (cli) (construite: Jan 18 2017 19:13:23) ( NTS ) Copyright (c)
1997-2016 Le Groupe PHP Zend Engine v3.0.0, le droit d'Auteur (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 les suivants:

serialize() (gains: 999) était à peu près de 10,98% plus rapide que json_encode()
unserialize() (gains: 987) était à peu près 33.26% plus rapide que la fonction json_decode()
unserialize() (gains: 987) était à peu près 48.35% plus rapide que la matrice de
la fonction json_decode()

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

Si vous imaginez un scénario où vous lecture/écriture de données sérialisées 10x ou plus souvent que vous avez besoin d'envoyer ou de recevoir à partir d'un non-système PHP, vous êtes TOUJOURS préférable d'utiliser serialize/unserialize et l'ont json_encode ou json_decode avant la sérialisation en termes de temps.

THX pour ce cas-test code:

Mes résultats sur le tableau que j'utilise pour la configuration comme la jachère:
JSON codé en 0.0031511783599854 secondes

PHP sérialisé dans 0.0037961006164551 secondes

json_encode() était à peu près 20.47% plus rapide que serialize()
JSON codé en 0.0070841312408447 secondes

PHP sérialisé dans 0.0035839080810547 secondes

unserialize() était à peu près 97.66% plus rapide que json_encode()

Soi - essai sur vos propres données.

Je vous suggère d'utiliser Super Cache, qui est un fichier de mécanisme de cache qui ne l'utiliseront pas json_encode ou serialize. Il est simple à utiliser et très rapide comparé à d'autres PHP mécanisme de Cache.

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