Méthode recommandée pour stocker des tableaux PHP (json_encode vs sérialiser)

Question

J'ai besoin de stocker un multi-dimensionnelle tableau associatif de données dans un fichier plat pour la mise en cache. Je pourrais parfois rencontré le besoin de le convertir en JSON pour les utiliser dans mon application web, mais la grande majorité du temps, je vais utiliser le tableau directement en PHP.

Serait-il plus efficace pour stocker le tableau JSON ou en PHP tableau sérialisé dans ce fichier texte? J'ai regardé autour et il semble que dans les dernières versions de PHP (5.3), json_decode est effectivement plus rapide que l' unserialize.

Je suis actuellement en se penchant vers le stockage de la matrice comme JSON que je ressens sa plus facile à lire par un humain, si nécessaire, il peut être utilisé en PHP et en JavaScript avec très peu d'effort, et de ce que j'ai lu, il pourrait même être plus rapide à décoder (pas sûr de l'encodage, tout de même).

Personne ne sait de toute pièges? N'importe qui ont de bons repères pour montrer les avantages de performance de la méthode?

Merci d'avance pour toute aide.

Answer 1

Dépend de vos priorités.

Si les performances sont absolus de conduite caractéristique, puis par tous les moyens d'utiliser le plus rapide. Assurez-vous juste que vous avez une pleine compréhension des différences avant de faire un choix

• JSON convertit les caractères UTF-8 unicode séquences d'échappement. serialize() ne le sont pas.
• JSON n'aura aucun souvenir de ce que l'origine de l'objet de classe a (ils sont toujours restaurés comme des instances de stdClass).
• Vous ne pouvez pas l'effet de levier __sleep() et __wakeup() avec JSON
• Seulement les propriétés publiques sont sérialisés avec JSON
• JSON est plus portable

Et il y a probablement quelques autres différences que je ne peux pas penser pour le moment.

Un simple test de vitesse de comparer les deux

<?php

ini_set( 'display_errors', 1 );
error_reporting( E_ALL );

//  Make a bit, 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<br>";

//  Time serialization
$start = microtime( true );
serialize( $testArray );
$serializeTime = microtime( true ) - $start;
echo "PHP serialized in $serializeTime seconds<br>";

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

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 est plus simple et plus rapide que PHP est le format de sérialisation et doit être utilisé à moins que:

• Vous êtes le stockage profondément tableaux imbriqués: json_decode(): "Cette fonction retourne false si les données encodées JSON est plus profond que 127 éléments."
• Vous êtes de stocker des objets qui doivent être délinéarisé que la classe correcte
• Vous êtes en interaction avec d'anciennes versions de PHP qui ne prennent pas en charge la fonction json_decode

Answer 3

J’ai écrit un blogpost sur ce sujet : «un large éventail de Cache : JSON, sérialiser ou var_export ?«. Dans ce post, il est démontré que sérialiser est le meilleur choix pour les petits et les grands tableaux de tailles. De très grands tableaux (> 70MO) JSON est le meilleur choix.

Answer 4

Vous pourriez également être intéressé par https://github.com/phadej/igbinary - qui fournit une autre sérialisation "moteur" pour PHP.

Mon random/arbitraire de la "performance" des chiffres, à l'aide de PHP 5.3.5 sur une plate-forme 64 bits montrer :

JSON :

• JSON codé en 2.180496931076 secondes
• JSON décodé dans 9.8368630409241 secondes
• sérialisés "Chaîne" taille : 13993

Natif de PHP :

• PHP sérialisé dans 2.9125759601593 secondes
• PHP désérialisé dans 6.4348418712616 secondes
• sérialisés "Chaîne" taille : 20769

Igbinary :

• GAGNER igbinary sérialisé dans 1.6099879741669 secondes
• GAGNER igbinrary désérialisé dans 4.7737920284271 secondes
• GAGNER sérialisé "Chaîne" Taille : 4467

Donc, c'est plus rapide de igbinary_serialize() et igbinary_unserialize() et utilise moins d'espace disque.

J'ai utilisé le fillArray(0, 3) code comme ci-dessus, mais a rendu les clés du tableau des chaînes plus longues.

igbinary peut conserver les mêmes types de données que PHP natif de sérialiser peut (Donc pas de problème avec les objets, etc) et vous pouvez dire à PHP5.3 à l'utiliser pour le gestionnaire de session si vous le souhaitez.

Voir aussi http://ilia.ws/files/zendcon_2010_hidden_features.pdf - spécifiquement diapositives 14/15/16

Answer 5

Y a juste testé sérialisées et json coder et décoder, plus la taille, il faudra la chaîne stockée.

Nous pouvons conclure que JSON encode plus rapidement et entraîne une chaîne plus petite, mais Délinéarise est plus rapide pour décoder la chaîne.