PHP Objects vs Arrays - Leistungsvergleich beim Iterieren

Ich habe eine große Anzahl von PHP-Objekten für ein neuronales Netzwerk, für die ich iterieren und einige Berechnungen durchführen muss. Ich habe mich gefragt, ob ich besser dran wäre, ein assoziatives Array für Klasseninstanzen zu verwenden.

Ich beschäftige mich mit 3640Objekten und iteriere herum500 (bestenfalls) Zeiten, sodass jede Mikrooptimierung sehr hilfreich ist. Wäre es unweigerlich schneller $object['value']als $object->value?

Edit: Also sind beide gleich. Aber ich denke, es würde ein wenig Aufwand für den Konstrukteur geben? So oder so glaube ich nicht, dass ich meine schönen Klassen gegen schmutzige Arrays eintauschen möchte: P.

Basierend auf dem Code von Quazzle habe ich den nächsten Code ausgeführt (5.4.16 Windows 64bit):

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

Und ich habe das nächste Ergebnis erhalten:

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
)

Schlussfolgerung für PHP 5.4

1. Klasse ist schneller als Arrays (aber nur am Rande).
2. stdClass ist böse.
3. Die Klasse benötigt weniger Speicher als Arrays. (ca. 30-40% weniger !!)

ps: Wenn die Klasse definiert ist, aber die Mitglieder, ist die Verwendung dieser Klasse langsamer. Es verwendet auch mehr Speicher. Anscheinend besteht das Geheimnis darin, die Mitglieder zu definieren

Aktualisieren

Ich habe von PHP 5.4 auf PHP 5.5 aktualisiert (5.5.12 x86 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
)

Schlussfolgerung für PHP 5.5

1. Für Arrays ist PHP 5.5 schneller als PHP 5.4, für Objekte ist es ziemlich gleich
2. Dank der Optimierung von PHP 5.5 und Arrays ist die Klasse langsamer als Arrays.
3. stdClass ist böse.
4. Die Klasse benötigt immer noch weniger Speicher als Arrays. (ca. 30-40% weniger !!).
5. SplFixedArray ähnelt der Verwendung einer Klasse, benötigt jedoch mehr Speicher.

Ich habe diesen Code für die "Profilerstellung" verwendet (1000 Instanzen, 1000.000 Lese- / Schreibvorgänge):

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

Es gibt in meinem LINUX Folgendes aus:

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

Fazit: Objekte sind auch unter PHP 5.2 langsamer. Verwenden Sie keine Objekte, es sei denn, Sie benötigen deren oop-Funktionen wirklich.

Ich benutze den Code von Magallanes unter PHP 7.0.9:

arrays: 0.19802498817444

memory: 324672

Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
arrays: 0.18602299690247

memory: 132376

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

memory: 348296

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

Und Benutzer PHP 7.1.3:

arrays: 0.59932994842529
memory: 444920
Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

arrays: 0.72895789146423
memory: 164512

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

arrays: 0.61777496337891
memory: 484416
stdClass Object
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)                      

magallanes 'Skript @ PHP 7.3.5

• SomeClass Object ist am schnellsten und am leichtesten.
• Array 1,32x Geschwindigkeit. 2,70x Speicher.
• stdClass Object 1,65x Geschwindigkeit. 2,94x Speicher.

Rohleistung:

arrays: 0.064794063568115
memory: 444920
Array (
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
arrays: 0.048975944519043
memory: 164512
SomeClass Object (
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
arrays: 0.081161022186279
memory: 484416
stdClass Object (
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)

Für alle, die sich noch für diese Frage interessieren :) Ich habe Quazzle-Code auf PHP 7.1 Ubuntu x64 ausgeführt und diese Antwort erhalten:

arrays: 0.24848890304565

memory: 444920

Array
(
    [aaa] => aaa
    [bbb] => bbb
    [ccc] => aaabbb
)
arrays: 0.23238587379456

memory: 164512

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

memory: 484416

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

Fazit

Array nimmt 4 (!) Den Speicher als Klassenobjekt.
Klassenobjekt etwas schneller.
stdClass immer noch böse © magallanes :)

Sie haben uns den Code für die Funktionsweise nicht gezeigt $object->value, da es sich bei dem Backend möglicherweise um ein Array handelt. In diesem Fall handelt es sich theoretisch um ein Array Verwendung eines Arrays schneller, da ein Funktionsaufruf weniger erforderlich ist. Die Kosten für die Suche werden im Vergleich zum Funktionsaufruf wahrscheinlich enorm sein. Wenn es sich um eine Variable handelt, wird es kaum Unterschiede geben, da Objekte und Arrays in PHP eine sehr ähnliche Implementierung haben.

Wenn Sie Optimierungen in Betracht ziehen, müssen Sie ein Profil erstellen, um zu überprüfen, wo die meiste Zeit verwendet wird. Ich vermute, dass das Ändern von Objekten in Arrays keinen großen Unterschied macht.

Ich sehe, dass dies eine Art alter Beitrag ist, also dachte ich, ich werde ihn aktualisieren. Hier sind meine Codes und Statistiken, die in Zend CE 5.3.21 erstellt wurden. Ich habe versucht, das Ganze zu testen, Informationen zu speichern und sie zurückzuziehen.

V1: dauert 0,83 Sekunden

for ($i=1; $i<1000000; $i++) {
  $a = get_one();
  $b = $a[0];
  $b = $a[1];
}

function get_one() {
  return array(1,1);
}

V2: dauert 3,05 Sek

for ($i=1; $i<1000000; $i++) {
  $a = get_one();
  $b = $a->v;
  $b = $a->k;
}

function get_one() {
  $ret = new test();
  $ret->v = 1;
  $reb->k = 1;
  return $ret;
}

class test {
  public $v;
  public $k;
}

V3: dauert 1,98 Sekunden (beachten Sie, dass der Konstruktor die Leistung verbessert)

for ($i=1; $i<1000000; $i++) {
  $a = get_one();
  $b = $a->v;
  $b = $a->k;
}

function get_one() {
  return new test(1,1);
}

class test {
  public $v;
  public $k;
  public function __construct($v, $k) {
    $this->v = $v;
    $this->k = $k;
  }
}

Sie können den PHP-Quellcode jederzeit auf solche Leistungsmerkmale überprüfen.

Aber auf den ersten Blick wird kein ['Wert'] schneller sein, da PHP eine Suche durchführen muss, wo ['Wert'] zu finden ist, obwohl eine Hashtabellen-Suche O (1) sein sollte, was nicht garantiert ist. Es gibt mehr Overhead, wenn Sie Text-Index verwenden.

Wenn das Objekt nur 1 Variablen enthält, auf die Sie zugreifen müssen, was Wert ist, ist die Verwendung eines Objekts mit mehr Aufwand verbunden.

Wenn Arrays und Klassen dieselbe Leistung haben, würde die Verwendung von Objekten vordefinierter Klassen zum Speichern / Übergeben von Geschäftsdaten unser Programm logischer und die Lesbarkeit des Codes verbessern.

Mit modernen Ideen wie Eclipse, Netbean ... ist es heute sehr praktisch zu wissen, welche Informationen ein Objekt (einer vordefinierten Klasse) enthält, Arrays jedoch nicht

ZB: Mit Array

function registerCourse(array $student) {
    // Right here I don't know how a $student look like unless doing a print_r() or var_dump()
 ....
}

Mit Objekt

class Studen {
    private $_name, $_age;
    public function getAge() {}
    public function getName() {}
    ..
}

function registerCourse(Studen $student) {
    // Right here I just Ctrl+Space $student or click "Student" and I know I can get name or age from it
    ...
}