Предпочтительный метод хранения массивов PHP (JSON encode vs serialize)

JSON проще и быстрее, чем формат сериализации PHP, и должен использоваться Если:

• вы храните глубоко вложенные массивы: json_decode(): "эта функция вернет false, если закодированные данные JSON глубже 127 элементов."
• вы храните объекты, которые должны необходимо выполнить десериализацию как правильный класс
• вы взаимодействуете со старыми версиями PHP, которые не поддерживают json_decode

Я написал блог на эту тему:"кэшировать большой массив: JSON, serialize или var_export?". В этом посте показано, что сериализация является лучшим выбором для небольших и больших массивов. Для очень больших массивов (> 70MB) JSON-лучший выбор.

вы также можете быть заинтересованы вhttps://github.com/phadej/igbinary - который предоставляет другой "движок" сериализации для PHP.

мои случайные / произвольные "показатели производительности", используя PHP 5.3.5 на 64-битной платформе, показывают:

в формате JSON :

• JSON закодирован в 2.180496931076 секунд
• JSON декодирован в 9.8368630409241 секунд
• сериализованная "строка" размер: 13993

родном языке PHP :

• в PHP по частям в 2.9125759601593 секунд
• PHP unserialized в 6.4348418712616 секунд
• сериализованная "строка" размер: 20769

Igbinary :

• WIN igbinary сериализован в 1.6099879741669 секунд
• WIN igbinrary unserialized в 4,7737920284271 секунд
• WIN сериализованный размер "строка" : 4467

таким образом, быстрее igbinary_serialize() и igbinary_unserialize() и использует меньше места на диске.

Я использовал код fillArray(0, 3), как указано выше, но сделал ключи массива более длинными строками.

igbinary может хранить те же типы данных, что и собственная сериализация PHP (поэтому нет проблем с объектами и т. д.), И вы можете сказать PHP5.3 использовать его для обработки сеанса, если хотите.

Смотрите также http://ilia.ws/files/zendcon_2010_hidden_features.pdf - специфически скольжения 14/15/16

Y только что протестировал сериализованный и JSON кодировать и декодировать, плюс размер он будет принимать строку, хранящуюся.

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 быстрее декодирует строку.

Если вы кэшируете информацию, которую вы в конечном итоге захотите "включить" в более поздний момент времени, вы можете попробовать использовать var_export. Таким образом, вы только попали в "сериализовать" и не в "восстановить".

Я увеличила тестов по производительности десериализации. Вот цифры, которые у меня есть.

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 кажется более быстрым для кодирования, но медленным в декодировании. Таким образом, это может зависеть от вашего приложения и того, что вы ожидаете сделать больше всего.

кажется, что сериализация-это тот, который я собираюсь использовать по 2 причинам:

• кто-то указал, что unserialize быстрее, чем json_decode, и случай "чтения" звучит более вероятным, чем случай "записи".

• У меня были проблемы с json_encode при наличии строк с недопустимыми символами UTF-8. Когда это происходит, строка оказывается пустой, что приводит к потере информации.

действительно хорошая тема, и после прочтения нескольких ответов я хочу поделиться своими экспериментами по этому вопросу.

у меня есть прецедент, когда некоторая "огромная" таблица должна запрашиваться почти каждый раз, когда я говорю с базой данных (не спрашивайте почему, просто факт). Система кэширования базы данных не подходит, поскольку она не будет кэшировать различные запросы, поэтому я подумал о системах кэширования php.

пробовал apcu но это не соответствовало потребностям, память недостаточно надежна в данном случае. Следующий шаг состоял в том, чтобы кэшировать в файл с сериализацией.

таблица имеет 14355 записей с 18 столбцами, это мои тесты и статистика по чтению сериализованного кэша:

JSON:

как вы все сказали, основные неудобства с json_encode/json_decode это то, что он преобразует все в StdClass экземпляр (или объект). Если вам нужно зациклить его, преобразование его в массив-это то, что вы, вероятно, сделаете, и да, это увеличивает время преобразования

среднее время: 780,2 МС; использование памяти: 41,5 Мб; размер файла кэша: 3,8 МБ

Msgpack

@hutch упоминает msgpack. Довольно сайт. Давай попробуем, а?

среднее время: 497 МС; использование памяти: 32 Мб; размер файла кэша: 2.8 Мб

это лучше, но требует нового расширения; компиляция иногда боится людей...

IgBinary

@ GingerDog упоминает igbinary. Обратите внимание, что я установил igbinary.compact_strings=Offпотому что я больше забочусь о чтении выступлений, чем размер файла.

среднее время: 411,4 МС; использование памяти: 36,75 Мб; размер файла кэша: 3,3 МБ

лучше, чем MSG pack. Тем не менее, это тоже требует компиляции.

serialize/unserialize

среднее время: 477,2 МС; использование памяти: 36,25 Мб; размер файла кэша: 5,9 МБ

лучшие спектакли, чем JSON, чем больше массив, тем медленнее json_decode есть, но вы уже новое.

эти внешние расширения сужают размер файла и кажутся отличными на бумаге. Числа не лгут*. Какой смысл компилировать расширение, если вы получаете почти те же результаты, что и со стандартной функцией PHP?

мы также можем сделать вывод, что в зависимости от ваших потребностей вы выберете что-то другое, чем кто-то другой:

• IgBinary действительно хороший и работает лучше, чем MsgPack
• Msgpack лучше сжимает ваши данные (обратите внимание, что я не пробовал igbinary компактный.string option).
• не хотите компилировать? Используйте стандарты.

вот-вот, еще одно сравнение методов сериализации, чтобы помочь вам выбрать один!

*протестировано с PHPUnit 3.7.31, php 5.5.10-только декодирование со стандартным жестким диском и старым двухъядерным процессором-средние числа на 10 одинаковых тестах прецедентов, ваша статистика может быть по-другому

Я очень тщательно протестировал это на довольно сложном, мягко вложенном мульти-хэше со всеми видами данных в нем (строка, нуль, целые числа) и сериализовать/несериализовать оказалось намного быстрее, чем 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!';
}

Я также сделал небольшой тест. Мои результаты были такими же. Но мне нужна производительность декодирования. Где я заметил, как сказали несколько человек выше,unserialize быстрее json_decode. unserialize занимает примерно 60-70% от json_decode времени. Таким образом, вывод довольно прост: Когда вам нужна производительность в кодировке, используйте json_encode, когда нужна производительность при декодировании, используйте unserialize. Поскольку вы не можете объединить две функции, вы должны сделать выбор, где вам нужно больше спектакль.

мой тест в псевдо:

• определить массив $arr с несколькими случайными ключами и значениями
• для x
• для y
• для y
• повторить результат, который был быстрее

на avarage: unserialize выиграл 96 раз более 4 раз json_decode. С средняя примерно 1,5 МС за 2,5 МС.

прежде чем принять окончательное решение, имейте в виду, что формат 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
)

просто fyi -- если вы хотите сериализовать свои данные до чего-то легкого для чтения и понимания, как JSON, но с большим сжатием и более высокой производительностью, вы должны проверить messagepack.

проверьте результаты здесь (Извините за взлом, поставив PHP-код в поле кода JS):

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

результаты: serialize() и unserialize() заметно быстрее в PHP 5.4 на массивах разного размера.

Я сделал тестовый скрипт на реальных данных для сравнения json_encode vs serialize и json_decode vs unserialize. Тест был запущен при кэшировании система сайта электронной коммерции в производстве. Он просто берет данные уже в кэше, и тесты времени для кодирования / декодирования (или сериализовать / восстановить) все данные и я положил его в простой в табл.

я запустил это на PHP 5.4 shared hosting server.

результаты были очень убедительны, что для этих крупных до небольших наборах данных сериализовать и восстановить были явными победителями. В частности, для моего случая использования наиболее важными являются json_decode и unserialize для системы кэширования. Unserialize был почти повсеместным победителем здесь. Обычно это было от 2 до 4 раз (иногда 6 или 7 раз) так же быстро, как json_decode.

интересно отметить разницу в результатах от @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) (built: Jan 18 2017 19:13: 23) (NTS) Авторское право (c) 1997-2016 PHP группа Zend Engine v3.0.0, Copyright (c) 1998-2016 Зенд Технологий с Zend OPcache v7.0.14, Copyright (c) 1999-2016, Zend Technologies

и мои результаты были:

serialize () (wins: 999) был примерно на 10.98% быстрее, чем json_encode() unserialize () (wins: 987) был примерно на 33.26% быстрее, чем json_decode() unserialize () (wins: 987) был примерно на 48,35% быстрее, чем массив json_decode()

Так явно, сериализовать/восстановить-это быстрый метод, в то время как json_encode/decode является самый портативный.

Если вы рассматриваете сценарий, в котором Вы читаете / записываете сериализованные данные 10x или чаще, чем вам нужно отправлять или получать из системы, отличной от PHP, вам все равно лучше использовать сериализацию/несериализацию и иметь ее json_encode или json_decode до сериализации с точки зрения времени.

JSON лучше, если вы хотите сделать резервную копию данных и восстановить их на другой машине или через FTP.

например, с сериализацией если вы храните данные на сервере Windows, загрузите его через FTP и восстановите его на Linux, он больше не может работать из-за повторного кодирования charachter, потому что сериализация хранит длину строк, а в Unicode > UTF-8 транскодирование некоторого 1 байта charachter может стать 2 байта, что приведет к сбою алгоритма.

THX - для этого контрольного кода:

мои результаты по массиву, который я использую для конфигурации, являются паром: JSON закодирован в 0.0031511783599854 секунд
PHP сериализован в 0.0037961006164551 секунд
json_encode() был примерно на 20,47% быстрее, чем serialize() JSON закодирован в 0.0070841312408447 секунд
PHP сериализован за 0.0035839080810547 секунд
unserialize() был примерно на 97,66% быстрее, чем json_encode()

So-проверьте его на своих собственных данных.

Если в результате того, что люди говорят здесь, json_decode/кодировать, кажется, быстрее, чем сериализовать/восстановить, но Если вы делаете var_dump, тип сериализованного объекта изменяется. Если по какой-то причине вы хотите сохранить тип, перейдите к сериализации!

(попробуйте, например, 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, что не так хорошо, информация об объекте потеряна... Так что решайте исходя из потребностей, особенно если это не только массивы...

Я бы предложил вам использовать Super Cache, который является механизмом кэша файлов, который не будет использовать json_encode или serialize. Он прост в использовании и очень быстр по сравнению с другим механизмом кэша 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();
?>