পিএইচপি অবজেক্টস বনাম অ্যারে - পুনরাবৃত্তির সময় পারফরম্যান্স তুলনা


91

নিউরাল নেটওয়ার্কের জন্য আমার কাছে প্রচুর পরিমাণে পিএইচপি অবজেক্ট রয়েছে যার জন্য আমাকে পুনরাবৃত্তি করতে হবে এবং কিছু গণিত সম্পাদন করতে হবে। আমি ভাবছিলাম আমি ক্লাসের উদাহরণগুলির চেয়ে সাহসী অ্যারে ব্যবহার করা ভাল কিনা?

আমি চারপাশে 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
)

পিএইচপি 5.4 এর উপসংহার

  1. ক্লাসটি অ্যারেগুলির তুলনায় দ্রুত (তবে প্রান্তিক) is
  2. stdClass খারাপ।
  3. ক্লাস অ্যারেগুলির চেয়ে কম মেমরি ব্যবহার করে। (প্রায় 30-40% কম !!)

PS: একটি নোট হিসাবে, ক্লাস সংজ্ঞায়িত করা হয় তবে সদস্যরা তখন, এই শ্রেণীর ব্যবহার ধীর হয়। এটি আরও স্মৃতি ব্যবহার করে। স্পষ্টতই গোপন সদস্যদের সংজ্ঞা দেওয়া হয়

হালনাগাদ

আমি পিএইচপি 5.4 থেকে পিএইচপি 5.5 (5.5.12 এক্স 86 উইন্ডোজ) এ আপডেট করেছি।

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
)

পিএইচপি 5.5 এর উপসংহার

  1. অ্যারেগুলির জন্য, পিএইচপি 5.5 পিএইচপি 5.4 এর চেয়ে দ্রুত, বস্তুর জন্য এটি প্রায় একই রকম
  2. ক্লাসটি পিএইচপি 5.5 এবং অ্যারের অনুকূলকরণের জন্য অ্যারেগুলির চেয়ে ধীরে ধীরে অ্যারে।
  3. stdClass খারাপ।
  4. ক্লাস এখনও অ্যারের চেয়ে কম মেমরি ব্যবহার করে। (প্রায় 30-40% কম !!)।
  5. SplFixedArray ক্লাস ব্যবহারের মতো তবে এটি আরও মেমরি ব্যবহার করে।

একটা ভাল কাজ করল ভাল স্যার। : নেস্টেড অ্যারে, ইত্যাদি অন্যান্য পিএইচপি পারফরম্যান্সের জন্য আকর্ষণীয় সাইট এই আউট প্রসারিত আকর্ষণীয় হতে হবে phpbench.com php-benchmark-script.com কিন্তু আমি যে আপনার মেমরি ব্যবহার মত হিসাবে ভাল।
এন

4
পিএইচপি 7 এর সাথে অ্যারে এবং অবজেক্টগুলির মধ্যে পার্থক্য আরও তাৎপর্যপূর্ণ হয়ে ওঠে। আপনার স্ক্রিপ্ট 30% রানটাইম এবং 60% মেমরির তফাত দেখায়। এটি কেবলমাত্র আমার মেশিন, তবে থাম্বের নিয়ম হিসাবে: অ্যারে স্ট্রোক হিসাবে ব্যবহার করবেন না। পরিবর্তে অবজেক্ট ব্যবহার করুন :)
কিং ক্রঞ্চ 21

এক্ষেত্রে কি ক্লাসের চেয়ে অবজেক্ট আলাদা?
ম্যাট জি

কোনও পিএইচপি 7 আপডেটের আশায় এটি বুকমার্কিং। এবং সম্ভবত আসন্ন পিএইচপি 8, প্রযোজ্য তখন। @ ম্যাগল্যানেস
এস

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

এটি আমার লিনাক্সের এই জিনিসগুলি হোস্টিংয়ের ফলাফল:

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

সুতরাং উপসংহারে: পিএইচপি 5.2-তে এমনকি বস্তুগুলি ধীরে ধীরে হয়। আপনার যদি সত্যই তাদের ওপ বৈশিষ্ট্যগুলি না লাগে তবে অবজেক্টগুলি ব্যবহার করবেন না।


7
ব্যবহারকারী levans থেকে stackoverflow.com/users/1473035/levans : আমি 5.3.8 সঙ্গে এই দৌড়ে গিয়ে বস্তু ধীর, 0,51839280128479 অবজেক্টের জন্য অ্যারে বনাম 0,85355806350708 জন্য ছিল। আমি এটি 5.4.13 এও চালিয়েছি এবং বিপরীতে ফলাফল পেয়েছি, সম্ভবত 5.4, 0.6256799697876 বনাম অ্যারেগুলির জন্য 0.43650078773499 এ করা ক্লাস অপ্টিমাইজেশনের কারণে। এভাবে দেখতে দেখতে টেবিলগুলি পরিণত হয়েছে এবং অবজেক্টগুলি এখন যাওয়ার পথে।
জিন-বার্নার্ড পেলারিন

4
উত্তম উত্তর, আমি স্রেফ XAMPP (অ্যাপাচি) পরীক্ষা করেছি এবং নীচের ফলাফল পেয়েছি: অ্যারে: 0.5174868106842 অ্যারে ([এএএএ] => আআআ [বিবিবি] => বিবিবি [সিসিসি] => আআবিবিবি) আপত্তি: 0.72189617156982 স্টাডি ক্লাস অবজেক্ট ([এএএএ]] => আআ [বিবিবি] => বিবিবি [সিসিসি] => আআবিবিবি) phpversion 5.4.19
ilhnctn

4
আমি 5.4.13 এও দৌড়েছি, তবে জিন-বার্নার্ড পেলারিনের বিপরীতে পেয়েছি: অ্যারে: 0.5020840167999 অবজেক্টস: 1.0378720760345 সুতরাং আমি ঠিক এখনও অবজেক্টগুলিতে প্রতিশ্রুতিবদ্ধ না।
সিমোনটেম্পলার

আমি কোডে কিছু পরিবর্তন করেছি এবং ক্লাস পিএইচপি 5.4 (5.4.16 32 বিট উইন্ডোজ) এর জন্য অ্যারেগুলির চেয়ে দ্রুত। আমি একটি নতুন উত্তর রাখলাম যা কারণটি ব্যাখ্যা করে।
ম্যাগালেনগুলি

পিএইচপি 5.5.11 ফলাফল: অ্যারে: 0.17430, অবজেক্টস: 0.24183
লেক্স

3

আমি পিএইচপি 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
)

এবং ব্যবহারকারী পিএইচপি 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
)                      

4
এবং stdClass রিয়েল স্ট্রিংয়ের সংখ্যা কী ব্যবহার করতে পারে তা ভুলে যাবেন না। ['1' => 1] [1 => 1] হিসাবে সংরক্ষণ করা হবে, তবে আমরা $a=new stdClass(); $a->{1} = 1; $b=(array)$a;আসল ['1' => 1] ব্যবহার করতে পারি ।
রথিয়থ

4
সুতরাং, উপসংহারে .. অ্যারেগুলি 18% বেশি দ্রুত কিন্তু 2.7x বেশি মেমরি গ্রহণ করে consume
jchook

3

ম্যাগলেনেসের স্ক্রিপ্ট @ পিএইচপি 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

এখনও এই প্রশ্নে আগ্রহী যে কারও জন্য :) আমি পিএইচপি 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 এখনও খারাপ © মাগলেনেস :)


2

আপনি কীভাবে $object->valueকাজ করে তার জন্য আপনি আমাদের কোডটি দেখান নি , কারণ এটি ব্যাকএন্ড হতে পারে এটি একটি অ্যারে যা ক্ষেত্রে তাত্ত্বিকভাবে অ্যারে ব্যবহার করা তত দ্রুত হবে কারণ এতে একটি কম ফাংশন কল অন্তর্ভুক্ত রয়েছে। ফাংশন কলটির তুলনায় লুকআপ করার ব্যয়টি সম্ভবত বিশাল হবে। যদি এটি পরিবর্তনশীল হয় তবে পিএইচপি-তে অবজেক্টস এবং অ্যারেগুলির খুব একই রকম বাস্তবায়ন হওয়ায় খুব সামান্য পার্থক্য হতে চলেছে।

আপনি যদি অপ্টিমাইজেশনের দিকে তাকিয়ে থাকেন তবে বেশিরভাগ সময় কোথায় ব্যবহৃত হচ্ছে তা পরীক্ষা করার জন্য আপনাকে প্রোফাইল তৈরি করতে হবে। আমার সন্দেহ হয় যে অ্যারেগুলিতে অবজেক্টগুলি পরিবর্তন করা কোনও বড় পার্থক্য তৈরি করবে না।


আমি ধরে নিয়েছি যে মানটি একটি সর্বজনীন পরিবর্তনশীল হবে, সুতরাং হ্যাশ-লুকিং নাও হতে পারে তাই স্পষ্টতই হে (1)।
ফিলিপ একবার্গ

2

আমি এটি একটি পুরানো পোস্টের মতো দেখতে পেয়েছি তাই আমি ভেবেছিলাম এটি আপডেট করব। এখানে আমার কোড এবং পরিসংখ্যানগুলি রয়েছে, জেন্ডেড সিই 5.3.21 তে করা হয়েছে আমি পুরো জিনিসটি পরীক্ষার চেষ্টা করেছি, তথ্য সঞ্চয় করে এবং এটিকে আবার টানছি।

ভি 1: 0.83 সেকেন্ড লাগে

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

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

ভি 2: 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;
}

ভি 3: 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

এর মতো মাইক্রো পারফরম্যান্স-বৈশিষ্ট্যগুলির জন্য আপনি সর্বদা পিএইচপি-উত্স কোড পরীক্ষা করতে পারেন।

তবে প্রথম নজরে, কোনও ['মান'] করা তত দ্রুত হবে না কারণ পিএইচপি-র কোথায় "[মান"] সন্ধান করতে হবে সেদিকে নজর রাখতে হবে এমনকি হ্যাশটেবল লুকও ও (1) হওয়া উচিত, এটির গ্যারান্টি নেই। আপনি যখন পাঠ্য-সূচি ব্যবহার করেন তখন আরও ওভারহেড থাকে।

যদি অবজেক্টটিতে কেবলমাত্র 1 টি ভেরিয়েবল থাকে যা আপনার অ্যাক্সেস করতে হবে যা মান,


এবং আপনি কী ভাবেন সম্পত্তিগুলি সন্ধান করা হবে? তারা একটি হ্যাশ টেবিলের মধ্যেও রয়েছে ... (যদিও এটি ট্রাঙ্কের ক্ষেত্রে কম বা কম সত্য)।
আর্টেফ্যাক্টো

1

ভাল, আজ আমি @ ম্যাগালেনস বেঞ্চমার্কের ভিত্তিতে কৌতূহল পেয়েছি, তাই আমি এটি কিছুটা প্রসারিত করেছি। আমি জিনিসগুলির মধ্যে ফাঁকগুলি হাইলাইট করার জন্য লুপগুলির জন্য কিছু আপ করেছি। এটি অ্যাপাচি ২.৪, মোড_এফপি এবং পিএইচপি .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

নীচে পরিবর্তিত স্ক্রিপ্ট আছে। আমি পদ্ধতিগুলি এবং সংজ্ঞায়িত প্রকারের সাহায্যে বৈশিষ্ট্য নির্ধারণ করতে চেয়েছিলাম। আমি খুব অবাক হয়ে গিয়েছিলাম যে সেটার পদ্ধতি ব্যবহার করে কোডটিতে উল্লেখযোগ্য হিট যুক্ত হয়। এখন মঞ্জুর করা হচ্ছে এটি একটি খুব নির্দিষ্ট পারফরম্যান্স পরীক্ষা many যেখানে অনেক অ্যাপ্লিকেশন এমনকি এটিকে আঘাত করে না। তবে আপনার যদি এমন একটি সাইট রয়েছে যা 1000 / রেইকস / সেকেন্ডের সাথে 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

যদি অ্যারে এবং ক্লাসগুলি একই পারফরম্যান্স হয়, আমার মনে হয় ব্যবসায়িক ডেটা সংরক্ষণ / পাস করার জন্য পূর্বনির্ধারিত শ্রেণীর আইটেমগুলি আমাদের প্রোগ্রামকে আরও যুক্তিযুক্ত করে তোলে এবং কোডটি আরও পাঠযোগ্য।

আজ, ইক্লিপস, নেটবিনের মতো আধুনিক আদর্শের সাথে ... এটি কোনও জিনিস (পূর্বনির্ধারিত শ্রেণীর) কী তথ্য বহন করছে তা জানা খুব সুবিধাজনক তবে অ্যারেগুলি তেমন নয়

যেমন: অ্যারে সহ ray

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

এটি অন্যান্য প্রমাণিত উত্তরগুলির সাথে স্ববিরোধী এবং এর কোনও প্রমাণ নেই। সুতরাং এটি একটি আসল উত্তরের চেয়ে আদর্শিক বিশ্বাস।
scones
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.