blocks|key|3063943|text|您可以随时查看PHP源代码中的微性能特性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3063944|但是乍一看，不做'value‘并不会更快，因为PHP需要做一个查找在哪里找到'value’，即使哈希表查找应该是O(1)，这是不能保证的。当你使用Text-index时会有更多的开销。|3063945|如果对象只包含1个你需要访问的变量，那么使用一个对象会有更多的开销。|3063946|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You can always check the PHP-source code for micro-performance-features like that.

But at a first glance, no doing ['value'] will not be faster because PHP needs to do a Lookup on where to find ['value'] even thougn a hashtable lookup should be O(1), that's not guaranteed. There's more overhead when you use Text-index.

If the object only contains 1 variables that you need to access which is value, there's more overhead in using an object.

blocks|key|3063992|text|你还没有向我们展示$object->value如何工作的代码，因为它可能是后端它是一个数组，在这种情况下，理论上使用一个数组会更快，因为它涉及更少的函数调用。与函数调用相比，执行查找的成本可能会很高。如果它是一个变量，将会有很小的差别，因为PHP中的对象和数组具有非常相似的实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3063993|如果您正在寻找优化，您将需要分析以检查在何处使用了大部分时间。我怀疑把对象改成数组不会有什么大的不同。|3063994|entityMap^0|9|E|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

You haven't shown us the code for how <code>$object-&gt;value</code> works, as it could be that backend it is an array in which case theoretically using an array would be faster as it involves one less function call. The cost of doing the lookup will probably be huge compared to the function call. If it is a variable, there is going to be very little diffrence as objects and arrays in PHP have a very similar implementation.

If you are looking at optimizations, you will need to profile to check where the majority of the time is being used. I suspect that changing objects to arrays will make no major difference.

blocks|key|315415|text|我使用以下代码进行“性能分析”(1,000个实例，1000.000次读/写)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|315416|function+p($i)+{
++echo+'<pre>';
++print_r($i);
++echo+'</pre>';
}


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

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

echo+'+phpversion+'.phpversion();|code-block|syntax|javascript|315417|它在我的LINUX中输出以下内容：|315418|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|315419|因此，结论是:即使在PHP5.2上，对象也很慢。除非你真的需要对象的oop特性，否则不要使用对象。|offset|length|style|BOLD|315420|entityMap^0|0|0|0|0|I|V|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I used this code for "profiling" (1000 instances, 1000.000 reads/writes):

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


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

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

echo '&lt;p&gt; phpversion '.phpversion();
</code></pre>

It outputs in my LINUX hosting this stuff:

<pre><code>arrays: 1.1085488796234

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
obj: 1.2824709415436

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
phpversion 5.2.17
</code></pre>

so in a conclusion: objects are slower even on PHP 5.2. Don't use objects unless you really need their oop features.

blocks|key|315431|text|我看到这是一个老帖子，所以我想我会更新它。以下是我在Zend+CE+5.3.21上完成的代码和统计数据，我试图测试整个过程，存储信息并将其拉回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|315432|V1+:耗时0.83秒|315433|for+($i=1;+$i<1000000;+$i%2B%2B)+{
++$a+=+get_one();
++$b+=+$a[0];
++$b+=+$a[1];
}

function+get_one()+{
++return+array(1,1);
}|code-block|syntax|javascript|315434|V2+:耗时3.05秒|315435|for+($i=1;+$i<1000000;+$i%2B%2B)+{
++$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;
}|315436|V3+:耗时1.98秒(请注意，构造函数提高了性能)|315437|for+($i=1;+$i<1000000;+$i%2B%2B)+{
++$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;
++}
}|315438|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I see this is kind of an old post so I thought I'll update it.
here are my codes and stats, done on Zend CE 5.3.21
I tried to test the whole thing, storing info and pulling it back.

V1 : takes 0.83 sec

<pre><code>for ($i=1; $i&lt;1000000; $i++) {
 $a = get_one();
 $b = $a[0];
 $b = $a[1];
}

function get_one() {
 return array(1,1);
}
</code></pre>

V2 : takes 3.05 sec

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

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

class test {
 public $v;
 public $k;
}
</code></pre>

V3 : takes 1.98 sec (note that the constructor improves the performance)

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

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

class test {
 public $v;
 public $k;
 public function __construct($v, $k) {
 $this-&gt;v = $v;
 $this-&gt;k = $k;
 }
}
</code></pre>

blocks|key|3064116|text|基于Quazzle的代码，我运行了下一段代码(5.4.16+windows+64位)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064117|<?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%2B%2B)+{
++++$z+=+array();
++++for+($j=0;+$j<1000;+$j%2B%2B)+{
++++++++$z['aaa']+=+'aaa';
++++++++$z['bbb']+=+'bbb';
++++++++$z['ccc']+=+$z['aaa'].$z['bbb'];++++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'arrays:+'.(microtime(true)+-+$t0)."";
echo+'memory:+'.($fin-$inicio)."";
p($z);

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

$t0+=+microtime(true);
$arraysOf=array();
$inicio=memory_get_usage();+
for+($i=0;+$i<1000;+$i%2B%2B)+{
++++$z+=+new+stdClass();
++++for+($j=0;+$j<1000;+$j%2B%2B)+{
++++++++$z->aaa+=+'aaa';
++++++++$z->bbb+=+'bbb';
++++++++$z->ccc+=+$z->aaa.$z->bbb;++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'arrays:+'.(microtime(true)+-+$t0)."";
echo+'memory:+'.($fin-$inicio)."";
p($z);++
?>|code-block|syntax|javascript|3064118|我得到了下一个结果：|3064119|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
)|3064120|php+5.4的结论|3064121|marginally).|3064122|stdClass类比数组快(但是|unordered-list-item|3064123|类是邪恶的。|ordered-list-item|3064124|类比数组占用更少的内存。(大约减少30-40%25！)|3064125|3064126|3064127|ps:需要注意的是，如果定义了类，但是定义了成员，那么这个类的使用就会变慢。它还使用了更多的内存。显然秘诀在于定义成员|offset|length|style|BOLD|3064128|更新|3064129|我从php+5.4更新到php+5.5+(5.5.12+x86+windows)。|3064130|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
)|3064131|php+5.5的结论|3064132|3064133|对于数组，PHP5.5比PHP5.4快，对于对象，由于PHP5.5和arrays.|3064134|stdClass的优化，|3064135|类比数组慢，|3064136|类仍然比数组占用更少的内存。(大约30-40%25的less!!).|3064137|SplFixedArray类似于使用类，但它使用更多的内存。|3064138|3064139|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|1D|A|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1V|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1W|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1X|8|@]|9|@]|A|$]]|$1|U|3|V|5|T|7|1Y|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|20|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|21|8|@$10|22|11|23|12|13]]|9|@]|A|$]]|$1|14|3|15|5|6|7|24|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|25|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|27|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|T|7|29|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|T|7|2A|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|T|7|2B|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|T|7|2C|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|T|7|2D|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]]|1P|$]]

Based in the code of Quazzle, i ran the next code (5.4.16 windows 64bits):

<pre><code>&lt;?php
class SomeClass {
 public $aaa;
 public $bbb;
 public $ccc;
 }

function p($i) {
 echo '&lt;pre&gt;';
 print_r($i);
 echo '&lt;/pre&gt;';
}


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

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

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

And i obtained the next result:

<pre><code>arrays: 1.8451430797577

memory: 460416

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 1.8294548988342

memory: 275696

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 2.2577090263367

memory: 483648

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
</code></pre>

Conclusion for php 5.4

<ol>
<li>Class is fasts than Arrays (but marginally).</li>
<li>stdClass is evil.</li>
<li>Class uses less memory than Arrays. (about 30-40% less!!)</li>
</ol>

ps: as a note, if the class is defined but the members then, the use of this class is slower. It also uses more memory. Apparently the secret is to define the members

<h2>Update</h2>

I updated from php 5.4 to php 5.5 (5.5.12 x86 windows).

<pre><code>arrays: 1.6465699672699

memory: 460400

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 1.8687851428986

memory: 363704

SplFixedArray Object
(
 [0] =&gt; aaa
 [1] =&gt; bbb
 [2] =&gt; aaabbb
)

arrays: 1.8554251194

memory: 275568

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 2.0101680755615

memory: 483656

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
</code></pre>

<h2>Conclusion for php 5.5</h2>

<ol>
<li>For arrays, PHP 5.5 is faster than PHP 5.4, for object it is pretty much the same</li>
<li>Class is slower than Arrays thanks to the optimization of PHP 5.5 and arrays.</li>
<li>stdClass is evil.</li>
<li>Class still uses less memory than Arrays. (about 30-40% less!!).</li>
<li>SplFixedArray is similar to use a Class but it uses more memory.</li>
</ol>

blocks|key|3064167|text|如果数组和类的性能相同，我认为使用预定义类的对象来存储/传递业务数据将使我们的程序更具逻辑性，代码更具可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064168|今天，有了像Eclipse，Netbean这样的现代ide+...知道一个(预定义类的)对象承载了什么信息是非常方便的，但是数组却不是这样|3064169|例如:使用数组|3064170|function+registerCourse(array+$student)+{
++++//+Right+here+I+don't+know+how+a+$student+look+like+unless+doing+a+print_r()+or+var_dump()
+....
}|code-block|syntax|javascript|3064171|使用对象|3064172|class+Studen+{
++++private+$_name,+$_age;
++++public+function+getAge()+{}
++++public+function+getName()+{}
++++..
}

function+registerCourse(Studen+$student)+{
++++//+Right+here+I+just+Ctrl%2BSpace+$student+or+click+"Student"+and+I+know+I+can+get+name+or+age+from+it
++++...
}|3064173|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If Arrays and Classs are the same performance, I think use objects of predefined classes for storing/passing business data would make our program more logic and the code more readability.

Today, with modern ide like Eclipse, Netbean ... it's very convenient to know what info an objects (of predefined class) is carrying but arrays are not so

Eg:
With array

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

With object

<pre><code>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
 ...
}
</code></pre>

blocks|key|320333|text|我在php+7.0.9下使用magallanes的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|320334|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
)|code-block|syntax|javascript|320335|和用户php+7.1.3：|320336|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
)++++++++++++++++++++++|320337|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I use magallanes' code under php 7.0.9 :

<pre><code>arrays: 0.19802498817444

memory: 324672

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.18602299690247

memory: 132376

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.1950249671936

memory: 348296

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
</code></pre>

And user php 7.1.3:

<pre><code>arrays: 0.59932994842529
memory: 444920
Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 0.72895789146423
memory: 164512

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

arrays: 0.61777496337891
memory: 484416
stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
) 
</code></pre>

blocks|key|320351|text|脚本@+PHP+7.3.5|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|320352|320353|SomeClass+Object是最快的，lightest.|unordered-list-item|CODE|320354|Array+是1.32倍的速度。2.70x+memory.|320355|stdClass+Object+1.65x速度。2.94x内存。|320356|320357|原始输出：|320358|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
)|code-block|syntax|javascript|320359|entityMap^0|4|9|0|0|0|G|0|0|5|6|7|G|5|0|0|F|G|5|O|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|12|8|@$9|13|A|14|B|J]]|D|@]|E|$]]|$1|K|3|L|5|I|7|15|8|@$9|16|A|17|B|J]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|M|3|N|5|I|7|1C|8|@$9|1D|A|1E|B|J]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1K|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|1L|8|@]|D|@]|E|$U|V]]|$1|W|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|X|$]]

magallanes' script @ PHP 7.3.5

<ul>
<li><code>SomeClass Object</code> is fastest and lightest.</li>
<li><code>Array</code> 1.32x speed. 2.70x memory.</li>
<li><code>stdClass Object</code> 1.65x speed. 2.94x memory.</li>
</ul>

Raw output:

<pre><code>arrays: 0.064794063568115
memory: 444920
Array (
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.048975944519043
memory: 164512
SomeClass Object (
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.081161022186279
memory: 484416
stdClass Object (
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
</code></pre>

blocks|key|318511|text|对于任何对这个问题感兴趣的人:)我在PHP7.1Ubuntu+x64上运行Quazzle代码，得到了这个答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|318512|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
)|code-block|syntax|javascript|318513|结论|318514|Array+take+4(!)内存大于类对象。|offset|length|style|BOLD|318515|类对象的速度略微快一些。|318516|stdClass仍然邪恶的©magallanes+:)|318517|entityMap^0|0|0|0|B|1|0|0|0|D|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@$K|12|L|13|M|N]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

For anybody who is still interested in this question :) 
I ran Quazzle code on PHP 7.1 Ubuntu x64 and got this answer:

<pre><code>arrays: 0.24848890304565

memory: 444920

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.23238587379456

memory: 164512

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
arrays: 0.24422693252563

memory: 484416

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)
</code></pre>

<h2>Conclusion</h2>

Array take 4(!) the memory than class object. 
Class object marginally faster. 
stdClass still evil © magallanes :)

blocks|key|320407|text|今天我对@magallanes基准测试产生了好奇心，所以我对它进行了扩展。我增加了一些for循环，以真正突出显示事物之间的差距。它在Apache2.4、mod_php和PHP7.2上运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|320408|为了使结果更简单，下面是一个汇总表：|320409|%2B---------------------------%2B---------%2B-----------------%2B
%7C+++++++++++Test++++++++++++%7C+Memory++%7C++++++Time+++++++%7C
%2B---------------------------%2B---------%2B-----------------%2B
%7C+Array+++++++++++++++++++++%7C+2305848+%7C+9.5637300014496+%7C
%7C+stdClass++++++++++++++++++%7C+2505824+%7C+11.212271928787+%7C
%7C+SomeClass+++++++++++++++++%7C++963640+%7C+11.558017015457+%7C+<--+*
%7C+AnotherClass++++++++++++++%7C+2563136+%7C+10.872401237488+%7C
%7C+SetterClass+++++++++++++++%7C++905848+%7C+59.879059791565+%7C
%7C+SetterClassDefineReturn+++%7C++905792+%7C+60.484427213669+%7C
%7C+SetterClassSetFromParam+++%7C++745792+%7C+62.783381223679+%7C
%7C+SetterClassSetKeyAndParam+%7C++745824+%7C+72.155715942383+%7C
%2B---------------------------%2B---------%2B-----------------%2B
*+-+Winner+winner+chicken+dinner|code-block|syntax|javascript|320410|下面是修改后的脚本。我想测试一下如何使用方法和定义类型来设置属性。我非常惊讶地发现，使用setter方法会给代码带来很大的冲击。现在，假设这是一个非常非常具体的性能测试，许多应用程序甚至不会达到这一点。但是，如果您的站点每秒处理1000个请求，其中1000个类与1000个对象一起使用，您就可以看到这可能会如何影响性能。|320411|<?php

set_time_limit(500);

class+SomeClass+{
++++public+$aaa;
++++public+$bbb;
++++public+$ccc;
}
++++
class+AnotherClass+{
}

class+SetterClass+{
++++public+$aaa;
++++public+$bbb;
++++public+$ccc;

++++public+function+setAAA()+{
++++++++$this->aaa+=+'aaa';
++++}

++++public+function+setBBB()+{
++++++++$this->bbb+=+'bbb';
++++}

++++public+function+setCCC()+{
++++++++$this->ccc+=+$this->aaa.$this->bbb;
++++}
}

class+SetterClassDefineReturn+{
++++public+$aaa;
++++public+$bbb;
++++public+$ccc;

++++public+function+setAAA():void+{
++++++++$this->aaa+=+'aaa';
++++}

++++public+function+setBBB():void+{
++++++++$this->bbb+=+'bbb';
++++}

++++public+function+setCCC():void+{
++++++++$this->ccc+=+$this->aaa.$this->bbb;
++++}
}

class+SetterClassSetFromParam+{
++++public+$aaa;
++++public+$bbb;
++++public+$ccc;

++++public+function+setAAA(string+$val):+void+{
++++++++$this->aaa+=+$val;
++++}

++++public+function+setBBB(string+$val):+void+{
++++++++$this->bbb+=+$val;
++++}

++++public+function+setCCC(string+$val):+void+{
++++++++$this->ccc+=+$val;
++++}
}

class+SetterClassSetKeyAndParam+{
++++public+$aaa;
++++public+$bbb;
++++public+$ccc;

++++public+function+set(string+$key,+string+$val):+void+{
++++++++$this->{$key}+=+$val;
++++}
}

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

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+SomeClass();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->aaa+=+'aaa';
++++++++$z->bbb+=+'bbb';
++++++++$z->ccc+=+$z->aaa.$z->bbb;++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+AnotherClass();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->aaa+=+'aaa';
++++++++$z->bbb+=+'bbb';
++++++++$z->ccc+=+$z->aaa.$z->bbb;++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+SetterClass();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->setAAA();
++++++++$z->setBBB();
++++++++$z->setCCC();++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+SetterClassDefineReturn();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->setAAA();
++++++++$z->setBBB();
++++++++$z->setCCC();++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+SetterClassSetFromParam();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->setAAA('aaa');
++++++++$z->setBBB('bbb');
++++++++$z->setCCC('aaabbb');++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';

p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+SetterClassSetKeyAndParam();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->set('aaa',+'aaa');
++++++++$z->set('bbb',+'bbb');++
++++++++$z->set('ccc',+'aaabbb');++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);

$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+new+stdClass();
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z->aaa+=+'aaa';
++++++++$z->bbb+=+'bbb';
++++++++$z->ccc+=+$z->aaa.$z->bbb;++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);+


$t0+=+microtime(true);
$arraysOf=[];
$inicio=memory_get_usage();+
for+($i=0;+$i<5000;+$i%2B%2B)+{
++++$z+=+[];
++++for+($j=0;+$j<5000;+$j%2B%2B)+{
++++++++$z['aaa']+=+'aaa';
++++++++$z['bbb']+=+'bbb';
++++++++$z['ccc']+=+$z['aaa'].$z['bbb'];++++++++++++
++++}
++++$arraysOf[]=$z;
}
$fin=memory_get_usage();++++
echo+'Time+Taken+(seconds):+'.(microtime(true)+-+$t0).'';
echo+'Memory:+'.($fin-$inicio).'';
p($z);|320412|结果如下：|320413|Time+Taken+(seconds):+11.558017015457

Memory:+963640

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

-----

Time+Taken+(seconds):+10.872401237488

Memory:+2563136

AnotherClass+Object
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)

----

Time+Taken+(seconds):+59.879059791565

Memory:+905848

SetterClass+Object
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)

----

Time+Taken+(seconds):+60.484427213669

Memory:+905792

SetterClassDefineReturn+Object
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)

----

Time+Taken+(seconds):+62.783381223679

Memory:+745792

SetterClassSetFromParam+Object
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)

----

Time+Taken+(seconds):+72.155715942383

Memory:+745824

SetterClassSetKeyAndParam+Object
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)

----

Time+Taken+(seconds):+11.212271928787

Memory:+2505824

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

----

Time+Taken+(seconds):+9.5637300014496

Memory:+2305848

Array
(
++++[aaa]+=>+aaa
++++[bbb]+=>+bbb
++++[ccc]+=>+aaabbb
)|320414|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Well I got curious today based off of @magallanes benchmark, so I expanded it a bit. I upped some of the for loops to really highlight the gaps between things. This is running on Apache 2.4, mod_php, and PHP 7.2.
Here's a summary table to make the results easier:
<pre><code>+---------------------------+---------+-----------------+
| Test | Memory | Time |
+---------------------------+---------+-----------------+
| Array | 2305848 | 9.5637300014496 |
| stdClass | 2505824 | 11.212271928787 |
| SomeClass | 963640 | 11.558017015457 | &lt;-- *
| AnotherClass | 2563136 | 10.872401237488 |
| SetterClass | 905848 | 59.879059791565 |
| SetterClassDefineReturn | 905792 | 60.484427213669 |
| SetterClassSetFromParam | 745792 | 62.783381223679 |
| SetterClassSetKeyAndParam | 745824 | 72.155715942383 |
+---------------------------+---------+-----------------+
* - Winner winner chicken dinner
</code></pre>
Below is the modified script. I wanted to test setting properties with methods and defining types. I was very surprised to find that using setter methods adds a significant hit to the code. Now granted this is a very very specific performance test where many apps will not even hit this. But if you have a site that handles 1000/reqs/second with 1000 classes that are used with 1000s of objects, you can see how this may affect performance.
<pre class="lang-php prettyprint-override"><code>&lt;?php

set_time_limit(500);

class SomeClass {
 public $aaa;
 public $bbb;
 public $ccc;
}
 
class AnotherClass {
}

class SetterClass {
 public $aaa;
 public $bbb;
 public $ccc;

 public function setAAA() {
 $this-&gt;aaa = 'aaa';
 }

 public function setBBB() {
 $this-&gt;bbb = 'bbb';
 }

 public function setCCC() {
 $this-&gt;ccc = $this-&gt;aaa.$this-&gt;bbb;
 }
}

class SetterClassDefineReturn {
 public $aaa;
 public $bbb;
 public $ccc;

 public function setAAA():void {
 $this-&gt;aaa = 'aaa';
 }

 public function setBBB():void {
 $this-&gt;bbb = 'bbb';
 }

 public function setCCC():void {
 $this-&gt;ccc = $this-&gt;aaa.$this-&gt;bbb;
 }
}

class SetterClassSetFromParam {
 public $aaa;
 public $bbb;
 public $ccc;

 public function setAAA(string $val): void {
 $this-&gt;aaa = $val;
 }

 public function setBBB(string $val): void {
 $this-&gt;bbb = $val;
 }

 public function setCCC(string $val): void {
 $this-&gt;ccc = $val;
 }
}

class SetterClassSetKeyAndParam {
 public $aaa;
 public $bbb;
 public $ccc;

 public function set(string $key, string $val): void {
 $this-&gt;{$key} = $val;
 }
}

function p($i) {
 echo '&lt;pre&gt;';
 print_r($i);
 echo '&lt;/pre&gt;';
 echo '&lt;hr&gt;';
}

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new SomeClass();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;aaa = 'aaa';
 $z-&gt;bbb = 'bbb';
 $z-&gt;ccc = $z-&gt;aaa.$z-&gt;bbb; 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new AnotherClass();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;aaa = 'aaa';
 $z-&gt;bbb = 'bbb';
 $z-&gt;ccc = $z-&gt;aaa.$z-&gt;bbb; 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new SetterClass();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;setAAA();
 $z-&gt;setBBB();
 $z-&gt;setCCC(); 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new SetterClassDefineReturn();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;setAAA();
 $z-&gt;setBBB();
 $z-&gt;setCCC(); 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new SetterClassSetFromParam();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;setAAA('aaa');
 $z-&gt;setBBB('bbb');
 $z-&gt;setCCC('aaabbb'); 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';

p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new SetterClassSetKeyAndParam();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;set('aaa', 'aaa');
 $z-&gt;set('bbb', 'bbb'); 
 $z-&gt;set('ccc', 'aaabbb'); 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);

$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = new stdClass();
 for ($j=0; $j&lt;5000; $j++) {
 $z-&gt;aaa = 'aaa';
 $z-&gt;bbb = 'bbb';
 $z-&gt;ccc = $z-&gt;aaa.$z-&gt;bbb; 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z); 


$t0 = microtime(true);
$arraysOf=[];
$inicio=memory_get_usage(); 
for ($i=0; $i&lt;5000; $i++) {
 $z = [];
 for ($j=0; $j&lt;5000; $j++) {
 $z['aaa'] = 'aaa';
 $z['bbb'] = 'bbb';
 $z['ccc'] = $z['aaa'].$z['bbb']; 
 }
 $arraysOf[]=$z;
}
$fin=memory_get_usage(); 
echo '&lt;p&gt;Time Taken (seconds): '.(microtime(true) - $t0).'&lt;/p&gt;';
echo '&lt;p&gt;Memory: '.($fin-$inicio).'&lt;/p&gt;';
p($z);
</code></pre>
And here's the results:
<pre><code>Time Taken (seconds): 11.558017015457

Memory: 963640

SomeClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

-----

Time Taken (seconds): 10.872401237488

Memory: 2563136

AnotherClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 59.879059791565

Memory: 905848

SetterClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 60.484427213669

Memory: 905792

SetterClassDefineReturn Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 62.783381223679

Memory: 745792

SetterClassSetFromParam Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 72.155715942383

Memory: 745824

SetterClassSetKeyAndParam Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 11.212271928787

Memory: 2505824

stdClass Object
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

----

Time Taken (seconds): 9.5637300014496

Memory: 2305848

Array
(
 [aaa] =&gt; aaa
 [bbb] =&gt; bbb
 [ccc] =&gt; aaabbb
)

</code></pre>

blocks|key|3064335|text|公平地说，这取决于你拥有什么类型的数据。其他答案的结果(或多或少)*是正确的。为了清楚起见，我将在底部粘贴测试代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3064336|这里重要的是，如果你使用一个预定义的对象，你可以节省相当多的内存，代价是你需要定义确切的结构。|3064337|考虑以下测试结果：|3064338|static+obj:+0.04223108291626
memory:+164920
object(staticSet)#1+(3)+{
++["aaa"]=>
++string(3)+"aaa"
++["bbb"]=>
++string(3)+"bbb"
++["ccc"]=>
++string(6)+"aaabbb"
}
---------------------------------------
static+obj+with+an+additional+prop:+0.042968988418579
memory:+524920
object(staticSet2)#1000+(3)+{
++["aaa"]=>
++string(3)+"aaa"
++["bbb"]=>
++string(3)+"bbb"
++["ddd"]=>
++string(6)+"aaabbb"
}
---------------------------------------|code-block|syntax|javascript|3064339|我可能错了，我没有研究PHP源代码，但我相信，就PHP而言，一切都是一个数组。预定义的对象只是一个定义良好的数组。有趣的是，值类型对ie没有影响。字符串值“1”将占用与布尔值为true相同的内存量。|3064340|为什么？正如我在前面所说的，PHP是数组，所以如果你有一个带有setter函数的对象，PHP+(一个简化的版本)做的是：|3064341|$objects+=+['objectName'+=>+[
++++'aaa'+=>+'',
++++'bbb'+=>+'',
++++'ccc'+=>+'',
++++'setValue:f'+=>+function('name',+'value')+{+...+}
++++]
];|3064342|每次执行时，都会查找功能键，该功能键查找道具名称，并在后台验证道具类型等。预定义对象中的内存节省来自于定义一个固定长度的数组(否则在PHP中是不可能的)，而不是分配内存块。|3064343|结论：|3064344|静态对象：耶！我们节省内存！但是，如果您尝试添加任何超出定义的内容，它将变得比stdClass更大。|offset|length|style|BOLD|3064345|['aaa']+into+[['aaa'],['bbb']]|3064346|PHP数组：如果你用PHP编写，你最好喜欢它们，即使一个字符串在PHP中也是一个字符数组。|3064347|对象：对象有很酷的功能，它们是保持代码有条理、整洁、模块化的绝佳方式。但我们都知道“拥有强大的力量...”。|3064348|最后，我的测试代码和“*”。人们似乎忘记了，如果在脚本运行时不清理变量，它们将保留在内存中，虽然这不会影响执行时间(很大)，但会影响内存测量。因此，在运行内存分析时，unset()是您的好朋友。|3064349|<?php

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

$noOfObjects+=+1000;
$noOfOperations+=+1000;

class+set+{
++++public+function+setKey($key,+$value)+{
++++++++$this->{$key}+=+$value;
++++}
++++public+function+readKey($name)+{
++++++++return+$this->{$name};
++++}
}

class+staticSet+{
++++public+string+$aaa;
++++public+string+$bbb;
++++public+string+$ccc;
}

class+staticSet2+{
++++public+string+$aaa;
++++public+string+$bbb;
}

class+staticSet3+{
++++public+bool+$aaa;
++++public+bool+$bbb;
++++public+bool+$ccc;
}

$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+array();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z['aaa']+=+'aaa';
++++++++$z['bbb']+=+'bbb';
++++++++$z['ccc']+=+$z['aaa'].$z['bbb'];
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'arrays:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+set();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->setKey('aaa','aaa');
++++++++$z->setKey('bbb','bbb');
++++++++$z->setKey('ccc',$z->readKey('aaa').$z->readKey('bbb'));
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'dynamic+obj:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+staticSet();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->{'aaa'}+=+'aaa';
++++++++$z->{'bbb'}+=+'bbb';
++++++++$z->{'ccc'}+=+$z->{'aaa'}.$z->{'bbb'};
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'static+obj:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+staticSet2();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->{'aaa'}+=+'aaa';
++++++++$z->{'bbb'}+=+'bbb';
++++++++$z->{'ddd'}+=+$z->{'aaa'}.$z->{'bbb'};
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'static+obj+with+an+additional+prop:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime($noOfObjects);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+Ds\Map();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->put('aaa','aaa');
++++++++$z->put('bbb','bbb');
++++++++$z->put('ccc',$z->get('aaa').$z->get('bbb'));
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'Ds\Map:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+staticSet();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->{'aaa'}+=+'1';
++++++++$z->{'bbb'}+=+'1';
++++++++$z->{'ccc'}+=+($z->{'aaa'}+&&+$z->{'bbb'});
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'static+obj+with+bool+values:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+new+staticSet3();+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z->{'aaa'}+=+'1';
++++++++$z->{'bbb'}+=+'1';
++++++++$z->{'ccc'}+=+($z->{'aaa'}+&&+$z->{'bbb'});
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'static+obj+with+defined+bool+values:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0+=+microtime(true);
$start=memory_get_usage();+
for+($i=0;+$i<$noOfObjects;+$i%2B%2B)+{
++++$z+=+array('aaa'+=>+'','bbb'+=>+'','ccc'+=>+'');+//+definition
++++for+($j=0;+$j<$noOfOperations;+$j%2B%2B)+{
++++++++$z['aaa']+=+'aaa';
++++++++$z['bbb']+=+'bbb';
++++++++$z['ccc']+=+$z['aaa'].$z['bbb'];
++++}
++++$arraysOf[]=$z;
}
$end=memory_get_usage();++
echo+'predefined+array:+'.(microtime(true)+-+$t0).PHP_EOL;
echo+'memory:+'.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo+'---------------------------------------'.PHP_EOL;


echo+'phpversion+'.phpversion().PHP_EOL;|3064350|entityMap^0|0|0|0|0|0|0|0|0|0|0|5|0|0|0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@$W|1M|X|1N|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|H|7|1O|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1P|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1Q|8|@$W|1R|X|1S|Y|Z]]|9|@]|A|$]]|$1|16|3|17|5|6|7|1T|8|@]|9|@]|A|$]]|$1|18|3|19|5|H|7|1U|8|@]|9|@]|A|$I|J]]|$1|1A|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|1B|$]]

To be fair it depends on what sort of data You have. The results in other answers are (more or less)* correct. I'll paste in the test code on the bottom for clarity.
The important thing here is that You can save a fair amount of memory if you use a predefined object, the trade-off is the fact that you need to define the exact structure.
Consider the following test results:
<pre><code>static obj: 0.04223108291626
memory: 164920
object(staticSet)#1 (3) {
 [&quot;aaa&quot;]=&gt;
 string(3) &quot;aaa&quot;
 [&quot;bbb&quot;]=&gt;
 string(3) &quot;bbb&quot;
 [&quot;ccc&quot;]=&gt;
 string(6) &quot;aaabbb&quot;
}
---------------------------------------
static obj with an additional prop: 0.042968988418579
memory: 524920
object(staticSet2)#1000 (3) {
 [&quot;aaa&quot;]=&gt;
 string(3) &quot;aaa&quot;
 [&quot;bbb&quot;]=&gt;
 string(3) &quot;bbb&quot;
 [&quot;ddd&quot;]=&gt;
 string(6) &quot;aaabbb&quot;
}
---------------------------------------
</code></pre>
I might be wrong here, I'm did not look into the PHP source but I believe that as far as PHP is concerned, everything is an array. A predefined object is just a well defined array. An interesting note is that the value type does not have an effect ie. a string value of '1' will take up the same amount of memory as a bool value of true.
Why? Well as I stated before PHP is arrays so if you have an object with a setter function what (a simplified version) PHP does is this:
<pre><code>$objects = ['objectName' =&gt; [
 'aaa' =&gt; '',
 'bbb' =&gt; '',
 'ccc' =&gt; '',
 'setValue:f' =&gt; function('name', 'value') { ... }
 ]
];
</code></pre>
Every time you execute, you do a lookup for the function key that does a lookup for a prop name, plus any validation for prop type etc. in the background. The memory savings in a predefined object come from defining an array of a set length (otherwise impossible in PHP) instead of allocating a chunk of memory.
Conclusion:
Static objects: Yey! We save memory! But if you try to add anything outside the definition it will grow larger then a stdClass.
<pre><code>['aaa'] into [['aaa'],['bbb']]
</code></pre>
Arrays: If You write in PHP You better love them, even a string is an array of characters in PHP.
Objects: Objects have cool functionality, they're a wonderful way to keep your code organised, clean, modular. But as we all know &quot;with great power...&quot;.
Finally, my test code and the '*'. people seem to forget that if You don't clean up your variables while the script is running they will remain in the memory, while it will not impact the execution time (much), it will impact the memory measurement. So while running a memory profiling unset() is your friend.
<pre><code>&lt;?php

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

$noOfObjects = 1000;
$noOfOperations = 1000;

class set {
 public function setKey($key, $value) {
 $this-&gt;{$key} = $value;
 }
 public function readKey($name) {
 return $this-&gt;{$name};
 }
}

class staticSet {
 public string $aaa;
 public string $bbb;
 public string $ccc;
}

class staticSet2 {
 public string $aaa;
 public string $bbb;
}

class staticSet3 {
 public bool $aaa;
 public bool $bbb;
 public bool $ccc;
}

$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = array(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z['aaa'] = 'aaa';
 $z['bbb'] = 'bbb';
 $z['ccc'] = $z['aaa'].$z['bbb'];
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'arrays: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new set(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;setKey('aaa','aaa');
 $z-&gt;setKey('bbb','bbb');
 $z-&gt;setKey('ccc',$z-&gt;readKey('aaa').$z-&gt;readKey('bbb'));
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'dynamic obj: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new staticSet(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;{'aaa'} = 'aaa';
 $z-&gt;{'bbb'} = 'bbb';
 $z-&gt;{'ccc'} = $z-&gt;{'aaa'}.$z-&gt;{'bbb'};
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'static obj: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new staticSet2(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;{'aaa'} = 'aaa';
 $z-&gt;{'bbb'} = 'bbb';
 $z-&gt;{'ddd'} = $z-&gt;{'aaa'}.$z-&gt;{'bbb'};
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'static obj with an additional prop: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime($noOfObjects);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new Ds\Map(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;put('aaa','aaa');
 $z-&gt;put('bbb','bbb');
 $z-&gt;put('ccc',$z-&gt;get('aaa').$z-&gt;get('bbb'));
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'Ds\Map: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new staticSet(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;{'aaa'} = '1';
 $z-&gt;{'bbb'} = '1';
 $z-&gt;{'ccc'} = ($z-&gt;{'aaa'} &amp;&amp; $z-&gt;{'bbb'});
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'static obj with bool values: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = new staticSet3(); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z-&gt;{'aaa'} = '1';
 $z-&gt;{'bbb'} = '1';
 $z-&gt;{'ccc'} = ($z-&gt;{'aaa'} &amp;&amp; $z-&gt;{'bbb'});
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'static obj with defined bool values: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;
$arraysOf=[];
$t0 = microtime(true);
$start=memory_get_usage(); 
for ($i=0; $i&lt;$noOfObjects; $i++) {
 $z = array('aaa' =&gt; '','bbb' =&gt; '','ccc' =&gt; ''); // definition
 for ($j=0; $j&lt;$noOfOperations; $j++) {
 $z['aaa'] = 'aaa';
 $z['bbb'] = 'bbb';
 $z['ccc'] = $z['aaa'].$z['bbb'];
 }
 $arraysOf[]=$z;
}
$end=memory_get_usage(); 
echo 'predefined array: '.(microtime(true) - $t0).PHP_EOL;
echo 'memory: '.($end-$start).PHP_EOL;
var_dump($z);
unset($t0,$start,$end,$z,$arraysOf);
echo '---------------------------------------'.PHP_EOL;


echo 'phpversion '.phpversion().PHP_EOL;
</code></pre>

I have a huge amount of PHP objects for a neural network for which I have to iterate over and perform some maths on. I was wondering if I would be better off using an associative array over instances of classes?

I am dealing with around <code>3640</code> objects and iterating around <code>500</code> times (at best) on top of that so any micro-optimization helps a great deal. Would it inevitably be quicker to do <code>$object['value']</code> than <code>$object-&gt;value</code>?

Edit: So they are both the same. But I guess there would be a little overhead for the constructor? Either way I don't think I want to trade in my beautiful classes for dirty arrays :P

PHP Objects vs Arrays -- Performance comparison while iterating

性能测试

Eclipse

我有大量的PHP对象用于神经网络，我必须迭代这些对象并在上面执行一些数学运算。我在想，在类的实例上使用关联数组会不会更好？我正在处理围绕3640对象和围绕500时间的迭代(充其量)，所以任何微优化都会有很大帮助。做$object['value']必然比做$object->value快吗？编辑：，因此它们都是相同的。但我...

问PHP对象与数组--迭代时的性能比较
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP对象与数组--迭代时的性能比较EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP对象与数组--迭代时的性能比较
EN