it-swarm.com.de

Bevorzugte Methode zum Speichern PHP Arrays (json_encode vs serialize)

Ich muss ein mehrdimensionales assoziatives Array von Daten für Caching-Zwecke in einer Einfachdatei speichern. Es kann gelegentlich vorkommen, dass ich es für die Verwendung in meiner Web-App in JSON konvertieren muss, aber die meiste Zeit werde ich das Array direkt in PHP verwenden.

Wäre es effizienter, das Array als JSON oder als PHP serialisiertes Array in dieser Textdatei zu speichern? Ich habe mich umgesehen und es scheint, dass in den neuesten Versionen von PHP (5.3) json_decode tatsächlich schneller ist als unserialize.

Ich neige derzeit dazu, das Array als JSON zu speichern, da ich das Gefühl habe, dass es bei Bedarf von einem Menschen leichter gelesen werden kann. Es kann mit sehr geringem Aufwand sowohl in PHP als auch in JavaScript verwendet werden Lesen Sie, es könnte sogar schneller zu dekodieren sein (nicht sicher über die Kodierung, aber).

Kennt jemand irgendwelche Fallstricke? Hat jemand gute Benchmarks, um die Leistungsvorteile beider Methoden aufzuzeigen?

577
KyleFarris

Kommt auf deine Prioritäten an.

Wenn Leistung Ihr absolutes Fahrverhalten ist, verwenden Sie auf jeden Fall das schnellste. Stellen Sie nur sicher, dass Sie die Unterschiede vollständig verstanden haben, bevor Sie eine Entscheidung treffen

  • Im Gegensatz zu serialize() müssen Sie zusätzliche Parameter hinzufügen, um UTF-8-Zeichen unberührt zu lassen: json_encode($array, JSON_UNESCAPED_UNICODE) (sonst werden UTF-8-Zeichen in Unicode-Escape-Sequenzen konvertiert).
  • JSON hat keine Erinnerung an die ursprüngliche Klasse des Objekts (sie werden immer als Instanzen von stdClass wiederhergestellt).
  • Mit JSON können Sie __sleep() und __wakeup() nicht nutzen
  • Standardmäßig werden nur öffentliche Eigenschaften mit JSON serialisiert. (In PHP>=5.4 können Sie JsonSerializable implementieren, um dieses Verhalten zu ändern).
  • JSON ist portabler

Und wahrscheinlich gibt es noch ein paar andere Unterschiede, die mir im Moment nicht einfallen.

Ein einfacher Geschwindigkeitstest, um die beiden zu vergleichen

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

JSON ist einfacher und schneller als das Serialisierungsformat von PHP und sollte verwendet werden, es sei denn:

  • Sie speichern tief verschachtelte Arrays: json_decode() : "Diese Funktion gibt false zurück, wenn die JSON-codierten Daten tiefer als 127 Elemente sind."
  • Sie speichern Objekte, die als die richtige Klasse desialisiert werden müssen
  • Sie interagieren mit alten PHP -Versionen, die json_decode nicht unterstützen
232
Greg

Ich habe einen Blogpost zu diesem Thema geschrieben: " Ein großes Array zwischenspeichern: JSON, serialize oder var_export? ". In diesem Beitrag wird gezeigt, dass serialize die beste Wahl für kleine bis große Arrays ist. Für sehr große Arrays (> 70 MB) ist JSON die bessere Wahl.

58
Taco

Sie könnten auch an https://github.com/phadej/igbinary - interessiert sein, das eine andere Serialisierungs-Engine für PHP bereitstellt.

Meine zufälligen/willkürlichen 'Performance'-Werte, die auf einer 64-Bit-Plattform mit PHP 5.3.5 verwendet werden, zeigen:

JSON:

  • JSON in 2.180496931076 Sekunden codiert
  • JSON wurde in 9.8368630409241 Sekunden dekodiert
  • serialisierte "String" -Größe: 13993

Native PHP:

  • PHP wurde in 2.9125759601593 Sekunden serialisiert
  • PHP in 6.4348418712616 Sekunden unserialisiert
  • serialisierte "String" -Größe: 20769

Igbinary:

  • WIN igbinary in 1.6099879741669 Sekunden serialisiert
  • WIN igbinrary in 4.7737920284271 Sekunden unserialisiert
  • WIN serialized "String" Size: 4467

Daher ist igbinary_serialize () und igbinary_unserialize () schneller und verbraucht weniger Speicherplatz.

Ich habe den fillArray-Code (0, 3) wie oben verwendet, aber die Array-Schlüssel länger gemacht.

igbinary kann die gleichen Datentypen speichern wie PHP's native serialize can (also keine Probleme mit Objekten usw.) und Sie können PHP5.3 anweisen, es für die Session-Behandlung zu verwenden, wenn Sie dies wünschen.

Siehe auch http://ilia.ws/files/zendcon_2010_hidden_features.pdf - insbesondere die Folien 14/15/16

51
David Goodwin

Y hat gerade die serialisierte und json-Codierung und -Decodierung getestet sowie die Größe, in der die Zeichenfolge gespeichert ist.

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

Wir können daraus schließen, dass JSON schneller codiert und zu einer kleineren Zeichenfolge führt, dass die Abkürzung jedoch durch unserialize schneller erfolgt.

24
Blunk

Wenn Sie Informationen zwischenspeichern, die Sie zu einem späteren Zeitpunkt "einschließen" möchten, können Sie versuchen, var_export zu verwenden. Auf diese Weise nehmen Sie nur den Treffer in der "serialize" und nicht in der "unserialize".

15
Jordan S. Jones

Ich habe den Test erweitert, um die Leistung der Deserialisierung zu berücksichtigen. Hier sind die Zahlen, die ich bekommen habe.

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 scheint also schneller zu codieren, aber langsam zu decodieren. Es könnte also von Ihrer Bewerbung abhängen und von was Sie am meisten erwarten.

11
Jeff Whiting

Ein wirklich schönes Thema und nachdem ich die wenigen Antworten gelesen habe, möchte ich meine Experimente zu diesem Thema teilen.

Ich habe einen Anwendungsfall bekommen, bei dem eine "große" Tabelle fast jedes Mal, wenn ich mit der Datenbank spreche, abgefragt werden muss (fragen Sie nicht nach dem Grund, nur eine Tatsache). Das Datenbank-Caching-System ist nicht geeignet, da es die verschiedenen Anforderungen nicht zwischenspeichert. Ich denke daher über PHP-Caching-Systeme nach. 

Ich habe apcu ausprobiert, aber es entsprach nicht den Bedürfnissen. Der Speicher ist in diesem Fall nicht zuverlässig genug. Der nächste Schritt war das Cachen in eine Datei mit Serialisierung.

Tabelle hat 14355 Einträge mit 18 Spalten. Das sind meine Tests und Statistiken zum Lesen des serialisierten Caches:

JSON:

Wie Sie alle gesagt haben, ist der größte Nachteil von json_encode/json_decode, dass alles in eine StdClass-Instanz (oder ein Objekt) umgewandelt wird. Wenn Sie es schleifen müssen, müssen Sie es wahrscheinlich in ein Array umwandeln. Ja, es erhöht die Transformationszeit

durchschnittliche Zeit: 780,2 ms; Speichernutzung: 41.5MB; Cache-Dateigröße: 3,8 MB

Msgpack

@hutch erwähnt msgpack . Hübsche Website. Lass es uns versuchen, oder?

durchschnittliche Zeit: 497 ms; Speichernutzung: 32 MB; Größe der Cache-Datei: 2,8 MB

Das ist besser, erfordert aber eine neue Erweiterung. manchmal ängstliche Leute zusammenstellen ...

IgBinary

@GingerDog erwähnt igbinary . Beachten Sie, dass ich den igbinary.compact_strings=Off eingestellt habe, da ich mehr Wert auf das Lesen als auf die Dateigröße lege.

durchschnittliche Zeit: 411,4 ms; Speichernutzung: 36.75MB; Größe der Cache-Datei: 3,3 MB

Besser als msg pack. Dennoch muss auch hier kompiliert werden.

serialize/unserialize

durchschnittliche Zeit: 477,2 ms; Speichernutzung: 36.25MB; Größe der Cache-Datei: 5,9 MB

Besser als JSON, je größer das Array ist, desto json_decode ist langsamer, aber das ist schon neu.

Diese externen Erweiterungen verringern die Dateigröße und erscheinen auf Papier großartig. Zahlen lügen nicht *. Was ist der Sinn beim Kompilieren einer Erweiterung, wenn Sie fast die gleichen Ergebnisse wie bei einer Standardfunktion PHP erhalten? 

Wir können auch ableiten, dass Sie abhängig von Ihren Bedürfnissen etwas anderes wählen als jemand anderes: 

  • IgBinary ist wirklich schön und funktioniert besser als MsgPack
  • Msgpack komprimiert Ihre Daten besser (beachten Sie, dass ich die Option igbinary Compact.string nicht ausprobiert habe).
  • Will nicht kompilieren? Standards verwenden.

Das ist es, ein weiterer Vergleich der Serialisierungsmethoden, der Ihnen bei der Auswahl der Methode hilft!

* Getestet mit PHPUnit 3.7.31, PHP 5.5.10 - nur Decodierung mit einem Standard-Hardrive und alter Dual-Core-CPU - Durchschnittswerte bei 10 gleichen Use-Case-Tests, Ihre Statistiken können abweichen

8
soyuka

Es scheint, als würde serialize aus zwei Gründen verwendet werden:

  • Jemand hat darauf hingewiesen, dass unserialize schneller ist als json_decode und ein 'Read'-Fall wahrscheinlicher als ein' Write'-Fall ist.

  • Ich habe Probleme mit json_encode, wenn ich Zeichenfolgen mit ungültigen UTF-8-Zeichen habe. In diesem Fall ist die Zeichenfolge leer und führt zu Informationsverlust.

8
urraka

Ich habe dies sehr gründlich auf einem ziemlich komplexen, leicht geschachtelten Multi-Hash mit allen Arten von Daten (String, NULL, Ganzzahlen) getestet, und serialize/unserialize endete viel schneller als json_encode/json_decode.

Der einzige Vorteil, den Json in meinen Tests hatte, war die geringere Packungsgröße.

Diese werden unter PHP 5.3.3 ausgeführt. Lassen Sie mich wissen, wenn Sie weitere Details wünschen.

Hier sind Testergebnisse und dann der Code, um sie zu produzieren. Ich kann die Testdaten nicht bereitstellen, da sie Informationen enthüllen würden, die ich nicht in freier Wildbahn loslassen kann.

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!';
}
6
Mr. Sox

Ich habe auch einen kleinen Benchmark gemacht. Meine Ergebnisse waren die gleichen. Aber ich brauche die Decodierleistung. Wo ich, wie auch ein paar Leute oben, festgestellt habe, ist unserialize schneller als json_decode. unserialize benötigt ungefähr 60-70% der json_decode-Zeit. Die Schlussfolgerung ist also ziemlich einfach: Wenn Sie beim Codieren Leistung benötigen, verwenden Sie json_encode, wenn Sie beim Dekodieren Leistung benötigen, verwenden Sie unserialize. Da Sie die beiden Funktionen nicht zusammenführen können, müssen Sie wählen, wo Sie mehr Leistung benötigen.

Mein Benchmark in Pseudo:

  • Definieren Sie das Array $ arr mit einigen zufälligen Schlüsseln und Werten
  • für x <100; x ++; serialize und json_encode ein array_Rand von $ arr
  • für y <1000; y ++; json_decode der json-codierte String - Rechenzeit
  • für y <1000; y ++; serialisieren Sie den serialisierten String - Zeit berechnen
  • echo das Ergebnis, das schneller war

Im Durchschnitt: unserialize gewann 96 mal mehr als 4 mal den json_decode. Mit einem Durchschnitt von ungefähr 1,5 ms über 2,5 ms.

5
Jelmer

Bevor Sie Ihre endgültige Entscheidung treffen, beachten Sie, dass das JSON-Format für assoziative Arrays nicht sicher ist - json_decode() gibt sie stattdessen als Objekte zurück:

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

Ausgabe ist:

Array
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)
stdClass Object
(
    [Frodo] => hobbit
    [Gimli] => dwarf
    [Gandalf] => wizard
)
2
too much php

nur ein Grund: Wenn Sie Ihre Daten mit etwas vergleichbarem wie JSON serialisieren möchten, jedoch mit mehr Komprimierung und höherer Leistung, sollten Sie messagepack auschecken.

1
Hutch

Zuerst habe ich das Skript geändert, um mehr Benchmarking durchzuführen (und auch 1000 Runs statt nur 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';
}

Ich habe diesen Build von PHP 7 verwendet:

PHP 7.0.14 (cli) (erstellt: 18. Januar 2017 um 19:13:23 Uhr) (NTS) Copyright (c) 1997-2016 Die Gruppe PHP Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies mit Zend OPcache v7.0.14, Copyright (c) 1999-2016, von Zend Technologies

Und meine Ergebnisse waren:

serialize () (wins: 999) war etwa 10,98% schneller als json_encode () unserialize () (wins: 987) war etwa 33.26% schneller als json_decode () unserialize () (Gewinne: 987) war etwa 48.35% schneller als Array json_decode ()

Clear, serialize/unserialize ist also die schnellste -Methode, während json_encode/decode die most portable ist.

Wenn Sie ein Szenario in Betracht ziehen, in dem Sie serialisierte Daten 10x oder öfter lesen oder schreiben, als Sie an ein Nicht-PHP-System senden oder von diesem empfangen müssen, ist es STILLSTEIGER, serialize/unserialize zu verwenden und es vor der Serialisierung json_encode oder json_decode zu verwenden in zeitlicher Hinsicht.

1
Shawn Tolidano

Schauen Sie sich die Ergebnisse hier an (sorry für den Hack, der den PHP -Code in das JS-Code-Feld einfügt):

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

RESULTS: serialize() und unserialize() sind in PHP 5.4 auf Arrays unterschiedlicher Größe beide wesentlich schneller.

Ich habe ein Testskript mit Daten aus der realen Welt erstellt, um json_encode vs serialize und json_decode vs unserialize zu vergleichen. Der Test wurde mit dem Caching-System einer E-Commerce-Site in Produktion durchgeführt. Es nimmt einfach die Daten, die sich bereits im Cache befinden, und testet die Zeiten, um alle Daten zu kodieren/dekodieren (oder zu serialisieren/unserialisieren), und ich lege sie in eine leicht einsehbare Tabelle.

Ich habe dies auf PHP 5.4 Shared Hosting Server ausgeführt.

Die Ergebnisse waren sehr überzeugend, dass für diese großen bis kleinen Datenbestände die Serialisierung und das unserialisieren die klaren Gewinner waren. Insbesondere für meinen Anwendungsfall sind der json_decode und unserialize für das Caching-System am wichtigsten. Unserialize war hier fast ein allgegenwärtiger Gewinner. Es war normalerweise 2 bis 4 mal (manchmal 6 oder 7 mal) so schnell wie json_decode.

Es ist interessant, den Unterschied in den Ergebnissen von @ peter-bailey festzustellen.

Hier ist der PHP Code, der zum Generieren der Ergebnisse verwendet wird:

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

THX - für diesen Benchmark-Code:

Meine Ergebnisse für das Array, das ich für die Konfiguration verwende, sind folgende: (J/J), kodiert in 0,0031511783599854 Sekunden
PHP in 0,0037961006164551 Sekunden serialisiert
json_encode() war etwa 20,47% schneller als serialize()____. JSON-Code in 0,0070841312408447 Sekunden
PHP in 0,0035839080810547 Sekunden serialisiert
unserialize() war etwa 97,66% schneller als json_encode()

Also - testen Sie es anhand Ihrer eigenen Daten.

0
mk182

Ich würde Ihnen empfehlen, Super Cache zu verwenden, einen Mechanismus für den Dateicache, der json_encode oder serialize nicht verwendet. Es ist einfach zu bedienen und sehr schnell im Vergleich zu anderen PHP Cache-Mechanismen. 

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

JSON ist besser, wenn Sie Daten sichern und auf einem anderen Computer oder über FTP wiederherstellen möchten.

Wenn Sie zum Beispiel mit serialisieren Daten auf einem Windows-Server speichern, sie über FTP herunterladen und auf einem Linux wiederherstellen, könnte dies aufgrund der Umcodierung der Zeichen nicht mehr funktionieren, da serialize die Länge der Zeichenfolgen und im Unicode speichert > Eine UTF-8-Transkodierung von 1 Byte könnte 2 Byte lang werden und den Algorithmus zum Absturz bringen.

0
Informate.it

Um zusammenzufassen, was die Leute hier sagen, scheint json_decode/encode schneller zu sein als serialize/unserialize. Aber wenn Sie var_dump verwenden, wird der Typ des serialisierten Objekts geändert. Wenn Sie den Typ aus irgendeinem Grund behalten möchten, gehen Sie mit serialisieren!

(Versuchen Sie beispielsweise stdClass vs array)

serialisieren/unserialisieren:

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 codieren/decodieren

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]

Wie Sie sehen, konvertiert der json_encode/decode alle in stdClass, was nicht so gut ist, die Objektinformationen gingen verloren.

0