선호하는 방법을 저장하 PHP 배열(json_encode 대 serialize)

Question

나를 저장할 필요가 다차원의 연관 배열에 있는 데이터의 평 파일 캐싱을 위한 목적입니다.수도우 필요로 변환 JSON 으로 사용하기 위해서 웹 앱을 하지만 대부분의 시간이 나는 배열을 사용하여 직접 in PHP.

는 것이 더 효율적으로 배열을 저장 JSON 으로 또는 PHP 직렬화된 배열에서 이 텍스트 파일입니까?봤어요 주위에 그리고 그것의 최신 버전에서 PHP(5.3), json_decode 실제로보다 더 빨리 unserialize.

나는 현재 기대 쪽으로 저장하는 배열 JSON 으로 느낌이 나는 쉽게 읽을 인간이 필요하다면,그것은 모두에서 사용할 수 있습니다 PHP 및 자바스크립트와 매우 약간의 노력,그리고 내가 읽도 수 있습니다른 디코딩(에 대한 확실하지 않 인코딩하지만).

사람이 알아의 함정을?사람은 좋은 벤치마크를 표시하는 성능 이점 중 하나의 방법이 있나요?

Answer 1

우선 순위에 따라 다릅니다.

성능이 당신의 절대 주행 특성이라면, 가장 빠른 것을 사용하십시오. 선택하기 전에 차이점을 완전히 이해했는지 확인하십시오.

• 같지 않은 serialize() UTF-8 문자를 그대로 유지하려면 추가 매개 변수를 추가해야합니다. json_encode($array, JSON_UNESCAPED_UNICODE) (그렇지 않으면 UTF-8 문자를 유니 코드 이스케이프 시퀀스로 변환합니다).
• 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';
}

Answer 2

JSON PHP의 직렬화 형식보다 단순하고 빠르며 사용해야합니다. ~하지 않는 한:

• 당신은 깊게 중첩 된 배열을 저장하고 있습니다.json_decode(): "JSON 인코딩 된 데이터가 127 개의 요소보다 깊다면이 함수는 False를 반환합니다."
• 당신은 올바른 클래스로서 비소화 해야하는 물건을 저장하고 있습니다.
• JSON_DECODE를 지원하지 않는 이전 PHP 버전과 상호 작용하고 있습니다.

Answer 3

이 주제에 대한 블로그 포스트를 썼습니다. "큰 배열을 캐시합니다 : json, serialize 또는 var_export?".이 포스트에서는 Serialize가 소규모에서 큰 크기의 배열에 가장 적합한 선택임을 보여줍니다. 매우 큰 배열 (> 70MB)의 경우 JSON이 더 나은 선택입니다.

Answer 4

당신은 또한에 관심이있을 수 있습니다 https://github.com/phadej/igbinary 제공하는 다른 직렬화'엔진을 위해'PHP.

내 무작위/임의의 성능 수치를 사용하여 PHP5.3.5 에서 64 비트 플랫폼 표시:

JSON:

• JSON 에서 인코딩된 초 2.180496931076
• JSON 디코딩에 초 9.8368630409241
• 직렬화된"문자열"크기:13993

Native 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

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이 더 빨리 인코딩하고 더 작은 문자열을 결과로 결과로 결론 지을 수 있지만 비소화가 더 빠르며 문자열을 해독하는 것이 더 빠릅니다.

Answer 6

궁극적으로 나중에 "포함"하려는 정보를 캐싱하는 경우 사용해 볼 수 있습니다. var_export. 그렇게하면 "Serialize"에서만 인기를 얻지 만 "비문화"가 아닙니다.

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 캐싱 시스템에 대해서는 적합하지 않습니다.

나는 시도했다 apcu 그러나 그것은 필요에 맞지 않았 으며이 경우 메모리는 충분히 신뢰할 수 없습니다. 다음 단계는 직렬화로 파일로 캐시하는 것이 었습니다.

테이블에는 18 개의 열이있는 14355 개의 항목이 있으며 직렬화 된 캐시를 읽는 데있어 테스트 및 통계입니다.

JSON :

모두가 말했듯이, 큰 불편 함 json_encode/json_decode 그것이 모든 것을 변화 시킨다는 것입니다 StdClass 인스턴스 (또는 객체). 반복해야한다면 배열로 변환하는 것은 아마도 할 것입니다. 그렇습니다. 그렇습니다. 변환 시간이 증가하고 있습니다.

평균 시간 : 780.2ms; 메모리 사용 : 41.5MB; 캐시 파일 크기 : 3.8MB

msgpack

@Hutch는 언급합니다 msgpack. 예쁜 웹 사이트. 우리가 시도해 볼까요?

평균 시간 : 497ms; 메모리 사용 : 32MB; 캐시 파일 크기 : 2.8MB

더 좋지만 새로운 확장이 필요합니다. 때때로 두려운 사람들을 컴파일하는 ...

igbinary

@gingerdog 언급 igbinary. 내가 설정했음을 참고하십시오 igbinary.compact_strings=Off파일 크기보다 읽기 성능에 더 관심이 있기 때문입니다.

평균 시간 : 411.4ms; 메모리 사용 : 36.75MB; 캐시 파일 크기 : 3.3MB

MSG 팩보다 낫습니다. 그럼에도 불구하고 이것도 컴파일이 필요합니다.

serialize/unserialize

평균 시간 : 477.2ms; 메모리 사용 : 36.25MB; 캐시 파일 크기 : 5.9MB

JSON보다 더 나은 성능, 배열이 더 크면 느리게 json_decode 그렇습니다. 그러나 당신은 이미 새로운 것입니다.

이러한 외부 확장은 파일 크기를 좁히고 종이에서 훌륭해 보입니다. 숫자는 거짓말하지 않습니다*. 표준 PHP 기능에서 얻은 거의 동일한 결과를 얻는 경우 확장을 컴파일하는 요점은 무엇입니까?

또한 귀하의 요구에 따라 다른 사람과 다른 것을 선택할 것이라고 추론 할 수 있습니다.

• Igbinary는 정말 훌륭하고 Msgpack보다 더 잘 수행됩니다
• Msgpack은 데이터를 압축하는 데 더 좋습니다 (IGBinary Compact.String 옵션을 시도하지 않았 음).
• 컴파일하고 싶지 않습니까? 표준을 사용하십시오.

그것이 바로, 또 다른 직렬화 방법 비교를 선택하는 데 도움이됩니다!

*PHPUNIT 3.7.31, PHP 5.5.10으로 테스트 - 표준 하드 브리브 및 기존 듀얼 코어 CPU로만 디코딩 - 동일한 유스 케이스 테스트에서 평균 숫자가 다를 수 있습니다.

Answer 9

직렬화는 두 가지 이유로 내가 사용할 것 같습니다.

• 누군가는 비소화가 json_decode보다 빠르고 '읽기'케이스가 '쓰기'케이스보다 더 가능성이 있다고 지적했습니다.

• 유효하지 않은 UTF-8 문자로 문자열을 가질 때 json_encode에 문제가있었습니다. 이런 일이 발생하면 문자열이 비어 있으면 정보가 손실됩니다.

Answer 10

나는 모든 종류의 데이터 (String, Null, Integers)를 사용하여 상당히 복잡하고 약간 중첩 된 멀티 하슈에서 이것을 매우 철저히 테스트했으며, Serialize/Bunserialize는 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 11

나는 또한 작은 벤치 마크를 만들었습니다. 내 결과는 동일했습니다. 그러나 디코드 성능이 필요합니다. 위의 몇몇 사람들처럼 내가 말한 것처럼 unserialize 보다 빠릅니다 json_decode. unserialize 약 60-70%를 차지합니다 json_decode 시각. 결론은 상당히 간단합니다. 인코딩에서 성능이 필요할 때 사용하십시오. json_encode, 디코딩 할 때 성능이 필요할 때 사용하십시오 unserialize. 두 기능을 병합 할 수 없으므로 더 많은 성능이 필요한 곳에 선택해야합니다.

의사의 벤치 마크 :

• 임의의 키와 값으로 배열 $ arr 정의
• x <100의 경우; x ++; Serialize 및 JSON_ENCODE ARRAY_RAND의 $ ARR
• y <1000의 경우; Y ++; JSON_DECODE JSON 인코딩 문자열 -Calc Time
• y <1000의 경우; Y ++; 직렬화 된 문자열 -Calc Time을 비평하십시오
• 더 빠른 결과를 반향하십시오

AVARAGE : UNSERIALIZE는 JSON_DECODE의 4 배 이상 96 번 우승했습니다. 2.5ms 이상 약 1.5ms의 avarage.

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

여기에서 결과를 확인하십시오 (JS 코드 상자에 PHP 코드를 넣는 해킹에 대한 죄송합니다) :

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

결과: serialize() 그리고 unserialize() 다양한 크기의 배열에서 PHP 5.4에서 상당히 빠릅니다.

json_encode vs serialize 및 json_decode vs unsserialize를 비교하기 위해 실제 데이터에 대한 테스트 스크립트를 만들었습니다. 테스트는 IN IN Production 전자 상거래 사이트의 캐싱 시스템에서 실행되었습니다. 그것은 단순히 캐시에 이미 데이터를 가져 와서 시간을 테스트하여 모든 데이터를 인코딩 / 디코딩 (또는 직렬화 / 비 서리 화)하고 쉽게 볼 수있는 테이블에 넣습니다.

PHP 5.4 공유 호스팅 서버에서 이것을 실행했습니다.

결과는 이러한 대규모에서 소규모 데이터 세트의 경우 직렬화 및 비 서식 화가 명확한 승자라는 것이 매우 결정적이었습니다. 특히 제 사용 사례의 경우, JSON_DECODE 및 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) (CLI) (빌드 : 2017 년 1 월 18 일 19:13:23) (NTS) 저작권 (C) 1997-2016 PHP 그룹 Zend 엔진 v3.0.0, 저작권 (C) 1998-2016 Zend Opcache와의 Zend Technologies v7.0.14, 저작권 (C) 1999-2016, Zend Technologies

그리고 내 결과는 다음과 같습니다.

Serialize () (Wins : 999)는 json_encode () unsserialize () (Wins : 987)보다 약 10.98% 빠르므로 JSON_DECODE () UNSERIALIZE () (WINS : 987)보다 약 33.26% 더 빠릅니다 (WINS : 987). ()

그래서 분명히, Serialize/Unserialize는입니다 가장 빠른 메소드는 json_encode/decode입니다 가장 휴대용.

비 PHP 시스템에서 보내거나받는 데 필요한 것보다 직렬화 된 데이터를 읽거나 쓰는 시나리오를 고려하는 경우, 직렬화 전에 Serialize/Bonserialize 또는 JSON_DECODE를 사용하는 것이 더 좋습니다. 시간 측면에서.

Answer 16

데이터를 백업하고 다른 컴퓨터에서 또는 FTP를 통해 복원하려면 JSON이 더 좋습니다.

예를 들어 Serialize의 경우 Windows 서버에 데이터를 저장하는 경우 FTP를 통해 데이터를 다운로드하고 Linux에서 복원하여 charachter 재 인코딩으로 인해 더 이상 작동 할 수 없습니다. Serialize는 문자열의 길이와 유니 코드에 저장하기 때문입니다. > UTF-8 1 바이트 charachter를 트랜스 코딩하면 2 바이트가되어 알고리즘 충돌이 발생할 수 있습니다.

Answer 17

THX-이 벤치 마크 코드의 경우 :

구성에 사용하는 배열에 대한 내 결과는 낙하입니다 : JSON은 0.0031511783599854 초
PHP는 0.0037961006164551 초에서 직렬화되었습니다
json_encode() 보다 약 20.47% 더 빠릅니다 serialize()JSON은 0.0070841312408447 초로 인코딩했습니다
PHP는 0.0035839080810547 초에서 직렬화되었습니다
unserialize() 보다 약 97.66% 더 빠릅니다 json_encode()

따라서 - 자신의 데이터로 테스트하십시오.

Answer 18

사람들이 여기서 말하는 내용을 여름을 맞추면 JSON_DECODE/ENCODE는 Serialize/Unserialize보다 빠른 것처럼 보이지만 Var_dump를 사용하면 직렬화 된 객체의 유형이 변경됩니다. 어떤 이유로 든 유형을 유지하려면 Serialize와 함께 가십시오!

(예 : 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로 변환됩니다. 이는 좋지 않은 객체 정보가 손실되었습니다 ... 따라서 필요에 따라 결정하십시오. 특히 배열이 아닌 경우 ...

Answer 19

사용하지 않는 파일 캐시 메커니즘 인 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();
?>