PHP配列を保存するための好ましい方法（json_encodeとserialize）

Question

キャッシングのために多次元連想配列のデータをフラットファイルに格納する必要があります。 Webアプリケーションで使用するためにJSONに変換する必要がある場合もありますが、その大部分はPHPで配列を直接使用します。

このテキストファイルにJSONまたはPHPシリアライズされた配列として配列を格納するほうが効率的ですか？私は見てきましたが、PHP（5.3）の最新バージョンでは、json_decodeはunserializeより実際に速いようです。

必要に応じて人間が読みやすく、PHPとJavaScriptの両方で使うことができ、私が読んだものからJSONとして配列を保存することに傾いています。デコードするほうが速いかもしれません（ただしエンコードについてはよくわかりません）。

誰かが何か落とし穴を知っていますか？どちらかの方法のパフォーマンス上の利点を示すための優れたベンチマークがありますか。

Answer 1

あなたの優先順位によります。

パフォーマンスがあなたの絶対的な運転特性であるならば、それから必ず最速のものを使用してください。選択する前に、違いについて十分に理解していることを確認してください。

• serialize()とは異なり、UTF-8文字を変更しないようにするには、追加のパラメータを追加する必要があります。json_encode($array, JSON_UNESCAPED_UNICODE)（それ以外の場合は、UTF-8文字をUnicodeエスケープシーケンスに変換します）。
• JSONは、オブジェクトの元のクラスが何であるかを記憶しません（それらは常にstdClassのインスタンスとして復元されます）。
• JSONでは__sleep()と__wakeup()を利用できません
• デフォルトでは、パブリックプロパティのみがJSONでシリアル化されています。 （PHP>=5.4では、この動作を変更するために JsonSerializable を実装できます）。
• JSONはよりポータブルです

そして今私が考えることができない他の少数の相違がおそらくある。

2つを比較するための簡単なスピードテスト

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

Answer 2

JSONはPHPのシリアライゼーションフォーマットよりも単純で速いのでexceptを使うべきです：

• 深くネストされた配列を格納しています。 json_decode() ：「この関数は、JSONエンコードデータが127要素よりも深い場合はfalseを返します。」
• 正しいクラスとしてシリアル化解除する必要があるオブジェクトを格納しています
• Json_decodeをサポートしていない古いPHPバージョンとやり取りしています

Answer 3

私はこの話題についてのブログ記事を書きました： " 大きな配列をキャッシュする：JSON、シリアライズ、またはvar_export？ "。この記事では、シリアライズが小規模から大規模のアレイに最適な選択であることを示しています。非常に大きなアレイ（> 70MB）にはJSONがより良い選択です。

Answer 4

あなたは https://github.com/phadej/igbinary にも興味があるかもしれません - それはPHPのための異なる直列化「エンジン」を提供します。

64ビットプラットフォームでPHP 5.3.5を使用した私のランダムな/任意の「パフォーマンス」数値

JSON：

• 2.180496931076秒でエンコードされたJSON
• JSONは9.8368630409241秒でデコードされました
• シリアル化された "文字列"サイズ：13993

ネイティブPHP：

• PHPは2.9125759601593秒でシリアル化されました
• PHPが6.4348418712616秒でシリアル化されない
• シリアル化された "文字列"サイズ：20769

Igbinary：

• 1.6099879741669秒でシリアル化されたWINigbinary
• WINigbinraryが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

Answer 5

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は文字列をデコードするのがより高速です。

Answer 6

もしあなたが最終的に後から "インクルード"したい情報をキャッシュしているのなら、 var_export を使ってみるのが良いかもしれません。そのようにして、あなたは「シリアライズ」でヒットするだけで、「アンシリアライズ」ではヒットしません。

Answer 7

私はテストを拡張して、シリアル化解除のパフォーマンスを含めました。これが私が手に入れた数字です。

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はエンコードは速くなりますが、デコードは遅くなります。それで、それはあなたのアプリケーションとあなたが最もすることを期待するものに依存するかもしれません。

Answer 8

本当にいい話題です、そしていくつかの答えを読んだ後、私は主題に関する私の実験を共有したいです。

データベースと話すたびに「巨大な」テーブルを問い合わせる必要があるというユースケースがありました（理由は問わず、事実だけ）。データベースキャッシュシステムは異なるリクエストをキャッシュしないので適切ではありません。そこで私はphpキャッシュシステムについて考えます。

私はapcuname__を試しましたが、それはニーズに合いませんでした、この場合メモリは十分に信頼できません。次のステップは、直列化を使用してファイルにキャッシュすることでした。

テーブルには18列の14355のエントリがあります。これらはシリアル化されたキャッシュの読み取りに関する私のテストと統計です。

JSON：

皆さんがおっしゃったように、json_encode/json_decodeの大きな不都合は、すべてがStdClassname__インスタンス（またはObject）に変換されることです。ループする必要がある場合は、配列に変換することでおそらく実行できますが、変換時間が長くなります。

平均時間：780.2ミリ秒。メモリ使用量：41.5MB。キャッシュファイルサイズ：3.8MB

メッセージパック

@hutchは msgpack に言及しています。かわいいウェブサイト試してみましょうか。

平均時間：497ミリ秒。メモリ使用量：32メガバイト。キャッシュファイルサイズ：2.8MB

それはいいのですが、新しい拡張が必要です。時々怖い人をコンパイルする...

IgBinary

@GingerDogは igbinary に言及しています。ファイルサイズよりもパフォーマンスの読み取りを重視するので、igbinary.compact_strings=Offを設定したことに注意してください。

平均時間：411.4ミリ秒。メモリ使用量：36.75MB。キャッシュファイルサイズ：3.3MB

Msg packよりも優れています。それでも、これもコンパイルが必要です。

serializename __/unserializename__

平均時間：477.2ミリ秒。メモリ使用量：36.25MB。キャッシュファイルサイズ：5.9MB

JSONよりもパフォーマンスが良いほど、配列が大きいほど、json_decodeは遅くなりますが、それはすでに新しいことです。

これらの外部拡張子はファイルサイズを狭めており、紙の上では素晴らしいようです。数字は嘘をつかない*。標準のPHP関数で得られる結果とほぼ同じ結果が得られたら、拡張機能をコンパイルすることのポイントは何ですか？

また、あなたのニーズに応じて、他の誰かとは違うものを選ぶことになるでしょう。

• IgBinaryは本当にいいし、MsgPackよりもパフォーマンスが良い
• Msgpackはあなたのデータを圧縮するのが得意です（私はigbinary compact.stringオプションを試していなかったことに注意してください）。
• コンパイルしたくないですか？標準を使用してください。

それはそれ、あなたが1つを選ぶのを助けるためのもう一つの直列化方法の比較です！

* PHPUnit 3.7.31、php 5.5.10でテスト済み - 標準のハードドライブと古いデュアルコアCPUでのデコードのみ - 同じ10のユースケーステストでの平均数、あなたの統計は異なるかもしれません

Answer 9

シリアライズのように思えるのは、2つの理由から使用するつもりです。

• 非シリアル化はjson_decodeよりも高速であり、「読み取り」の場合は「書き込み」の場合よりも可能性が高いと誰かが指摘しました。

• 無効なUTF-8文字を含む文字列がある場合、json_encodeに問題がありました。それが起こると、文字列は空になり、情報が失われます。

Answer 10

私も小さなベンチマークを作りました。私の結果は同じでした。しかし、私はデコード性能が必要です。私が気づいたところでは、上記の何人かの人が言ったように、unserializeはjson_decodeより速いです。 unserializeはjson_decode時間の約60-70％かかります。そのため、結論はかなり簡単です。エンコード時にパフォーマンスが必要な場合はjson_encodeを使用し、デコード時にパフォーマンスが必要な場合はunserializeを使用します。 2つの機能をマージすることはできないので、パフォーマンスを向上させる必要がある場合には選択しなければなりません。

擬似的に私のベンチマーク：

• ランダムなキーと値をいくつか使って配列$ arrを定義します。
• ｘ ＜１００の場合。 x ++; $ arrのarray_Randをシリアライズしてjson_encodeします。
• ｙ ＜１０００の場合。 y ++; json_decode jsonでエンコードされた文字列 - 計算時間
• ｙ ＜１０００の場合。 y ++;シリアル化された文字列のシリアル化を解除 - 計算時間
• 速い結果をエコーする

平均すると：unserializeはjson_decodeの4倍のうち96倍を獲得しました。 2.5msの上におよそ1.5msの平均で。

Answer 11

いろいろな種類のデータ（文字列、NULL、整数）を含むかなり複雑で穏やかにネストされたマルチハッシュでこれを非常に徹底的にテストしました、そして直列化/ unserializeは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!';
}

Answer 12

最終的な決定を下す前に、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
)

Answer 13

ここで結果をチェックしてください（PHPコードをJSコードボックスに入れているハックをお詫び申し上げます）。

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

結果：サイズが異なる配列のPHP 5.4では、serialize()とunserialize()の両方がかなり速くなりました。

私は、json_encodeとserialize、およびjson_decodeとunserializeを比較するために、実際のデータに対してテストスクリプトを作成しました。テストは、実稼働中のeコマースサイトのキャッシングシステムで実行されました。それは単に既にキャッシュにあるデータを受け取り、すべてのデータをエンコード/デコード（またはシリアル化/シリアル化解除）する時間をテストし、私はそれを見やすいテーブルに入れます。

私は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>

Answer 14

ほんの一言 - データをJSONのように読みやすく理解しやすいものにシリアライズしたいが、より多くの圧縮とより高いパフォーマンスを得たい場合は、 messagepackをチェックしてください。

Answer 15

まず、スクリプトを変更して、ベンチマークをさらに実行しました（さらに、1回ではなく1000回実行しました）。

<?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）（ビルド日：2017年1月18日19時13分23秒）（NTS）Copyright（c）1997-2016 The 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（）（勝ち率：999）はjson_encode（）よりおおよそ10.98％速いです。unserialize（）（勝率：987）はjson_decode（）よりおおよそ33.26％速かったunserialize（）（勝ち：987）は配列json_decodeより概ね48.35％速かった（）

つまり明らかに、シリアライズ/アンシリアライズは最速のメソッドですが、json_encode/decodeは最も移植性が高いです。

シリアル化されたデータをPHP以外のシステムとの間で送受信する必要があるよりも10倍以上頻繁に読み書きするシナリオを考えている場合は、シリアル化/アンシリアル化を使用してシリアル化の前にjson_encodeまたはjson_decodeを使用するほうがよいでしょう。時間の面で。

Answer 16

THX - このベンチマークコードの場合：

私が設定に使用している配列に関する私の結果は次のとおりです。JSONエンコード0.0031511783599854秒
PHPは0.0037961006164551秒でシリアル化されました
json_encode()は、0.0070841312408447秒でserialize() JSONエンコードよりも約20.47％高速でした
PHPは0.0035839080810547秒でシリアル化されました
unserialize()はjson_encode()より約97.66％高速でした

だから - あなた自身のデータでそれをテストします。

Answer 17

json_encodeやserializeを使用しないファイルキャッシュメカニズムであるSuper Cacheを使用することをお勧めします。それは使いやすく、他の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();
?>

Answer 18

JSONは、データをバックアップして別のマシンまたはFTP経由で復元したい場合に適しています。

たとえば、Windowsサーバにデータを保存し、FTP経由でデータをダウンロードし、Linuxに復元すると、文字の長さがUnicodeに保存されるため、文字の再エンコードのためにこれ以上機能しなくなります。 > 1バイトの文字をUTF-8でトランスコードすると2バイトになり、アルゴリズムがクラッシュする可能性があります。

Answer 19

ここで人々の意見をまとめると、json_decode/encodeはBUTのシリアライズ/アンシリアライズより速いようです。var_dumpを実行すると、シリアライズされたオブジェクトの型が変更されます。何らかの理由で型を保持したい場合は、直列化を使用してください。

（例えばstdClass対配列を試してみてください）

直列化/非直列化：

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に変換しますが、これはあまり良くありません。オブジェクト情報が失われます。特に配列だけではない場合は、ニーズに基づいて決定してください。