Bevorzugte Methode zum Speichern von PHP-Arrays (json_encode vs serialize)

Ich muss ein mehrdimensionales assoziatives Array von Daten in einer flachen Datei für Caching-Zwecke speichern. Gelegentlich kann es 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 serialisiertes PHP-Array in dieser Textdatei zu speichern? Ich habe mich json_decode und es scheint, dass json_decode in den neuesten Versionen von PHP (5.3) schneller ist als unserialize .

Ich bin gerade dabei, das Array als JSON zu speichern, da ich es bei Bedarf leichter von einem Menschen lesen kann, es kann mit sehr wenig Aufwand in PHP und JavaScript verwendet werden, und von dem, was ich gelesen habe, könnte es sogar sein schneller zu dekodieren (nicht sicher über die Codierung, obwohl).

Kennt jemand irgendwelche Fallstricke? Jeder hat gute Benchmarks, um die performancesvorteile beider Methoden zu zeigen?

Hängt von Ihren Prioritäten ab.

Wenn performance Ihre absolute Fahreigenschaft ist, dann benutzen Sie auf jeden Fall den schnellsten. Stellen Sie sicher, dass Sie die Unterschiede vollständig verstanden haben, bevor Sie eine Auswahl treffen

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

Und es gibt wahrscheinlich ein paar andere Unterschiede, an die ich im Moment nicht denken kann.

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

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

  • Sie speichern tief geschachtelte Arrays: json_decode() : “Diese function gibt false zurück, wenn die JSON-codierten Daten tiefer als 127 Elemente sind.”
  • Sie speichern Objekte, die unserialisiert werden müssen, als die richtige class
  • Sie interagieren mit alten PHP-Versionen, die json_decode nicht unterstützen

Ich habe einen Blogpost zu diesem Thema geschrieben: ” Cache ein großes Array: JSON, serialize oder var_export? “. In diesem Beitrag wird gezeigt, dass Serialisierung die beste Wahl für kleine bis große Arrays ist. Bei sehr großen Arrays (> 70 MB) ist JSON die bessere Wahl.

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

Meine zufälligen / willkürlichen “Performance” -Figuren, die PHP 5.3.5 auf einer 64bit-Plattform verwenden, zeigen:

JSON:

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

Natives PHP:

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

Igbinär:

  • WIN igbinary serialisiert in 1.6099879741669 Sekunden
  • WIN ibbirary unsialized in 4.7737920284271 Sekunden
  • WIN serialisiert “String” Größe: 4467

So ist es schneller zu igbinary_serialize () und igbinary_unserialize () und benötigt weniger Speicherplatz.

Ich habe den fillArray (0, 3) -Code wie oben verwendet, aber die Array-Keys zu längeren Strings gemacht.

igbinary kann die gleichen Datentypen speichern wie die native serialize von PHP (also kein Problem mit Objekten etc.) und Sie können PHP5.3 sagen, es für die Session-Behandlung zu verwenden, wenn Sie dies wünschen.

Siehe auch http://ilia.ws/files/zendcon_2010_hidden_features.pdf – speziell Dias 14/15/16

Y getestet gerade serialisiert und Json kodieren und dekodieren, plus die Größe, die es die gespeicherte Zeichenfolge dauert.

 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, aber unsere Version ist schneller, um die Zeichenfolge zu decodieren.

Wenn Sie Informationen zwischenspeichern, die Sie schließlich zu einem späteren Zeitpunkt ” einbeziehen” möchten, sollten Sie versuchen, var_export zu verwenden . So nehmen Sie den Treffer nur in der “serialize” und nicht in der “unserialize”.

Ich erweiterte den Test, um die performance 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() 

So scheint Json schneller zu sein für die Kodierung, aber langsam in der Dekodierung. Es könnte also von Ihrer Anwendung abhängen und von dem, was Sie am meisten erwarten.

Scheint, als wäre Serialisierung die, die ich aus 2 Gründen verwenden werde:

  • Jemand wies darauf hin, dass unserialize schneller als json_decode ist und ein ‘read’ Fall wahrscheinlicher klingt als ein ‘write’ Fall.

  • Ich hatte Probleme mit json_encode, wenn Zeichenfolgen mit ungültigen UTF-8-Zeichen verwendet wurden. Wenn das passiert, wird die Zeichenfolge leer und verursacht Informationsverlust.

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

Ich habe einen Anwendungsfall, bei dem fast jedes Mal, wenn ich mit der database rede, ein “riesiger” Tisch abgefragt werden muss (frag nicht warum, nur eine Tatsache). Das database-Caching-System ist nicht geeignet, da es die verschiedenen Anforderungen nicht zwischenspeichert, also dachte ich über PHP-Caching-Systeme nach.

Ich habe es versucht, aber es war nicht die Bedürfnisse, Speicher ist nicht genug zuverlässig in diesem Fall. Der nächste Schritt war das Zwischenspeichern in eine Datei mit Serialisierung.

Tabelle hat 14355 Einträge mit 18 Spalten, das sind meine Tests und Statistiken beim Lesen des serialisierten Caches:

JSON:

Wie Sie alle gesagt haben, besteht die Hauptschwierigkeit bei json_encode / json_decode darin, dass alles in eine StdClass Instanz (oder ein Objekt) umgewandelt wird. Wenn Sie es loopen müssen, ist es wahrscheinlich, dass Sie es in ein Array umwandeln, und ja, es erhöht die Transformationszeit

durchschnittliche Zeit: 780,2 ms; Speicherverbrauch: 41,5 MB; Cache-Dateigröße: 3,8 MB

Msgpack

@ Hutch erwähnt msgpack . Hübsche Webseite. Lass es uns versuchen, sollen wir?

Durchschnittszeit: 497 ms; Speicherverbrauch: 32 MB; Cache-Dateigröße: 2,8 MB

Das ist besser, erfordert aber eine neue Erweiterung; manchmal ängstliche Leute kompilierend …

IgBinär

@GingerDog erwähnt igbinary . Beachten Sie, dass ich die igbinary.compact_strings=Off weil es mir mehr darum geht, Performances als die Dateigröße zu lesen.

durchschnittliche Zeit: 411,4 ms; Speicherverbrauch: 36,75 MB; Cache-Dateigröße: 3,3 MB

Besser als msg pack. Trotzdem muss dieser auch kompiliert werden.

serialize / unserialize

durchschnittliche Zeit: 477,2 ms; Speicherverbrauch: 36,25 MB; Cachedateigröße: 5,9 MB

Bessere performanceen als JSON, je größer das Array ist, json_decode langsamer ist json_decode , aber das hast du schon neu.

Diese externen Erweiterungen verringern die Dateigröße und erscheinen auf dem Papier großartig. Zahlen lügen nicht *. Was bringt es, eine Erweiterung zu kompilieren, wenn Sie fast die gleichen Ergebnisse erhalten wie mit einer Standard-PHP-function?

Wir können auch folgern, dass Sie je nach Ihren Bedürfnissen etwas anderes wählen als jemand anderen:

  • IgBinary ist wirklich nett und funktioniert besser als MsgPack
  • Msgpack ist besser beim Komprimieren Ihrer Daten (beachten Sie, dass ich die Option ignbinary compact.string nicht ausprobiert habe).
  • Möchtest du nicht kompilieren? Verwenden Sie Standards.

Das ist es, ein weiterer Serialisierungsmethoden-Vergleich, um Ihnen zu helfen, den einen zu wählen!

* Getestet mit PHPUnit 3.7.31, PHP 5.5.10 – nur Dekodierung mit einem Standard-Hard Drive und alter Dual-Core-CPU – durchschnittliche Zahlen bei 10 gleichen Use-Case-Tests, Ihre Statistiken könnten anders sein

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

Der einzige Vorteil, den json in meinen Tests hatte, war die kleinere “gepackte” Größe.

Diese sind unter PHP 5.3.3 gemacht, lassen Sie mich wissen, wenn Sie weitere Details wünschen.

Hier sind Testergebnisse dann der Code, um sie zu produzieren. Ich kann die Testdaten nicht liefern, da sie Informationen offen legen, die ich nicht in der Wildnis rauslassen 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
"; // Time serialization $start = microtime( true ); for($i = 0; $i < 10000; $i++) { serialize( $test ); } $serializeTime = microtime( true ) - $start; echo "PHP serialized in $serializeTime seconds
"; // 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
"; // 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
"; $jsonSize = strlen(json_encode( $test )); $phpSize = strlen(serialize( $test )); echo "

serialized size : " . strlen(serialize( $test )) . "
"; echo "json_encode size : " . strlen(json_encode( $test )) . "

"; // 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 '
'; // 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 '
'; // 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!'; }

Ich habe auch einen kleinen Benchmark gemacht. Meine Ergebnisse waren die gleichen. Aber ich brauche die Decodierleistung. Wo ich gemerkt habe, wie einige Leute oben gesagt haben, ist unserialize schneller als json_decode . unserialize benötigt ungefähr 60-70% der json_decode Zeit. Die Schlussfolgerung ist ziemlich einfach: Wenn Sie performance in der Codierung benötigen, verwenden Sie json_encode , wenn Sie beim Decodieren performance benötigen, verwenden Sie unserialize . Da Sie die beiden functionen nicht zusammenführen können, müssen Sie eine Auswahl treffen, bei der Sie mehr performance benötigen.

Mein Maßstab in pseudo:

  • Definieren Sie Array $ arr mit ein paar zufälligen Schlüsseln und Werten
  • für x <100; x ++; serialisieren und json_encode array_rand von $ arr
  • für y <1000; y ++; json_decode die JSON-codierte Zeichenkette - Berechnungszeit
  • für y <1000; y ++; unserialized die serialisierte Zeichenfolge - Calc-Zeit
  • Echo das Ergebnis, das schneller war

Im Durchschnitt: unserialize gewann 96 mal über 4 mal den json_decode. Mit einem Durchschnitt von ungefähr 1.5ms über 2.5ms.

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 ) 

nur ein fyi – wenn Sie Ihre Daten zu etwas leicht zu lesen und zu verstehen wie JSON serialisieren möchten, aber mit mehr Komprimierung und höherer performance, sollten Sie sich Messagepack.

Sehen Sie sich die Ergebnisse hier an (Entschuldigung für den Hack, der den PHP-Code in die JS-Code-Box schreibt):

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

Ergebnisse: serialize() und unserialize() sind in PHP 5.4 auf Arrays unterschiedlicher Größe deutlich schneller.

Ich habe ein Testskript über reale Daten erstellt, um json_encode vs serialize und json_decode vs unserialize zu vergleichen. Der Test wurde auf dem Caching-System einer in Produktion befindlichen E-Commerce-Site durchgeführt. Es nimmt einfach die Daten, die bereits im Cache sind, und testet die Zeiten, um alle Daten zu kodieren / zu dekodieren (oder serialisieren / unserialisieren) und ich lege es in eine leicht zu sehende 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 Datensätze Serialisierung und Deserialisierung die klaren Gewinner waren. Insbesondere für meinen Anwendungsfall sind json_decode und unserialize die wichtigsten für das Caching-System. Unserialise war fast ein allgegenwärtiger Gewinner hier. Es war typischerweise 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 zu bemerken.

Hier ist der PHP-Code, mit dem die Ergebnisse generiert werden:

 < ?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]); ?>  < ?php foreach ($fields as $f) { ?>  < ?php } ?>  < ?php foreach ($data as $d) { ?>  < ?php foreach ($d as $key => $value) { ?> < ?php $is_win = strpos($key, 'Win'); ?> < ?php $color = ($is_win && $value) ? 'color: green;font-weight:bold;' : ''; ?>  < ?php } ?>  < ?php } ?> 
< ?= $f; ?>
< ?= $value . (($is_win && $value) ? '%' : ''); ?>

Zuerst änderte ich das Skript, um noch mehr Benchmarks zu machen (und mache auch 1000 Läufe 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) (gebaut: 18. Januar 2017 19:13:23) (NTS) Copyright (c) 1997-2016 Die PHP-Gruppe 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 ungefähr 10,98% schneller als json_encode () unserialize () (wins: 987) war ungefähr 33,26% schneller als json_decode () unserialize () (wins: 987) war ungefähr 48,35% schneller als das Array json_decode ()

Also, serialize / unserialize ist die schnellste Methode, während json_encode / decode das portabelste ist.

Wenn Sie ein Szenario betrachten, in dem Sie serialisierte Daten 10x oder öfter lesen oder schreiben, als Sie an ein Nicht-PHP-System senden oder von einem Nicht-PHP-System erhalten möchten, sollten Sie serialize / unserialize verwenden und vor der Serialisierung json_encode oder json_decode verwenden in Bezug auf die Zeit.

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

Zum Beispiel mit serialize, wenn Sie Daten auf einem Windows-Server speichern, über FTP herunterladen und auf einem Linux-Server wiederherstellen, könnte es aufgrund der Zeichenumschlüsselung nicht mehr funktionieren, da serialize die Länge der Zeichenfolgen und im Unicode speichert > UTF-8-Transcodierung eines 1-Byte-Charakters könnte 2 Byte lang werden, was den Algorithmus zum Absturz bringt.

THX – für diesen Benchmark-Code:

Meine Ergebnisse für das Array, das ich für die Konfiguration verwende, sind wie folgt: JSON in 0,0031511783599854 Sekunden codiert
PHP serialisiert in 0,0037961006164551 Sekunden
json_encode() war ungefähr 20,47% schneller als serialize() JSON, codiert in 0,0070841312408447 Sekunden
PHP serialisiert in 0.0035839080810547 Sekunden
unserialize() war ungefähr 97.66% schneller als json_encode()

Also – teste es an deinen eigenen Daten.

Wenn man das zusammenfassen möchte, was die Leute hier sagen, scheint json_decode / encode schneller zu sein als serialisieren / unserialisieren. ABER Wenn Sie var_dump machen, wird der Typ des serialisierten Objekts geändert. Wenn Sie den Typ aus irgendeinem Grund behalten möchten, gehen Sie mit serialize!

(Probieren Sie zum Beispiel 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 kodieren / 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 können, konvertiert der json_encode / decode alle in stdClass, was nicht so gut ist, verlorene Objektinfo … Entscheiden Sie also basierend auf den Bedürfnissen, besonders wenn es nicht nur Arrays sind …

Ich würde vorschlagen, dass Sie Super Cache verwenden, was ein Datei-Cache-Mechanismus ist, der json_encode oder serialize nicht verwendet. Es ist einfach zu benutzen 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('')->set(''); sCache::cache('myKey')->set('Key_value'); //Retrieving cache value with a key echo sCache::cache('myKey')->get(); ?>