Предпочтительный метод для хранения массивов PHP (json_encode vs serialize)
Эта функция, вероятно, более эффективна для вещественных сигналов. Он использует rfft и zero pad для входов с мощностью 2, достаточной для обеспечения линейной (т.е. некруглой) корреляции:
def rfft_xcorr(x, y):
M = len(x) + len(y) - 1
N = 2 ** int(np.ceil(np.log2(M)))
X = np.fft.rfft(x, N)
Y = np.fft.rfft(y, N)
cxy = np.fft.irfft(X * np.conj(Y))
cxy = np.hstack((cxy[:len(x)], cxy[N-len(y)+1:]))
return cxy
Возвращаемое значение - длина M = len(x) + len(y) - 1 (взломанная вместе с hstack, чтобы удалить дополнительные нули от округления до степени 2). Неотрицательные лаги - cxy[0], cxy[1], ..., cxy[len(x)-1], а отрицательные лаги - cxy[-1], cxy[-2], ..., cxy[-len(y)+1].
Чтобы сопоставить опорный сигнал, я вычислил rfft_xcorr(x, ref) и искал пик. Например:
def match(x, ref):
cxy = rfft_xcorr(x, ref)
index = np.argmax(cxy)
if index < len(x):
return index
else: # negative lag
return index - len(cxy)
In [1]: ref = np.array([1,2,3,4,5])
In [2]: x = np.hstack(([2,-3,9], 1.5 * ref, [0,3,8]))
In [3]: match(x, ref)
Out[3]: 3
In [4]: x = np.hstack((1.5 * ref, [0,3,8], [2,-3,-9]))
In [5]: match(x, ref)
Out[5]: 0
In [6]: x = np.hstack((1.5 * ref[1:], [0,3,8], [2,-3,-9,1]))
In [7]: match(x, ref)
Out[7]: -1
Это не надежный способ согласования сигналов, но это быстро и просто.
11 ответов
Depends on your priorities.
If performance is your absolute driving characteristic, then by all means use the fastest one. Just make sure you have a full understanding of the differences before you make a choice
- Unlike
serialize()you need to add extra parameter to keep UTF-8 characters untouched:json_encode($array, JSON_UNESCAPED_UNICODE)(otherwise it converts UTF-8 characters to Unicode escape sequences). - JSON will have no memory of what the object's original class was (they are always restored as instances of stdClass).
- You can't leverage
__sleep()and__wakeup()with JSON - By default, only public properties are serialized with JSON. (in
PHP>=5.4you can implement JsonSerializable to change this behavior). - JSON is more portable
And there's probably a few other differences I can't think of at the moment.
A simple speed test to compare the two
<?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';
}
Если подытожить, что люди здесь говорят, json_decode / encode кажется быстрее, чем сериализация / десериализация, НО Если вы сделаете var_dump, тип сериализованного объекта будет изменен. Если по какой-то причине вы хотите сохранить тип, переходите к serialize!
(попробуйте, например, stdClass vs array)
serialize / unserialize:
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 encode / decode
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 лучше, если вы хотите сделать резервную копию данных и восстановить их на другом компьютере или через FTP.
Например, при использовании serialize, если вы храните данные на сервере Windows, загружаете их по FTP и восстанавливаете на Linux, на которых они больше не могут работать из-за перекодирования charachter, поскольку serialize хранит длину строк и в транскодировании Unicode> UTF-8 некоторый 1-байтовый символ может иметь длину 2 байта, что приводит к сбою алгоритма.
JSON is simpler and faster than PHP's serialization format and should be used unless:
- You're storing deeply nested arrays:
json_decode (): «Эта функция будет возвращать false, если данные в кодировке JSON глубже 127 элементов.» - Вы сохраняете объекты, которые должны быть не сериализованы как правильный класс
- Вы ' взаимодействует со старыми версиями PHP, которые не поддерживают json_decode
Если вы кешируете информацию, которую в конечном итоге захотите «включить» на более позднем этапе, вы можете захотеть попробовать использовать var_export . Таким образом, вы получаете удар только в «сериализации», а не в «сериализации».
Я написал сообщение в блоге на эту тему: « Кэшировать большой массив: JSON, сериализовать или var_export? ». В этом посте показано, что сериализация - лучший выбор для массивов малого и большого размера. Для очень больших массивов (> 70 МБ) 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
)
I augmented the test to include unserialization performance. Here are the numbers I got.
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()
So json seems to be faster for encoding but slow in decoding. So it could depend upon your application and what you expect to do the most.
Похоже, что я собираюсь использовать serialize по двум причинам:
Кто-то указал, что unserialize быстрее, чем json_decode, и случай "чтения" звучит более вероятным, чем случай "записи".
У меня были проблемы с json_encode, когда у меня были строки с недопустимыми символами UTF-8. Когда это происходит, строка оказывается пустой, что приводит к потере информации.
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 быстрее декодирует строку.
THX - для этого кода теста:
Мои результаты по массиву, который я использую для конфигурации, ошибочны:
JSON закодирован за 0,0031511783599854 секунды
PHP, сериализованный за 0,0037961006164551 секунды
json_encode () был примерно на 20,47% быстрее, чем serialize ()
JSON закодирован за 0,0070841312408447 секунд
PHP, сериализованный за 0,0035839080810547 секунд
unserialize () , был примерно 97.На 66% быстрее, чем json_encode ()
Итак - протестируйте его на своих данных.