Objets de PHP vs tableaux

Question

J'ai une énorme quantité d'objets PHP pour un réseau de neurones pour laquelle j'ai du parcourir et effectuer des mathématiques. Je me demandais si je serais mieux à l'aide d'un tableau associatif dans les instances de classes?

Je fais affaire avec autour 3640 d'objets et d'itération autour de 500 temps (au mieux) sur le dessus de ce que les micro-optimisation de l'aide beaucoup. Serait-il inévitablement être plus rapide $object['value'] que $object->value?

Edit: Donc, ils sont tous les deux la même chose. Mais je suppose qu'il y aurait un peu de marge pour le constructeur? De toute façon, je ne pense pas que je veux le commerce de mon beau classes pour sale tableaux :P

Answer 1

Basé dans le code de Quazzle, j'ai couru le code suivant (5.4.16 windows 64bits):

<?php
class SomeClass {
    public $aaa;
    public $bbb;
    public $ccc;
    }

function p($i) {
  echo '<pre>';
  print_r($i);
  echo '</pre>';
}


$t0 = microtime(true);
$arraysOf=array();
$inicio=memory_get_usage(); 
for ($i=0; $i<1000; $i++) {
    $z = array();
    for ($j=0; $j<1000; $j++) {
        $z['aaa'] = 'aaa';
        $z['bbb'] = 'bbb';
        $z['ccc'] = $z['aaa'].$z['bbb'];            
    }
    $arraysOf[]=$z;
}
$fin=memory_get_usage();    
echo '<p>arrays: '.(microtime(true) - $t0)."</p>";
echo '<p>memory: '.($fin-$inicio)."</p>";
p($z);

$t0 = microtime(true);
$arraysOf=array();
$inicio=memory_get_usage(); 
for ($i=0; $i<1000; $i++) {
    $z = new SomeClass();
    for ($j=0; $j<1000; $j++) {
        $z->aaa = 'aaa';
        $z->bbb = 'bbb';
        $z->ccc = $z->aaa.$z->bbb;          
    }
    $arraysOf[]=$z;
}
$fin=memory_get_usage();    
echo '<p>arrays: '.(microtime(true) - $t0)."</p>";
echo '<p>memory: '.($fin-$inicio)."</p>";
p($z);

$t0 = microtime(true);
$arraysOf=array();
$inicio=memory_get_usage(); 
for ($i=0; $i<1000; $i++) {
    $z = new stdClass();
    for ($j=0; $j<1000; $j++) {
        $z->aaa = 'aaa';
        $z->bbb = 'bbb';
        $z->ccc = $z->aaa.$z->bbb;          
    }
    $arraysOf[]=$z;
}
$fin=memory_get_usage();    
echo '<p>arrays: '.(microtime(true) - $t0)."</p>";
echo '<p>memory: '.($fin-$inicio)."</p>";
p($z);  
?>

Et j'ai obtenu le résultat suivant:

arrays: 1.8451430797577

memory: 460416

Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

arrays: 1.8294548988342

memory: 275696

SomeClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

arrays: 2.2577090263367

memory: 483648

stdClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

Conclusion pour php 5.4

1. La classe est jeûnes que les Tableaux (mais légèrement).
2. stdClass est le mal.
3. La classe utilise moins de mémoire que les Tableaux. (environ 30 à 40% moins cher!!)

ps: une remarque, si la classe est définie, mais les membres à l'époque, l'utilisation de cette classe est plus lent. Il utilise également plus de mémoire. Apparemment, le secret est de définir les membres

Mise à jour

J'ai mis à jour de php 5.4, php 5.5 (5.5.12 x86 de windows).

arrays: 1.6465699672699

memory: 460400

Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

arrays: 1.8687851428986

memory: 363704

SplFixedArray Object
(
    [0] => aaa
    [1] => bbb
    [2] => aaabbb
)

arrays: 1.8554251194

memory: 275568

SomeClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

arrays: 2.0101680755615

memory: 483656

stdClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

Conclusion pour php 5.5

1. Pour les tableaux, PHP 5.5 est plus rapide que PHP 5.4, pour l'objet, il est à peu près la même
2. La classe est plus lent que les Tableaux grâce à l'optimisation de PHP 5.5 et les tableaux.
3. stdClass est le mal.
4. La classe utilise encore moins de mémoire que les Tableaux. (environ 30 à 40% moins cher!!).
5. SplFixedArray est similaire à l'utilisation d'une Classe, mais il utilise plus de mémoire.

Answer 2

Si vous utilisez PHP5, la différence entre les objets et les tableaux n'est presque pas significative. Ici, un homme teste les performances des meilleures structures de données: http://aggregation.novaak.net/?q=node/227 .

Answer 3

J'ai utilisé ce code pour "profiler" (1000 instances, 1000.000 lectures / écritures):

 function p($i) {
  echo '<pre>';
  print_r($i);
  echo '</pre>';
}


$t0 = microtime(true);
for ($i=0; $i<1000; $i++) {
    $z = array();
    for ($j=0; $j<1000; $j++) {
        $z['aaa'] = 'aaa';
        $z['bbb'] = 'bbb';
        $z['ccc'] = $z['aaa'].$z['bbb'];
    }
}
echo '<p>arrays: '.(microtime(true) - $t0);
p($z);

$t0 = microtime(true);
for ($i=0; $i<1000; $i++) {
    $z = (object) null;
    for ($j=0; $j<1000; $j++) {
        $z->aaa = 'aaa';
        $z->bbb = 'bbb';
        $z->ccc = $z->aaa.$z->bbb;
    }
}
echo '<p>obj: '.(microtime(true) - $t0);
p($z);

echo '<p> phpversion '.phpversion();
 

Il génère dans mon hébergement Linux ce genre de choses:

 arrays: 1.1085488796234

Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
obj: 1.2824709415436

stdClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
phpversion 5.2.17
 

En conclusion, les objets sont plus lents même sous PHP 5.2. N'utilisez pas d'objets à moins que vous n'ayez vraiment besoin de leurs fonctionnalités oop.

Answer 4

Vous n'avez pas de nous montrer le code pour combien de $object->value œuvres, comme il se pourrait que le backend c'est un tableau dans lequel cas , théoriquement, à l'aide d'un tableau serait plus rapide car elle implique moins un appel de fonction. Le coût de la recherche sera probablement énorme par rapport à l'appel de la fonction. Si c'est une variable, il va y avoir très peu de diffrence que les objets et les tableaux en PHP est très semblable mise en œuvre.

Si vous êtes à la recherche à des optimisations, vous aurez besoin de profil pour vérifier où se trouve la majorité du temps est utilisé. Je soupçonne que la modification des objets à des tableaux fera pas de grande différence.

Answer 5

Vous pouvez toujours vérifier le code source PHP pour de telles fonctionnalités micro-performances.

Mais à première vue, aucune action ["valeur"] ne sera rapide, car PHP doit rechercher où trouver ["valeur"], même si une recherche avec table de hachage doit être O (1), cela n’est pas garanti. Il y a plus de frais généraux lorsque vous utilisez Text-index.

Si l'objet ne contient que 1 variable à laquelle vous devez accéder, qui est une valeur, l'utilisation d'un objet entraîne une surcharge.