복붙노트

PHP 배열을 저장하는 기본 방법 (json_encode 대 serialize)

PHP

PHP 배열을 저장하는 기본 방법 (json_encode 대 serialize)

필자는 캐싱 목적으로 평면 파일에 다차원 연상 데이터 배열을 저장해야합니다. 가끔 내 웹 앱에서 JSON으로 변환 할 필요가있을 수도 있지만 대다수의 시간은 PHP에서 직접 배열을 사용하게 될 것입니다.

이 텍스트 파일에 배열을 JSON 또는 PHP 직렬 배열로 저장하는 것이 더 효율적입니까? 주위를 둘러 보았고 PHP (5.3)의 최신 버전에서 json_decode가 실제로 unserialize보다 빠릅니다.

저는 현재 JSON으로 배열을 저장하는쪽으로 기울어 있습니다. 필요한 경우 인간이 읽기 쉽다고 느끼기 때문에 PHP와 JavaScript 모두에서 약간의 노력으로 사용할 수 있습니다. 그리고 내가 읽은 것에서는 심지어 그렇게 될 수도 있습니다. 디코딩하기가 더 빠릅니다 (인코딩은 확실하지 않습니다).

누군가 함정에 대해 알고 있습니까? 누구나 두 가지 방법의 성능 이점을 보여줄 수있는 좋은 벤치 마크를 가지고 있습니까?

해결법

  1. ==============================

    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);

// 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';
}
  2. ==============================

    2.JSON은 PHP의 직렬화 형식보다 간단하고 빠르며 다음과 같은 경우를 제외하고 사용해야합니다.

    JSON은 PHP의 직렬화 형식보다 간단하고 빠르며 다음과 같은 경우를 제외하고 사용해야합니다.

  3. ==============================

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

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

  4. ==============================

    4.PHP에 대해 다른 직렬화 엔진을 제공하는 https://github.com/phadej/igbinary에 관심이있을 수도 있습니다.

    PHP에 대해 다른 직렬화 엔진을 제공하는 https://github.com/phadej/igbinary에 관심이있을 수도 있습니다.

    내 임의 / 임의의 '성능'수치, 64 비트 플랫폼에서 PHP 5.3.5를 사용하여 표시 :

    JSON :

    기본 PHP :

    Igbinary :

    따라서 igbinary_serialize () 및 igbinary_unserialize ()가 빠르며 디스크 공간을 덜 사용합니다.

    필자는 위와 같이 fillArray (0, 3) 코드를 사용했지만 배열 키를 더 긴 문자열로 만들었습니다.

    igbinary는 PHP의 네이티브 serialize can (객체 등의 문제는 없음)과 동일한 데이터 유형을 저장할 수 있으며 원할 경우 세션 처리를 위해 PHP5.3을 사용할 수 있습니다.

    http://ilia.ws/files/zendcon_2010_hidden_features.pdf - 특히 슬라이드 14/15/16도 참조하십시오.

  5. ==============================

    5.Y는 방금 serialize 된 json 인코딩 및 디코드를 테스트하고 크기를 더하면 저장된 문자열을 취합니다.

    Y는 방금 serialize 된 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는 문자열을 디코딩하는 것이 더 빠르다고 결론 지을 수 있습니다.

  6. ==============================

    6.궁극적으로 나중에 "include"할 정보를 캐싱하는 경우 var_export를 사용해보십시오. 그런 식으로 "직렬화"에서는 히트를 치고 "비 직렬화"에서는 히트를 취하지 않습니다.

    궁극적으로 나중에 "include"할 정보를 캐싱하는 경우 var_export를 사용해보십시오. 그런 식으로 "직렬화"에서는 히트를 치고 "비 직렬화"에서는 히트를 취하지 않습니다.

  7. ==============================

    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은 인코딩 속도는 더 빠르지 만 디코딩은 느린 것 같습니다. 따라서 응용 프로그램과 가장 많이 할 것으로 예상되는 것에 따라 달라질 수 있습니다.

  8. ==============================

    8.직렬화처럼 보이는 이유는 다음 두 가지 이유 때문입니다.

    직렬화처럼 보이는 이유는 다음 두 가지 이유 때문입니다.

  9. ==============================

    9.정말 좋은 주제이고 몇 가지 답변을 읽은 후에 주제에 대한 실험을 공유하고 싶습니다.

    정말 좋은 주제이고 몇 가지 답변을 읽은 후에 주제에 대한 실험을 공유하고 싶습니다.

    나는 "거대한"테이블이 데이타베이스에 대해 거의 언제나 질의를 받아야하는 유스 케이스를 가지고있다. 왜 그런지 묻지 않는다. 데이터베이스 캐싱 시스템은 다른 요청을 캐시하지 않으므로 적절하지 않습니다. 따라서 PHP 캐싱 시스템에 대해서 생각합니다.

    나는 apcu를 시도했으나 필요에 맞지 않았다.이 경우에는 메모리가 충분하지 않다. 다음 단계는 직렬화 된 파일에 캐시하는 것이 었습니다.

    테이블에는 18 열이있는 14355 개의 항목이 있는데, 이들은 직렬화 된 캐시를 읽는 것에 대한 테스트와 통계입니다.

    모두 말씀 드렸듯이 json_encode / json_decode의 주요 불편은 모든 것을 StdClass 인스턴스 (또는 Object)로 변환한다는 것입니다. 루프로 변환해야한다면 배열로 변환하면됩니다. 그렇다면 변형 시간이 길어질 것입니다.

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

    더 좋지만 새로운 확장이 필요합니다. 때때로 두려워하는 사람들을 편집하는 중 ...

    @GingerDog에 igbinary가 언급되었습니다. 파일 크기보다 읽기 성능이 더 중요하기 때문에 igbinary.compact_strings = Off를 설정했습니다.

    msg 패키지보다 좋습니다. 아직도이 컴파일 작업이 필요합니다.

    JSON보다 성능이 좋을수록 어레이가 더 커지고 느린 json_decode가되지만 이미 새로운 것입니다.

    이러한 외부 확장은 파일 크기를 좁히고 있으며 종이에 위대하게 보인다. 숫자는 거짓말하지 않습니다 *. 표준 PHP 함수로 얻을 수있는 결과와 거의 같은 결과를 얻을 수 있다면 확장 기능을 컴파일해야하는 이유는 무엇입니까?

    우리는 또한 당신의 필요에 따라 다른 누군가와 다른 것을 선택할 것이라고 추론 할 수 있습니다.

    그 중 하나를 선택하는 데 도움이되는 또 다른 직렬화 방법 비교입니다!

    * PHPUnit 3.7.31, PHP 5.5.10로 테스트 - 표준 하드 드라이브 및 구형 듀얼 코어 CPU로만 디코딩 - 동일한 사용 사례 테스트에서 평균 수치, 통계가 다를 수 있음

  10. ==============================

    10.필자는 꽤 복잡하고 가벼운 중첩 된 다중 해시 (문자열, NULL, 정수)가있는 모든 종류의 데이터를 테스트했으며 serialize / unserialize는 json_encode / json_decode보다 훨씬 빠릅니다.

    필자는 꽤 복잡하고 가벼운 중첩 된 다중 해시 (문자열, NULL, 정수)가있는 모든 종류의 데이터를 테스트했으며 serialize / 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!';
}
  11. ==============================

    11.나는 작은 기준을 만들었다. 내 결과는 같았습니다. 하지만 디코딩 성능이 필요합니다. 위의 몇 사람처럼 json_decode보다 unserialize가 빠르다는 것을 알았습니다. unserialize는 json_decode 시간의 대략 60-70 %를 차지합니다. 결론은 매우 간단합니다. 인코딩 할 때 성능이 필요하면 json_encode를 사용하고 디코딩 할 때 성능이 필요할 때 unserialize를 사용하십시오. 두 가지 기능을 병합 할 수 없으므로 더 많은 성능이 필요한 부분을 선택해야합니다.

    나는 작은 기준을 만들었다. 내 결과는 같았습니다. 하지만 디코딩 성능이 필요합니다. 위의 몇 사람처럼 json_decode보다 unserialize가 빠르다는 것을 알았습니다. unserialize는 json_decode 시간의 대략 60-70 %를 차지합니다. 결론은 매우 간단합니다. 인코딩 할 때 성능이 필요하면 json_encode를 사용하고 디코딩 할 때 성능이 필요할 때 unserialize를 사용하십시오. 두 가지 기능을 병합 할 수 없으므로 더 많은 성능이 필요한 부분을 선택해야합니다.

    의사의 내 벤치 마크 :

    평균적으로 : unserialize는 json_decode의 4 배가 넘는 96 배의 승리를 얻었습니다. 2.5ms가 넘는 평균 1.5ms.

  12. ==============================

    12.최종 결정을 내리기 전에 JSON 형식이 연관 배열에 대해 안전하지 않다는 점에 유의하십시오. json_decode ()는 대신 객체로 반환합니다.

    최종 결정을 내리기 전에 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
)
  13. ==============================

    13.단순한 fyi - JSON과 같이 읽기 쉽고 이해하기 쉬운 데이터로 직렬화하고 싶지만 압축률과 성능이 향상되면 messagepack을 확인해야합니다.

    단순한 fyi - JSON과 같이 읽기 쉽고 이해하기 쉬운 데이터로 직렬화하고 싶지만 압축률과 성능이 향상되면 messagepack을 확인해야합니다.

  14. ==============================

    14.여기에서 결과를 확인하십시오 (JS 코드 상자에 PHP 코드를 삽입하는 해킹에 대해 사과드립니다).

    여기에서 결과를 확인하십시오 (JS 코드 상자에 PHP 코드를 삽입하는 해킹에 대해 사과드립니다).

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

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

    나는 json_encode와 serialize 그리고 json_decode와 unserialize를 비교하기위한 실제 데이터에 대한 테스트 스크립트를 만들었다. 테스트는 프로덕션 전자 상거래 사이트의 캐싱 시스템에서 실행되었습니다. 단순히 캐시에있는 데이터를 가져 와서 모든 데이터를 인 코드 / 디코드 (또는 serialize / unserialize)하는 시간을 테스트하여 쉽게 볼 수있는 테이블에 넣습니다.

    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>
  15. ==============================

    15.첫째, 스크립트를 좀 더 벤치마킹하도록 변경했습니다 (또한 1 개 대신 1000 개 실행).

    첫째, 스크립트를 좀 더 벤치마킹하도록 변경했습니다 (또한 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 빌드를 사용했다 :

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

    따라서 serialize / unserialize가 가장 빠른 방법 인 반면 json_encode / decode가 가장 이식성이 좋습니다.

    비 PHP 시스템과주고받는 것보다 직렬화 된 데이터를 10 배 이상 읽고 쓰는 시나리오를 고려한다면 serialize / unserialize를 사용하고 직렬화하기 전에 json_encode 또는 json_decode를 사용하는 것이 더 나을 것입니다 시간의 측면에서.

  16. ==============================

    16.JSON은 데이터를 백업하고 다른 머신이나 FTP를 통해 복원하려는 경우 더 좋습니다.

    JSON은 데이터를 백업하고 다른 머신이나 FTP를 통해 복원하려는 경우 더 좋습니다.

    예를 들어 Windows 서버에 데이터를 저장하는 경우 serialize를 사용하고 FTP를 통해 다운로드 한 다음 Linux에서 복원하십시오. serialize는 문자열의 길이와 유니 코드를 저장하기 때문에 charcher 재 인코딩으로 인해 더 이상 작동하지 않습니다. > UTF-8 트랜스 코딩 일부 1 바이트 문자가 2 바이트 길이가되어 알고리즘이 중단 될 수 있습니다.

  17. ==============================

    17.THX -이 벤치 마크 코드 :

    THX -이 벤치 마크 코드 :

    구성에 사용하는 배열의 결과는 다음과 같습니다. JSON은 0.0031511783599854 초에 인코딩 됨 PHP는 0.0037961006164551 초에 직렬화되었습니다. json_encode ()는 serialize ()보다 약 20.47 % 빠릅니다. JSON은 0.0070841312408447 초에 인코딩 됨 PHP는 0.0035839080810547 초에 직렬화 됨 unserialize ()는 json_encode ()보다 약 97.66 % 빠릅니다.

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

  18. ==============================

    18.사람들이 여기서 말하는 것을 요약하면 json_decode / encode가 serialize / unserialize보다 빠를 것 같지만 var_dump를 수행하면 직렬화 된 객체의 유형이 변경됩니다. 어떤 이유로 유형을 유지하려면 serialize를 사용하십시오.

    사람들이 여기서 말하는 것을 요약하면 json_decode / encode가 serialize / unserialize보다 빠를 것 같지만 var_dump를 수행하면 직렬화 된 객체의 유형이 변경됩니다. 어떤 이유로 유형을 유지하려면 serialize를 사용하십시오.

    (예를 들어 stdClass 대 배열을보십시오)

    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 인코딩 / 디코딩

    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를 모두 stdClass로 변환하는데, 그다지 좋지 않습니다. 객체 정보가 손실되었습니다 ... 그래서 필요에 따라 결정하십시오. 특히 배열 일뿐만 아니라 ...

  19. ==============================

    19.Super Cache는 json_encode를 사용하지 않거나 serialize하는 파일 캐시 메커니즘입니다. 그것은 사용하기 쉽고 다른 PHP 캐시 메커니즘에 비해 정말 빠릅니다.

    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();
?>

    20. from https://stackoverflow.com/questions/804045/preferred-method-to-store-php-arrays-json-encode-vs-serialize by cc-by-sa and MIT license

'PHP' 카테고리의 다른 글

PHP에서 브라우저 언어 감지  (0) 2018.09.09
모바일 장치를 감지하는 가장 간단한 방법  (0) 2018.09.09
Git에서 "서버 버전"을 유지 관리하는 올바른 방법은 무엇입니까? 설정 파일 만 변경하면됩니까?  (0) 2018.09.09
MVC와 비슷한 페이지에서 예쁜 URL을 기반으로 클래스를로드하는 방법은 무엇입니까?  (0) 2018.09.09
HTML 태그를 일반 텍스트로 표시하는 방법  (0) 2018.09.09
,

티스토리툴바