PHP ऑब्जेक्ट बनाम एरेस - पुनरावृति करते समय प्रदर्शन तुलना


91

मेरे पास एक न्यूरल नेटवर्क के लिए बड़ी मात्रा में PHP ऑब्जेक्ट्स हैं, जिसके लिए मुझे कुछ गणित पर चलना और प्रदर्शन करना है। मैं सोच रहा था कि क्या मैं कक्षाओं के उदाहरणों पर एक साहचर्य सरणी का उपयोग करना बेहतर होगा?

मैं 3640ऑब्जेक्ट्स के साथ काम कर रहा हूं और उस 500समय के आसपास (सबसे अच्छे रूप में) पुनरावृति कर रहा हूं ताकि कोई भी माइक्रो-ऑप्टिमाइज़ेशन एक महान सौदे में मदद करे। यह अनिवार्य रूप से करने के लिए तेज होगा $object['value']की तुलना में $object->value?

संपादित करें: इसलिए वे दोनों समान हैं। लेकिन मुझे लगता है कि कंस्ट्रक्टर के लिए थोड़ा ओवरहेड होगा? किसी भी तरह से मुझे नहीं लगता कि मैं गंदे सरणियों के लिए अपनी सुंदर कक्षाओं में व्यापार करना चाहता हूं: पी

जवाबों:


65

क्वेज़ल के कोड के आधार पर, मैंने अगला कोड (5.4.16 विंडोज़ 64 बिट्स) चलाया:

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

और मैंने अगला परिणाम प्राप्त किया:

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
)

Php 5.4 के लिए निष्कर्ष

  1. क्लास अर्रेज़ (लेकिन मामूली) से तेज़ है।
  2. stdClass बुराई है।
  3. कक्षा Arrays की तुलना में कम मेमोरी का उपयोग करती है। (लगभग 30-40% कम !!)

पीएस: एक नोट के रूप में, यदि वर्ग को परिभाषित किया गया है लेकिन सदस्य तब, इस वर्ग का उपयोग धीमा है। यह अधिक मेमोरी का भी उपयोग करता है। जाहिर तौर पर सदस्यों को परिभाषित करने के लिए रहस्य है

अपडेट करें

मैंने php 5.4 से php 5.5 (5.5.12 x86 विंडो) में अपडेट किया।

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
)

Php 5.5 के लिए निष्कर्ष

  1. सरणियों के लिए, PHP 5.5 PHP 5.4 से अधिक तेज़ है, वस्तु के लिए यह बहुत अधिक है
  2. PHP 5.5 के अनुकूलन और सरणियों के लिए Arrays की तुलना में कक्षा धीमी है।
  3. stdClass बुराई है।
  4. क्लास अभी भी Arrays से कम मेमोरी का उपयोग करता है। (लगभग 30-40% कम !!)।
  5. SplFixedArray एक क्लास का उपयोग करने के समान है लेकिन यह अधिक मेमोरी का उपयोग करता है।

आपके लिए एक अच्छा काम है सर। नेस्टेड एरेज़ आदि के लिए इसका विस्तार करना दिलचस्प होगा, अन्य PHP प्रदर्शन के लिए दिलचस्प साइटें: phpbench.com php-benchmark-script.com लेकिन मुझे यह पसंद है कि आपने मेमोरी का भी उपयोग किया है।
हीथ एन

2
PHP7 के साथ सरणियों और वस्तुओं के बीच अंतर अधिक महत्वपूर्ण हो गया। आप स्क्रिप्ट 30% रनटाइम और 60% मेमोरी का अंतर दिखाते हैं। बस मेरी मशीन, लेकिन अंगूठे के एक नियम के रूप में: संरचना के रूप में सरणियों का उपयोग न करें। इसके बजाय वस्तुओं का उपयोग करें :)
KingCrunch

क्या वस्तुएं इस मामले में कक्षाओं से अलग हैं?
मैट जी

किसी भी PHP7 अद्यतन की उम्मीद में यह बुकमार्क करना। और शायद आगामी PHP8, जब लागू हो। @ मगलालेन
s3c

8

मैंने इस कोड का उपयोग "रूपरेखा" के लिए किया है (1000 उदाहरण, 1000.000 पढ़ता / लिखता है):

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

यह इस सामग्री की मेजबानी में मेरे LINUX आउटपुट:

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

इसलिए निष्कर्ष में: PHP 5.2 पर भी वस्तुएँ धीमी हैं। जब तक आपको वास्तव में उनकी ऊप विशेषताओं की आवश्यकता न हो, तब तक वस्तुओं का उपयोग न करें।


7
user levans stackoverflow.com/users/1473035/levans से : मैंने इसे 5.3.8 के साथ चलाया और ऑब्जेक्ट्स के लिए 0.85355806350708 बनाम एरेज़ के लिए ऑब्जेक्ट्स धीमे, 0.51839280128479 थे। मैंने इसे 5.4.13 पर भी चलाया और इसके विपरीत परिणाम मिले, संभवतः 5.4 में किए गए वर्ग अनुकूलन के कारण, 0.43650078773499 बनाम सरणियों के लिए 0.6256799697876। इस प्रकार ऐसा लगता है कि टेबल बदल गए हैं और ऑब्जेक्ट अब जाने का रास्ता है।
जीन-बर्नार्ड पेलरिन

1
अच्छा जवाब, मैंने सिर्फ XAMPP (Apache) पर परीक्षण किया और नीचे दिए गए परिणाम मिले: arrays: 0.5174868106842 सरणी ([आआआ] => आआ [bbb] => बब्ब [ccc] = [आबबब] obj: 0.72189617156982 stdClass Object ([आआ]] => आआ [बी.बी.बी.] => बी.बी.बी. [ccc] => एआर्ब) ५.४.१ ९
ilhnctn

1
मैं 5.4.13 पर भी दौड़ा, लेकिन जीन-बर्नार्ड पेलरिन के विपरीत मिला: Arrays: 0.5020840167999 ऑब्जेक्ट: 1.0378720760345 इसलिए मैं अभी तक वस्तुओं के लिए प्रतिबद्ध नहीं हूं।
simontemplar

मैंने कोड में कुछ बदलाव किए और php 5.4 (5.4.16 32 बिट्स विंडोज) के लिए अर्रेज़ की तुलना में क्लास तेज़ है। मैंने एक नया उत्तर दिया जो इसका कारण बताता है।
मैगलन

PHP 5.5.11 परिणाम: सारणी: 0.17430, ऑब्जेक्ट: 0.24183
लेक्स

3

मैं 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
)

और उपयोगकर्ता 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
)                      

1
और मत भूलो stdClass असली स्ट्रिंग संख्यात्मक कुंजी का उपयोग कर सकते हैं। ['1' => 1] को [1 => 1] के रूप में संग्रहीत किया जाएगा, लेकिन हम $a=new stdClass(); $a->{1} = 1; $b=(array)$a;वास्तविक ['1' = 1] का उपयोग कर सकते हैं ।
सारथी

2
इसलिए, निष्कर्ष में .. Arrays 18% तेज हैं लेकिन 2.7x का अधिक मेमोरी का उपभोग करते हैं।
ज्यूक

3

मैगलन की लिपि @ PHP 7.3.5

  • SomeClass Object सबसे तेज और हल्का है।
  • Array 1.32x स्पीड। 2.70x मेमोरी।
  • stdClass Object 1.65x की गति। 2.94x मेमोरी।

कच्चा उत्पादन:

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
)

3

किसी को भी, जो अभी भी इस सवाल में दिलचस्पी है :) के लिए मैंने PHP 7.1 उबंटू x64 पर क्वेज़ल कोड चलाया और यह जवाब मिला:

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
)

निष्कर्ष

एरे ले 4 (!) स्मृति वर्ग वस्तु की तुलना में।
क्लास ऑब्जेक्ट मामूली तेजी से।
stdClass अभी भी बुराई © magallanes :)


2

आपने हमें यह नहीं दिखाया $object->valueकि यह कैसे काम करता है, क्योंकि यह हो सकता है कि यह एक सरणी है जिसमें यह एक सरणी है जिसमें सैद्धांतिक रूप से किसी सरणी का उपयोग करना अधिक तेज़ होगा क्योंकि इसमें एक कम फ़ंक्शन कॉल शामिल है। फ़ंक्शन कॉल की तुलना में लुकअप करने की लागत संभवतः बहुत बड़ी होगी। यदि यह एक चर है, तो बहुत कम अंतर होने वाला है क्योंकि PHP में वस्तुओं और सरणियों का बहुत समान कार्यान्वयन है।

यदि आप अनुकूलन देख रहे हैं, तो आपको यह जांचने के लिए प्रोफ़ाइल करना होगा कि अधिकांश समय का उपयोग कहां किया जा रहा है। मुझे संदेह है कि सरणियों में वस्तुओं को बदलने से कोई बड़ा फर्क नहीं पड़ेगा।


मैंने मान लिया कि मान सार्वजनिक चर होगा, इसलिए हे (1) डिफेंसिवली है जबकि हैश-लुकअप नहीं हो सकता है।
फिलिप एकबर्ग

2

मुझे लगता है कि यह एक पुरानी पोस्ट की तरह है तो मैंने सोचा कि मैं इसे अपडेट करूंगा। यहाँ Zend CE 5.3.21 पर किए गए मेरे कोड और आँकड़े हैं, मैंने पूरी चीज़ का परीक्षण करने की कोशिश की, जानकारी संग्रहीत की और इसे वापस खींच लिया।

V1: 0.83 सेकंड लेता है

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

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

V2: 3.05 सेकंड लेता है

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: 1.98 सेकंड लेता है (ध्यान दें कि कंस्ट्रक्टर प्रदर्शन में सुधार करता है)

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

1

आप हमेशा माइक्रो-परफॉर्मेंस-फीचर्स के लिए PHP-source कोड की जांच कर सकते हैं।

लेकिन पहली नज़र में, कोई भी काम करना ['मूल्य'] तेज़ नहीं होगा क्योंकि PHP को एक लुकअप करने की ज़रूरत है जहाँ पर ['मान' खोजने के लिए] यहाँ तक कि एक हैशटेबल लुक ओ (१) होना चाहिए, यह गारंटी नहीं है। जब आप पाठ-अनुक्रमणिका का उपयोग करते हैं तो अधिक ओवरहेड होता है।

यदि ऑब्जेक्ट में केवल 1 वैरिएबल होते हैं जिन्हें आपको एक्सेस करने की आवश्यकता होती है जो कि मूल्य है, तो ऑब्जेक्ट का उपयोग करने में अधिक ओवरहेड है।


और आपको कहां लगता है कि संपत्तियों पर नजर है? वे एक हैश टेबल में हैं, भी ... (हालांकि यह ट्रंक में कम या ज्यादा सच है)।
अर्टिफैक्टो

1

खैर मैं @magallanes बेंचमार्क के आधार पर आज उत्सुक हो गया, इसलिए मैंने इसे थोड़ा विस्तारित किया। मैंने कुछ छोरों के लिए कुछ चीजों के बीच अंतराल को उजागर करने के लिए उकसाया। यह Apache 2.4, mod_php और PHP 7.2 पर चल रहा है।

परिणामों को आसान बनाने के लिए यहां एक सारांश तालिका दी गई है:

+---------------------------+---------+-----------------+
|           Test            | Memory  |      Time       |
+---------------------------+---------+-----------------+
| Array                     | 2305848 | 9.5637300014496 |
| stdClass                  | 2505824 | 11.212271928787 |
| SomeClass                 |  164920 | 3.9636149406433 | <-- *
| AnotherClass              | 2563136 | 10.872401237488 |
| SetterClass               |  905848 | 59.879059791565 |
| SetterClassDefineReturn   |  905792 | 60.484427213669 |
| SetterClassSetFromParam   |  745792 | 62.783381223679 |
| SetterClassSetKeyAndParam |  745824 | 72.155715942383 |
+---------------------------+---------+-----------------+
* - Winner winner chicken dinner

नीचे संशोधित स्क्रिप्ट है। मैं तरीकों और परिभाषित प्रकारों के साथ सेटिंग गुणों का परीक्षण करना चाहता था। मुझे यह जानकर बहुत आश्चर्य हुआ कि सेटर विधियों के उपयोग से कोड में एक महत्वपूर्ण हिट जुड़ जाता है। अब दी गई यह एक बहुत ही विशिष्ट प्रदर्शन परीक्षा है, जहाँ कई ऐप इसे हिट भी नहीं करेंगे। लेकिन अगर आपके पास ऐसी साइट है जो 1000 / reqs / सेकंड को 1000 वर्गों के साथ संभालती है जो विभिन्न वस्तुओं के साथ उपयोग की जाती हैं, तो आप देख सकते हैं कि यह प्रदर्शन को कैसे प्रभावित कर सकता है।

<?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<1000; $i++) {
    $z = new SomeClass();
    for ($j=0; $j<10000; $j++) {
        $z->aaa = 'aaa';
        $z->bbb = 'bbb';
        $z->ccc = $z->aaa.$z->bbb;          
    }
    $arraysOf[]=$z;
}
$fin=memory_get_usage();    
echo '<p>Time Taken (seconds): '.(microtime(true) - $t0).'</p>';
echo '<p>Memory: '.($fin-$inicio).'</p>';
p($z);

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

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

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

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

p($z);

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

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


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

और यहाँ परिणाम हैं:

Time Taken (seconds): 3.9636149406433

Memory: 164920

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
)


0

यदि Arrays और Class समान प्रदर्शन हैं, तो मुझे लगता है कि व्यवसाय डेटा को संग्रहीत / पास करने के लिए पूर्वनिर्धारित कक्षाओं की वस्तुओं का उपयोग करना हमारे कार्यक्रम को अधिक तर्क और कोड को अधिक पठनीयता बनाएगा।

आज, ग्रहण, नेटबीन जैसे आधुनिक विचारधारा के साथ ... यह जानना बहुत सुविधाजनक है कि कौन सी जानकारी एक वस्तु (पूर्वनिर्धारित वर्ग) ले जा रही है लेकिन सरणियाँ ऐसा नहीं हैं

जैसे: सरणी के साथ

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

वस्तु के साथ

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
    ...
}

यह अन्य सिद्ध उत्तरों का खंडन करता है और इसका कोई प्रमाण नहीं है। तो यह एक वास्तविक उत्तर की तुलना में अधिक वैचारिक विश्वास है।
स्कोन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.