it-swarm.com.ru

Предпочитаемый способ хранения PHP массивы (json_encode против сериализации)

Мне нужно хранить многомерный ассоциативный массив данных в плоский файл для целей кэширования. Иногда я могу столкнуться с необходимостью конвертировать его в JSON для использования в моем веб-приложении, но в большинстве случаев я буду использовать массив непосредственно в PHP.

Будет ли эффективнее хранить массив в виде JSON или сериализованного массива PHP в этом текстовом файле? Я огляделся вокруг, и кажется, что в новейших версиях PHP (5.3) json_decode на самом деле быстрее, чем unserialize.

В настоящее время я склоняюсь к сохранению массива в формате JSON, так как считаю, что его легче читать человеку, при необходимости, он может быть использован как в PHP, так и в JavaScript без особых усилий, и из того, что я прочитал, это может даже быть быстрее для декодирования (хотя не уверен насчет кодирования).

Кто-нибудь знает какие-либо подводные камни? У кого-нибудь есть хорошие тесты, чтобы показать преимущества производительности любого метода?

571
KyleFarris

Зависит от ваших приоритетов.

Если производительность является вашей абсолютной характеристикой вождения, то обязательно используйте самую быструю. Просто убедитесь, что у вас есть полное понимание различий, прежде чем сделать выбор

  • В отличие от serialize() вам нужно добавить дополнительный параметр, чтобы символы UTF-8 оставались нетронутыми: json_encode($array, JSON_UNESCAPED_UNICODE) (в противном случае он преобразует символы UTF-8 в escape-последовательности Unicode).
  • У JSON не будет памяти о том, каким был исходный класс объекта (они всегда восстанавливаются как экземпляры stdClass).
  • Вы не можете использовать __sleep() и __wakeup() с JSON
  • По умолчанию только открытые свойства сериализуются с помощью 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';
}
534
Peter Bailey

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

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

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

58
Taco

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

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

JSON:

  • JSON закодирован за 2,180496931076 секунд
  • JSON расшифровывается за 9,8368630409241 секунд
  • сериализованный размер "String": 13993

Родной PHP:

  • PHP сериализован за 2,9125759601593 секунд
  • PHP не сериализован за 6,4348418712616 секунд
  • сериализованный "String" размер: 20769

Игбинар:

  • WIN igbinary сериализован за 1.6099879741669 секунд
  • WIN Игровая библиотека не сериализована за 4,7737920284271 секунд.
  • WIN сериализованный "String" Размер: 4467

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

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

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

Смотрите также http://ilia.ws/files/zendcon_2010_hidden_features.pdf - конкретно слайды 14/15/16

51
David Goodwin

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

24
Blunk

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

15
Jordan S. Jones

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

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

11
Jeff Whiting

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

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

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

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

JSON:

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

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

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 Compact.string).
  • Не хотите компилировать? Используйте стандарты.

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

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

8
soyuka

Похоже, я буду использовать serialize по двум причинам:

  • Кто-то отметил, что десериализация выполняется быстрее, чем json_decode, и случай «чтения» звучит более вероятно, чем случай «записи».

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

8
urraka

Я очень тщательно протестировал это на довольно сложном, слегка вложенном мульти-хэше со всеми видами данных (строка, 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!';
}
6
Mr. Sox

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

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

  • Определите массив $ arr с несколькими случайными ключами и значениями
  • для х <100; х ++; сериализовать и json_encode массив_Rand $ arr
  • для у <1000; у ++; json_decode строка в кодировке json - время расчета
  • для у <1000; у ++; десериализовать сериализованную строку - время расчета
  • повторить результат, который был быстрее

На avarage: unserialize выиграл 96 раз по сравнению с 4-кратным json_decode. С средним значением 1,5 мс над 2,5 мс.

5
Jelmer

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

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

1
Hutch

Во-первых, я изменил скрипт, чтобы сделать еще несколько тестов (а также сделать 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) (сборка: 18 января 2017 г. 19:13:23) (NTS) Copyright (c) 1997-2016 PHP Group Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies с Zend OPcache v7.0.14, Copyright (c) 1999-2016, Zend Technologies

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

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

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

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

1
Shawn Tolidano

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

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

РЕЗУЛЬТАТЫ: serialize() и unserialize() значительно быстрее в PHP 5.4 для массивов различного размера.

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

Я запустил это на PHP 5.4 сервере общего хостинга.

Результаты были очень убедительными, что для этих больших и малых наборов данных сериализация и десериализация были явными победителями. В частности, для моего случая использования 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>
1
newms87

THX - для этого кода теста:

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

Так что - проверьте это на своих данных.

0
mk182

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

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

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

0
Informate.it

Если суммировать то, что люди здесь говорят, json_decode/encode кажется быстрее, чем сериализация/десериализация, НО Если вы делаете 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, что не очень хорошо, информация об объекте теряется ... Так что решайте исходя из потребностей, особенно если это не только массивы ...

0
David Constantine