método preferido de matrizes de armazenamento de PHP (json_encode vs serializar)

Question

Eu preciso armazenar uma matriz associativa multidimensional dos dados em um arquivo simples para fins de armazenamento em cache. I podem, ocasionalmente, se deparar com a necessidade de convertê-lo em JSON para uso em meu aplicativo web, mas a grande maioria do tempo eu vou estar usando a matriz diretamente no PHP.

Seria mais eficiente para armazenar a matriz como JSON ou como uma matriz serializada PHP neste arquivo de texto? Eu olhei ao redor e parece que nas versões mais recentes do PHP (5.3), json_decode é realmente mais rápido do que unserialize.

Atualmente estou inclinado para armazenar a matriz como JSON como eu sinto a sua mais fácil de ler por um ser humano, se necessário, ele pode ser usado tanto em PHP e JavaScript com muito pouco esforço, e pelo que eu li, ele pode até ser mais rápido para decodificar (não tenho certeza sobre codificação, embora).

Alguém sabe de qualquer armadilhas? Alguém tem boas referências para mostrar os benefícios de um ou outro método de desempenho?

Answer 1

Depende das suas prioridades.

Se o desempenho é a sua característica de condução absoluta, então por todos os meios utilizar o mais rápido. Apenas certifique-se que você tem um completo entendimento das diferenças antes de fazer uma escolha

• serialize() Ao contrário de você precisa adicionar parâmetro extra para manter caracteres UTF-8 intocado:. json_encode($array, JSON_UNESCAPED_UNICODE) (caso contrário, ele converte caracteres UTF-8 para seqüências de escape Unicode)
• JSON terá nenhuma memória do que classe original do objeto era (eles estão sempre restaurado como instâncias de stdClass).
• Você não pode alavancagem __sleep() e __wakeup() com JSON
• Por padrão, apenas as propriedades públicas são serializados com JSON. (Em PHP>=5.4 você pode implementar JsonSerializable para alterar esse comportamento).
• JSON é mais portátil

E há provavelmente algumas outras diferenças que eu não posso pensar de neste momento.

Um teste de velocidade simples para comparar os dois

<?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 é mais simples e mais rápido do que o formato de serialização do PHP e deve ser usado a menos :

• Você está armazenando matrizes profundamente aninhadas: json_decode() : "Esta função retornará false se o JSON dados codificados é mais profundo do que 127 elementos"
• Você está armazenando objetos que precisam ser desserializados como a classe correta
• Você está interagindo com versões do PHP antigos que não suportam json_decode

Answer 3

Eu escrevi um blogpost sobre este assunto: " cache uma grande variedade: JSON, serialize ou var_export ?". Neste post, é mostrado que serialize é a melhor escolha para pequenas e grandes matrizes de tamanho. Para matrizes muito grandes (> 70MB) JSON é a melhor escolha.

Answer 4

Você pode também estar interessado em https://github.com/phadej/igbinary - que fornece uma serialização 'motor' diferente para PHP.

As minhas arbitrárias números aleatórios / 'performance', usando PHP 5.3.5 em um show plataforma de 64 bits:

JSON:

• JSON codificado em 2.180496931076 segundos
• JSON decodificado em 9.8368630409241 segundos
• serializado "String" size: 13993

Native PHP:

• PHP serializado em 2.9125759601593 segundos
• PHP desserializados em 6.4348418712616 segundos
• serializado "String" size: 20769

Igbinary:

• WIN igbinary serializado em 1.6099879741669 segundos
• WIN igbinrary desserializado em 4.7737920284271 segundos
• WIN serializado "String" Tamanho: 4467

Assim, é mais rápido para igbinary_serialize () e igbinary_unserialize () e usa menos espaço em disco.

I utilizado o FillArray (0, 3) de código como acima, mas feitas as chaves de matriz cadeias mais longas.

igbinary pode armazenar os mesmos tipos de dados como serialize nativa do PHP pode (Então não há problema com objetos etc) e você pode dizer PHP5.3 usá-lo para manipulação de sessão se assim o desejar.

Veja também http://ilia.ws/files/zendcon_2010_hidden_features.pdf - especificamente diapositivos 14/15/16

Answer 5

Y apenas testado serializado e codificar e decodificar json, mais o tamanho que levará a string armazenada.

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

Podemos concluir que JSON codifica mais rápido e resulta uma corda menor, mas unserialize é mais rápido para decodificar a string.

Answer 6

Se você está cache de informações que você acabará por querer "incluir" em um ponto posterior no tempo, você pode querer tentar usar var_export . Dessa forma, você só pode tomar o hit no "serialize" e não no "unserialize".

Answer 7

I aumentou o teste para incluir desempenho desserialização. Aqui estão os números que eu tenho.

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

Assim json parece ser mais rápido para codificar mas lento na decodificação. Assim, poderia depender da sua aplicação e o que você espera para fazer mais.

Answer 8

Realmente bom tema e depois de ler algumas respostas, eu quero compartilhar minhas experiências sobre o assunto.

Eu tenho um caso de uso onde alguns "grandes" necessidades de mesa a ser consultado quase toda vez que eu falar com o banco de dados (não pergunte por que, apenas um fato). O sistema de cache do banco de dados não é apropriado, pois não vai armazenar em cache os diferentes pedidos, então eu embora sobre sistemas php cache.

Eu tentei apcu mas não se adequar às necessidades, a memória não é confiável o suficiente neste caso. O passo seguinte foi para o cache em um arquivo com a serialização.

Table tem 14355 entradas com 18 colunas, esses são os meus testes e estatísticas sobre a leitura do cache serializado:

JSON:

Como todos disse, o grande inconveniente com json_encode / json_decode é que ele transforma tudo a uma instância StdClass (ou objeto). Se você precisa de loop-lo, transformando-o em uma matriz é o que você provavelmente vai fazer, e sim é o aumento do tempo de transformação

tempo médio: 780,2 ms; uso de memória: 41.5MB; tamanho do arquivo de cache: 3,8MB

Msgpack

@hutch menciona msgpack . website Pretty. Vamos dar-lhe uma tentativa vamos?

tempo médio: 497 ms; uso de memória: 32MB; tamanho do arquivo de cache: 2,8MB

Assim é melhor, mas exige uma nova extensão; compilar as pessoas às vezes com medo ...

IgBinary

@GingerDog menciona igbinary . Note que eu definir o igbinary.compact_strings=Offbecause me preocupo mais com a leitura performances do que o tamanho do arquivo.

tempo médio: 411,4 ms; uso de memória: 36.75MB; tamanho do arquivo de cache: 3,3MB

Melhor do pacote msg. Ainda assim, este requer compilação também.

serialize / unserialize

tempo médio: 477,2 ms; uso de memória: 36.25MB; tamanho do arquivo de cache: 5.9MB

desempenhos melhores do que JSON, maior a matriz já é, mais lento json_decode é, mas você nova disso.

Estas extensões externas estão estreitando o tamanho do arquivo e parece ótimo no papel. Os números não mentem *. Qual é o ponto de compilar uma extensão se você ficar quase os mesmos resultados que você teria com uma função PHP padrão?

Nós também podemos deduzir que, dependendo de suas necessidades, você vai escolher diferente algo que outra pessoa:

• IgBinary é realmente agradável e executa melhor do que MsgPack
• Msgpack é melhor para comprimir seus dados (note que eu não tentei o igbinary opção compact.string).
• Não quero compilar? Use padrões.

É isso aí, outra comparação métodos de serialização para ajudar você a escolher o caminho!

* Testado com PHPUnit 3.7.31, PHP 5.5.10 - única decodificação com um CPU dual core hardrive e padrão antigo - números médios em 10 mesmos testes de caso de uso, suas estatísticas pode ser diferente

Answer 9

Parece que serialize é o que eu vou usar por 2 motivos:

• Alguém apontou que unserialize é mais rápido que json_decode e um 'ler' sons de caso mais provável do que um caso de 'escrever'.

• Eu tive problemas com json_encode ao ter cordas com inválidos UTF-8 caracteres. Quando isso acontece as extremidades da corda sendo vazia causar perda de informações.

Answer 10

Eu testei isso muito cuidadosamente em um bastante complexo, levemente aninhados multi-hash com todos os tipos de dados nele (String, null, inteiros), e serialize / unserialize acabou muito mais rápido do que json_encode / json_decode.

A única vantagem JSON ter em meus testes foi ele é menor 'embalado' tamanho.

Estas são feitas sob PHP 5.3.3, deixe-me saber se você quer mais detalhes.

Aqui estão os resultados de testes, em seguida, o código para produzi-los. Eu não pode fornecer os dados de teste, uma vez que iria revelar informações que não posso deixar de ir para fora no selvagem.

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

Eu fiz uma pequena referência também. Meus resultados foram os mesmos. Mas eu preciso do desempenho de decodificação. Onde eu notei, como algumas pessoas acima disse, bem, unserialize é mais rápido que json_decode. unserialize leva cerca de 60-70% do tempo json_decode. Portanto, a conclusão é bastante simples: Quando você precisar de desempenho na codificação, o uso json_encode, quando você precisa de desempenho ao decodificar, o uso unserialize. Porque você não pode mesclar as duas funções que você tem que fazer uma escolha onde você precisa de mais desempenho.

Meu referência em pseudo:

• Definir array $ arr com algumas chaves aleatórias e valores
• para x <100; x ++; serialize e json_encode um array_rand de US $ arr
• para y <1000; y ++; json_decode o JSON string codificada - time calc
• para y <1000; y ++; unserialize a string serializada - time calc
• ecoar o resultado que foi mais rápido

Em avarage: won unserialize 96 vezes mais de 4 vezes o json_decode. Com um avarage de 1.5ms aproximadamente mais de 2,5 ms.

Answer 12

Antes de fazer sua decisão final, estar ciente de que o formato JSON não é seguro para arrays associativos - json_decode() vai devolvê-los como objetos em vez disso:

$config = array(
    'Frodo'   => 'hobbit',
    'Gimli'   => 'dwarf',
    'Gandalf' => 'wizard',
    );
print_r($config);
print_r(json_decode(json_encode($config)));

A saída é:

Array
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)
stdClass Object
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)

Answer 13

Confira os resultados aqui (desculpem o hack colocar o código PHP na caixa Código de JS):

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

RESULTADOS: serialize() e unserialize() são ambos significativamente mais rápido em PHP 5.4 em matrizes de tamanho variando

.

Eu fiz um script de teste em dados do mundo real para comparar json_encode vs serializar e json_decode vs unserialize. O teste foi executado no sistema de cache de uma no local de produção e-commerce. Ele simplesmente pega os dados já no cache, e testa os tempos de codificação / decodificação (ou serialize / unserialize) todos os dados e eu colocá-lo em um fácil de ver tabela.

Eu corri isso em PHP 5.4 de hospedagem compartilhada servidor.

Os resultados foram muito conclusivas de que para estes grandes para pequenos conjuntos de dados serializar e unserialize foram os claros vencedores. Em particular para o meu caso de uso, o json_decode e unserialize são os mais importantes para o sistema de cache. Unserialize era quase um vencedor onipresente aqui. Era tipicamente 2 a 4 vezes (por vezes, 6 ou 7 vezes) tão rápido quanto json_decode.

É interessante notar a diferença nos resultados de @ peter-Bailey.

Aqui está o código PHP utilizada para gerar os resultados:

<?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

apenas uma FYI - se você quiser serializar seus dados para algo fácil de ler e entender como JSON, mas com mais compressão e maior desempenho, você deve verificar MessagePack.

Answer 15

Em primeiro lugar, eu mudei o script para fazer um pouco mais de benchmarking (e também fazer 1000 é executado em vez de apenas 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';
}

Eu usei esta compilação de PHP 7:

PHP 7.0.14 (cli) (construída: 18 de janeiro de 2017 19:13:23) (NTS) Copyright (c) 1997-2016 A Zend Engine Group PHP v3.0.0, Copyright (c) 1998-2016 Zend Technologies com Zend OPcache v7.0.14, Copyright (c) 1999-2016, pelo Zend Technologies

E os meus resultados foram:

serialize () (vitórias: 999) foi de aproximadamente 10,98% mais rápido do que json_encode () unserialize () (vitórias: 987) foi de aproximadamente 33,26% mais rápido do que json_decode () unserialize () (vitórias: 987) foi de aproximadamente 48,35% mais rápido do que variedade json_decode ()

Assim claramente , serialize / unserialize é o mais rápido método, enquanto json_encode / decodificação é o mais portátil.

Se você considerar um cenário em que você ler / escrever serializado dados 10x ou mais frequentemente do que você precisa enviar ou receber a partir de um sistema não-PHP, você ainda está em melhor situação para uso serialize / unserialize e tê-lo json_encode ou json_decode antes de serialização em termos de tempo.

Answer 16

JSON é melhor se você deseja fazer o backup de dados e restaurá-lo em uma máquina diferente ou via FTP.

Por exemplo, com serialize se você armazenar dados em um servidor Windows, faça o download via FTP e restaurá-lo em um Linux um não poderia mais trabalhar devido à charachter re-codificação, porque serialize armazena o comprimento das cordas e no Unicode> UTF-8 transcodificação alguns charachter 1 byte poderia se tornou 2 bytes de comprimento tornando o acidente algoritmo.

Answer 17

THX - para este código de referência:

Os meus resultados em conjunto que eu uso para a configuração são tão pousio: JSON codificado em 0.0031511783599854 segundos
PHP serializado na 0.0037961006164551 segundos
json_encode() foi de aproximadamente 20,47% mais rápido do que serialize() JSON codificado em 0.0070841312408447 segundos
PHP serializado na 0.0035839080810547 segundos
unserialize() foi de aproximadamente 97,66% mais rápido do que json_encode()

Assim -. Testá-lo em seu próprio dados

Answer 18

Se a SUMM-se que as pessoas dizem aqui, json_decode / codificar parece mais rápido do que serialize MAS / unserialize Se você fizer var_dump o tipo do objeto serializado é alterado. Se por algum motivo você quiser manter o tipo, ir com serialize!

(tentativa por exemplo stdClass vs matriz)

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 codificação / decodificação

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]

Como você pode ver os convertidos json_encode / decodificar toda a stdClass, o que não é bom, info objeto perdido ... Então, decidir com base nas necessidades, especialmente se ele não é apenas matrizes ...

Answer 19

Gostaria de sugerir que você use Super Cache, que é um mecanismo de cache de arquivos que não vai usar json_encode ou serialize. É simples de usar e muito rápido em comparação com outro mecanismo PHP Cache.

https://packagist.org/packages/smart-php/super-cache

Ex:

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