THX -用于此基准代码:

我的结果对阵列我使用的配置是休耕: JSON编码在0.0031511783599854秒 PHP在0.0037961006164551秒内序列化 Json_encode()比serialize()快20.47% JSON编码在0.0070841312408447秒 PHP在0.0035839080810547秒内序列化 Unserialize()比json_encode()快97.66%

用你自己的数据进行测试。

我曾经写过一篇关于这个主题的博文:“缓存一个大数组:JSON，序列化还是var_export?”在这篇文章中，我们展示了序列化是大小数组的最佳选择。对于非常大的数组(> 70MB)， JSON是更好的选择。

我已经在一个相当复杂、嵌套简单、包含各种数据(字符串、NULL、整数)的多散列上对此进行了非常彻底的测试，序列化/反序列化最终比json_encode/json_decode快得多。

在我的测试中，json的唯一优势是它的“打包”大小更小。

这些都是在PHP 5.3.3下完成的，如果你想了解更多细节，请告诉我。

下面是测试结果，然后是生成它们的代码。我不能提供测试数据，因为它会泄露一些我不能公开的信息。

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

如果您正在缓存的信息最终希望在稍后的时间点“包含”，那么您可能希望尝试使用var_export。这样你只在“序列化”中受到打击，而不是在“反序列化”中受到打击。

真是个不错的话题，在看了几个答案后，我想分享我在这个问题上的实验。

我有一个用例，几乎每次与数据库对话时都需要查询一些“巨大的”表(不要问为什么，只是一个事实)。数据库缓存系统是不合适的，因为它不会缓存不同的请求，所以我想到了php缓存系统。

我尝试了apcu，但它不符合需求，内存在这种情况下不够可靠。下一步是通过序列化将缓存到文件中。

表有14355个条目，有18列，这些是我的测试和读取序列化缓存的统计:

JSON:

正如大家所说，json_encode/json_decode的主要不便之处在于它将所有内容转换为StdClass实例(或对象)。如果你需要循环它，你可能会把它转换成一个数组，是的，这会增加转换时间

平均时间:780.2 ms;内存使用:41.5MB;缓存文件大小:3.8MB

Msgpack

@hutch提到了msgpack。漂亮的网站。让我们试一试，好吗?

平均时间:497 ms;内存使用:32MB;缓存文件大小:2.8MB

这样好多了，但需要一个新的扩展;编译有时害怕的人…

IgBinary

@GingerDog提到了igbinary。注意，我设置了igbinary.compact_strings= off，因为我更关心读取性能而不是文件大小。

平均时间:411.4 ms;内存使用:36.75MB;缓存文件大小:3.3MB

比味精包装好。不过，这个也需要编译。

系列化/非系列化

平均时间:477.2 ms;内存使用:36.25MB;缓存文件大小:5.9MB

比JSON更好的性能，数组越大，json_decode就越慢，但你已经知道了。

这些外部扩展缩小了文件大小，在纸上看起来很棒。数字不会说谎。如果您得到的结果与使用标准PHP函数得到的结果几乎相同，那么编译扩展还有什么意义呢?

我们还可以推断出，根据你的需求，你会选择与别人不同的东西:

IgBinary真的很好，比MsgPack执行得更好 Msgpack更擅长压缩数据(注意，我没有尝试igbinary 紧凑。字符串选项)。 不想编译?使用标准。

就是这样，另一个序列化方法的比较，帮助您选择一个!

*使用PHPUnit 3.7.31测试，php 5.5.10 -仅使用标准硬盘和旧双核CPU解码- 10个相同用例测试的平均数字，您的统计数据可能不同

我知道这有点晚了，但答案很旧，我想我的基准测试可能会有帮助，因为我刚刚在PHP 7.4中测试过

Serialize/Unserialize比JSON快得多，占用的内存和空间更少，在PHP 7.4中完全胜出，但我不确定我的测试是最有效或最好的。

我基本上创建了一个PHP文件，它返回一个数组，我编码，序列化，然后解码和反序列化。

$array = include __DIR__.'/../tests/data/dao/testfiles/testArray.php';

//JSON ENCODE
$json_encode_memory_start = memory_get_usage();
$json_encode_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $encoded = json_encode($array);
}

$json_encode_time_end = microtime(true);
$json_encode_memory_end = memory_get_usage();
$json_encode_time = $json_encode_time_end - $json_encode_time_start;
$json_encode_memory = 
$json_encode_memory_end - $json_encode_memory_start;


//SERIALIZE
$serialize_memory_start = memory_get_usage();
$serialize_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $serialized = serialize($array);
}

$serialize_time_end = microtime(true);
$serialize_memory_end = memory_get_usage();
$serialize_time = $serialize_time_end - $serialize_time_start;
$serialize_memory = $serialize_memory_end - $serialize_memory_start;


//Write to file time:
$fpc_memory_start = memory_get_usage();
$fpc_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $fpc_bytes = 
    file_put_contents(
        __DIR__.'/../tests/data/dao/testOneBigFile',
        '<?php return '.var_export($array,true).' ?>;'
    );
}

$fpc_time_end = microtime(true);
$fpc_memory_end = memory_get_usage();
$fpc_time = $fpc_time_end - $fpc_time_start;
$fpc_memory = $fpc_memory_end - $fpc_memory_start;


//JSON DECODE
$json_decode_memory_start = memory_get_usage();
$json_decode_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $decoded = json_encode($encoded);
}

$json_decode_time_end = microtime(true);
$json_decode_memory_end = memory_get_usage();
$json_decode_time = $json_decode_time_end - $json_decode_time_start;
$json_decode_memory = 
$json_decode_memory_end - $json_decode_memory_start;


//UNSERIALIZE
$unserialize_memory_start = memory_get_usage();
$unserialize_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $unserialized = unserialize($serialized);
}

$unserialize_time_end = microtime(true);
$unserialize_memory_end = memory_get_usage();
$unserialize_time = $unserialize_time_end - $unserialize_time_start;
$unserialize_memory = 
$unserialize_memory_end - $unserialize_memory_start;


//GET FROM VAR EXPORT:
$var_export_memory_start = memory_get_usage();
$var_export_time_start = microtime(true);

for ($i=0; $i < 20000; $i++) { 
    $array = include __DIR__.'/../tests/data/dao/testOneBigFile';
}

$var_export_time_end = microtime(true);
$var_export_memory_end = memory_get_usage();
$var_export_time = $var_export_time_end - $var_export_time_start;
$var_export_memory = $var_export_memory_end - $var_export_memory_start;

结果:

Var输出长度:11447 序列化长度:11541 Json编码长度:11895 文件放内容字节:11464

Json编码时间:1.9197590351105 序列化时间:0.160325050354 FPC时间:6.2793469429016

Json编码内存:12288 序列化内存:12288 FPC内存:0

JSON解码时间:1.7493588924408 UnSerialize Time: 0.19309520721436 Var导出和包括:3.1974139213562

JSON解码内存:16384 反序列化内存:14360 Var Export and Include: 192