PHP 객체 vs 어레이 -- 반복 시 성능 비교

programing

PHP 객체 vs 어레이 -- 반복 시 성능 비교

newsource 2022. 10. 6. 22:00

PHP 객체 vs 어레이 -- 반복 시 성능 비교

뉴럴 네트워크를 위한 엄청난 양의 PHP 오브젝트를 가지고 있습니다.그것에 대해 반복하고 몇 가지 계산을 실시해야 합니다.클래스 인스턴스보다 연관 배열을 사용하는 것이 더 나은지 궁금했습니다.

나는 주변과 거래하고 있다.3640 및 " " " 주변에서 "500시간(기껏해야)을 초과하기 때문에 어떤 미세 최적화라도 큰 도움이 됩니다. 수 없이 는이것것 would would would would would would would would would would would would would would ?$object['value']$object->value

편집: 즉, 둘 다 동일합니다.하지만 건설업자에게 비용이 좀 들 것 같은데요?어느 쪽이든, 저는 아름다운 수업에서 지저분한 배열과 바꾸고 싶지 않다고 생각합니다.p

Quazzle 코드를 기반으로 다음 코드(5.4.16 Windows 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의 결론

클래스는 어레이보다 빠릅니다(단, 약간).
stdClass는 사악합니다.
클래스는 어레이보다 메모리를 적게 사용합니다.(약 30~40% 절감!!)

ps: 참고로 클래스가 정의되어 있지만 멤버가 정의되어 있으면 이 클래스의 사용 속도는 느려집니다.또한 메모리를 더 많이 사용합니다.그 비밀은 멤버들을 정의하는 것이라고 한다.

갱신하다

php 5.4에서 php 5.5(5.5.12 x 86 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
)

php 5.5의 결론

어레이의 경우 PHP 5.5가 PHP 5.4보다 빠르지만 오브젝트의 경우 거의 동일합니다.
PHP 5.5 및 어레이의 최적화로 인해 클래스가 어레이보다 느립니다.
stdClass는 사악합니다.
클래스에서 사용하는 메모리가 어레이보다 적다.(약 30~40% 절감!!)
SplFixedArray는 클래스를 사용하는 것과 비슷하지만 더 많은 메모리를 사용합니다.

이 코드를 "프로파일링"에 사용했습니다(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에서도 느려집니다. op 기능이 꼭 필요한 경우가 아니면 개체를 사용하지 마십시오.

magallanes 스크립트 @ PHP 7.3.5

SomeClass Object가장 빠르고 가볍습니다.
Array 1.32배의 속도2.70배 메모리
stdClass Object 1.65배 속도, 2.94배 메모리

원시 출력:

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
)

오늘은 @magallanes 벤치마크를 바탕으로 궁금해서 조금 더 확장했습니다.물건 사이의 차이를 강조하기 위해 몇 개의 for 루프를 올렸습니다.Apache 2.4, mod_php 및 PHP 7.2에서 실행됩니다.

다음은 결과를 쉽게 하기 위한 요약 표입니다.

+---------------------------+---------+-----------------+
|           Test            | Memory  |      Time       |
+---------------------------+---------+-----------------+
| Array                     | 2305848 | 9.5637300014496 |
| stdClass                  | 2505824 | 11.212271928787 |
| SomeClass                 |  963640 | 11.558017015457 | <-- *
| 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/second를 처리하는 사이트가 있고 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<5000; $i++) {
    $z = new SomeClass();
    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 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): 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
)

php 7.0.9에서 magallanes 코드를 사용합니다.

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
)

아직 이 질문에 관심이 있는 분들을 위해:) PHP 7.1 Ubuntu x64에서 Quazzle 코드를 실행했는데 다음과 같은 답변을 받았습니다.

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 still evil © magallanes :)

$object->value이 백엔드는 이론적으로 어레이를 사용하는 것이 더 빠르기 때문에 기능 호출을 1회 줄일 수 있기 때문에 어레이를 사용하는 것이 이론적으로 더 빠를 수 있습니다.Function Call에 비해 lookup 비용이 많이 들 것입니다.변수일 경우 PHP의 개체와 배열은 매우 유사한 구현을 가지고 있기 때문에 차이가 거의 없습니다.

최적화를 검토하는 경우 프로파일링을 통해 대부분의 시간을 어디서 사용하고 있는지 확인해야 합니다.오브젝트를 어레이로 변경해도 큰 차이는 없을 것 같습니다.

오래된 게시물이라 업데이트하려고요.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;
  }
}

이와 같은 마이크로 퍼포먼스 기능에 대해서는 언제든지 PHP 소스 코드를 확인할 수 있습니다.

그러나 언뜻 보면 ['value']를 실행하지 않는 것이 빠르지 않습니다.이는 해시테이블 검색이 O(1)가 되어야 한다고 해도 PHP가 ['value']를 찾을 수 있는 위치에 대한 검색을 수행해야 하기 때문입니다.텍스트 색인을 사용하면 더 많은 오버헤드가 발생합니다.

개체에 액세스해야 하는 변수(값)가 하나만 포함된 경우 개체 사용에 대한 오버헤드가 증가합니다.

어레이와 클래스가 같은 퍼포먼스라면 비즈니스 데이터를 저장/전달하기 위해 미리 정의된 클래스의 오브젝트를 사용하면 프로그램이 보다 논리적이고 읽기 쉽다고 생각합니다.

오늘날, Eclipse, Netbean과 같은 현대적인 이데올로기로...(미리 정의된 클래스의) 객체가 어떤 정보를 전송하고 있는지 아는 것은 매우 편리하지만 어레이는 그렇지 않습니다.

예: 어레이 포함

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

공평하게 말하자면, 당신이 가지고 있는 데이터의 종류에 따라 다릅니다.다른 답변의 결과는 (거의) 정답입니다.*알기 쉽게 하기 위해 아래에 테스트 코드를 붙여 놓을게요.

여기서 중요한 것은 미리 정의된 개체를 사용하면 메모리를 상당히 절약할 수 있다는 것입니다. 단점은 정확한 구조를 정의해야 한다는 것입니다.

다음 테스트 결과를 고려하십시오.

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

제가 틀렸을 수도 있습니다.PHP 소스를 조사하지는 않았지만 PHP에 관한 한 모든 것은 어레이라고 생각합니다.미리 정의된 개체는 제대로 정의된 배열일 뿐입니다.흥미로운 점은 값 유형이 영향을 미치지 않는다는 것입니다. 즉, 문자열 값 '1'이 bool 값 true와 동일한 양의 메모리를 차지합니다.

왜일까요? PHP는 어레이이기 때문에 셋터 기능을 가진 오브젝트가 있다면 PHP는 다음과 같습니다.

$objects = ['objectName' => [
    'aaa' => '',
    'bbb' => '',
    'ccc' => '',
    'setValue:f' => function('name', 'value') { ... }
    ]
];

실행할 때마다 백그라운드에서 소품 이름 및 소품 유형 등에 대한 유효성 검사를 수행하는 기능 키를 검색합니다.메모리 청크를 할당하는 대신에, 미리 정의된 오브젝트내의 메모리 절약은, 설정된 길이의 어레이를 정의하는 것으로부터 실현됩니다(그렇지 않으면 PHP에서는 불가능).

결론:

정적 객체: 예! 메모리를 절약할 수 있습니다!그러나 정의 이외의 것을 추가하려고 하면 stdClass보다 더 커집니다.

['aaa'] into [['aaa'],['bbb']]

배열: PHP로 쓰면 더 좋아할 것입니다. 문자열도 PHP의 문자 배열입니다.

오브젝트: 오브젝트는 쿨한 기능을 갖추고 있어 코드를 정리하고 깔끔하고 모듈러형으로 유지할 수 있습니다.하지만 우리 모두 알다시피, "큰 힘을 가지고".".

마지막으로 테스트 코드와 "*"는 스크립트 실행 중에 변수를 정리하지 않으면 메모리에 남아 실행 시간에 큰 영향을 주지 않고 메모리 측정에 영향을 미친다는 사실을 잊은 것 같습니다.메모리 프로파일링을 실행하는 동안 unset()은 당신의 친구입니다.

<?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++) {
    $z = array(); // definition
    for ($j=0; $j<$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<$noOfObjects; $i++) {
    $z = new set(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = new staticSet(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = new staticSet2(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = new Ds\Map(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = new staticSet(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = new staticSet3(); // definition
    for ($j=0; $j<$noOfOperations; $j++) {
        $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++) {
    $z = array('aaa' => '','bbb' => '','ccc' => ''); // definition
    for ($j=0; $j<$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;

언급URL : https://stackoverflow.com/questions/2193049/php-objects-vs-arrays-performance-comparison-while-iterating

'programing' 카테고리의 다른 글

두 좌표 사이의 거리를 계산하는 함수 (0)	2022.10.06
Java / Android - 전체 스택 트레이스를 인쇄하는 방법 (0)	2022.10.06
64비트 OS에서 32비트 JVM의 최대 Java 힙 크기 (0)	2022.10.06
생성 시 및 업데이트 시 MySQL CURRENT_TIMESTamp (0)	2022.10.06
HTML을 PHP 함수로 되돌리는 방법이 있습니까?(반환값을 문자열로 작성하지 않음) (0)	2022.10.06

현재글PHP 객체 vs 어레이 -- 반복 시 성능 비교

각종 프로그래밍 정보를 다루는 블로그입니다.

Oracle, javascript, python, C, vuex, Git, mysql, angularJS, json, wordpress, Spring-boot, Excel, asp.net, vuejs2, MongoDB, Java, reactjs, MariaDB, php, jQuery,

Today :
Yesterday :

newsource

PHP 객체 vs 어레이 -- 반복 시 성능 비교

PHP 객체 vs 어레이 -- 반복 시 성능 비교

갱신하다

php 5.5의 결론

결론

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2025/01 »
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

PHP 객체 vs 어레이 -- 반복 시 성능 비교

PHP 객체 vs 어레이 -- 반복 시 성능 비교

갱신하다

php 5.5의 결론

결론

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바