存储PHP数组的首选方法(json_encode vs serialize)

JSON比PHP的序列化格式更简单更快，应该使用除非:

• 你正在存储深嵌套数组: json_decode():“如果JSON编码的数据大于127个元素，这个函数将返回false。”李< / >
• 您存储的对象需要被反序列化为正确的类
• 您正在与不支持json_decode的旧PHP版本进行交互

这取决于你的优先级。

如果性能是你的绝对驾驶特点，那么无论如何要用最快的。在你做出选择之前，一定要充分了解它们之间的差异

• 与serialize()不同，您需要添加额外的参数以保持UTF-8字符不变:json_encode($array, JSON_UNESCAPED_UNICODE)(否则它将UTF-8字符转换为Unicode转义序列)。
• JSON将没有对象的原始类的内存(它们总是恢复为stdClass的实例)。
• 你不能用JSON来利用__sleep()和__wakeup()
• 默认情况下，只有公共属性用JSON序列化。(在PHP>=5.4中，您可以实现JsonSerializable来改变这种行为)。
• JSON更具可移植性

可能还有其他一些不同之处，我现在想不出来。

一个简单的速度测试来比较两者

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

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

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

在做出最终决定之前，请注意JSON格式对于关联数组是不安全的——json_decode()将以对象的形式返回它们:

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

输出是:

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

我对测试进行了扩展，以包括反序列化性能。这是我得到的数字。

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

因此json似乎编码更快，但解码较慢。因此，这可能取决于您的应用程序以及您希望最大限度地实现什么。

似乎serialize是我要使用的一个，有两个原因:

• 有人指出，unserialize比json_decode更快，而且'read' case听起来比'write' case更有可能。

• 当使用无效UTF-8字符的字符串时，我遇到了json_encode的问题。当这种情况发生时，字符串最终为空，导致信息丢失。

Y刚刚测试了serialized和json的encode和decode，加上它将把字符串存储的大小。

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

我们可以得出结论，JSON编码更快，结果字符串更小，但unserialize解码字符串更快。

THX -用于此基准代码:

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

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

我已经在一个相当复杂、嵌套简单、包含各种数据(字符串、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!';
}

您可能还会对https://github.com/phadej/igbinary感兴趣——它为PHP提供了一个不同的序列化“引擎”。

我的随机/任意的“性能”数据，使用PHP 5.3.5在64位平台上显示:

JSON:

• JSON编码在2.180496931076秒
• JSON解码在9.8368630409241秒
• serialized "String" size: 13993

原生PHP:

• PHP在2.9125759601593秒内序列化
• PHP在6.4348418712616秒内反序列化
• 序列化的“字符串”大小:20769

Igbinary:

• 赢得 igbinary序列化在1.6099879741669秒
• 在4.7737920284271秒内未序列化赢得 igbinary
• 赢得序列化“字符串”大小:4467

因此，igbinary_serialize()和igbinary_unserialize()更快，使用更少的磁盘空间。

我使用fillArray(0,3)代码，但使数组键更长的字符串。

igbinary可以存储与PHP原生序列化相同的数据类型(所以对象等没有问题)，如果你愿意，你可以告诉PHP5.3使用它来进行会话处理。

参见http://ilia.ws/files/zendcon_2010_hidden_features.pdf -特别是幻灯片14/15/16

如果您想在不同的机器上或通过FTP备份数据和恢复数据，JSON更好。

例如，serialize如果你在Windows服务器上存储数据，通过FTP下载并将其恢复到Linux服务器上，由于字符重新编码，它不能再工作了，因为serialize存储字符串的长度，并且在Unicode > UTF-8转码中，一些1字节的字符可能会变成2字节长，使算法崩溃。

我在pseudo中的基准:

• 用一些随机键和值定义数组$arr
• 对于x <100;x + +;序列化和json_encode $arr的array_rand
• 对于y <1000;y + +;Json_decode json编码的string - calc时间
• 对于y <1000;y + +;取消序列化的string - calc时间
• 回声更快的结果

平均而言:unserialize赢得了96次胜过json_decode的4次。平均约1.5ms超过2.5ms。

仅供参考——如果你想将数据序列化为易于阅读和理解的格式，如JSON，但具有更多的压缩和更高的性能，你应该检查messagepack。

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

我有一个用例，其中一些“巨大”;表需要查询几乎每次我与数据库(不要问为什么，只是一个事实)。数据库缓存系统是不合适的，因为它不会缓存不同的请求，所以我想到了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。注意，我设置了# eyz0，因为我更关心读取性能而不是文件大小。

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

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

# EYZ0 / # EYZ1

平均时间: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代码放在JS代码框中):

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

结果:在PHP 5.4中，serialize()和unserialize()在不同大小的数组上都明显更快。

我在真实世界的数据上做了一个测试脚本，比较json_encode vs serialize和json_decode vs unserialize。测试是在一个生产中的电子商务网站的缓存系统上运行的。它只是获取缓存中已经存在的数据，并测试编码/解码(或序列化/反序列化)所有数据的时间，然后我将其放入一个易于查看的表中。

我在PHP 5.4共享托管服务器上运行了这个程序。

结果是非常结论性的，对于这些大到小的数据集，序列化和非序列化是明显的赢家。特别是对于我的用例，json_decode和unserialize对于缓存系统是最重要的。在这里，Unserialize几乎是一个无处不在的赢家。它的速度通常是json_decode的2到4倍(有时是6或7倍)。

有趣的是，@peter-bailey的结果有所不同。

下面是用于生成结果的PHP代码:

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

首先，我修改了脚本，做了更多的基准测试(也做了1000次而不是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';
}

我使用PHP 7的这个版本:

PHP 7.0.14 (cli)(已构建:Jan 18 2017 19:13:23) (NTS)版权所有(c) PHP Group Zend Engine v3.0.0，版权所有(c) 1998-2016 Zend技术 Zend OPcache v7.0.14，版权所有(c) 1999-2016，由Zend Technologies

我的结果是:

serialize()(赢:999)大约比json_encode()快10.98% Unserialize()(胜:987)大约比json_decode()快33.26% Unserialize()(胜:987)大约比array快48.35% json_decode () < / p >

因此，很明显, serialize/unserialize是最快方法，而json_encode/decode是大多数便携式。方法

如果您考虑这样一个场景:您读/写序列化数据的次数是向非php系统发送数据或从非php系统接收数据的次数的10倍或更多，那么就时间而言，最好还是使用序列化/反序列化，并在序列化之前使用json_encode或json_decode。

(例如stdClass vs array)

序列化/非系列化:

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编码/解码

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]

正如你所看到的json_encode/decode将所有转换为stdClass，这不是很好，对象信息丢失…所以根据需要来决定，特别是如果它不仅仅是数组……

我建议你使用超级缓存，这是一种文件缓存机制，不会使用json_encode或serialize。与其他PHP缓存机制相比，它使用简单，速度非常快。

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

例:

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

我知道这有点晚了，但答案很旧，我想我的基准测试可能会有帮助，因为我刚刚在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 Time: 6.2793469429016

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

JSON解码时间:1.7493588924408 UnSerialize Time: 0.19309520721436 Var Export and Include: 3.1974139213562