Chaining Multiple Objects in PHP
I like encapsulation. Unfortunately PHP is a language that presents some interesting challenges to the classical interpretation of Object Oriented Programming.

There’s a couple things you should know about objects in PHP:

• Objects became available in PHP in version 5. We’re still on version 5 today, even though it came out in 2004… *rolls eyes*
• At this time, PHP Doesn’t support multiple inheritance. This means you can only chain objects together one by one.
• Object oriented php is a little slower than procedural php, as discussed here
• Constructors are only called on the implemented object.

The last one is a little important. If you instantiate an object, only that object’s constructor will be called by PHP. This is important when you start extending other objects that also have constructors. You’ll have errors unless you manually call the constructor of each parent with

parent::__construct();

Is it Worth It?
Some would say, no, just chuck every function that’s needed for this sort of thing into one big object. Personally, I like encapsulation. At the least, it makes functions easier to read. At the best, it keeps everything clean and organized and functioning properly while allowing reverse compatibility during future changes.

After building a few objects and changing them by simply using the extends keyword, I wanted to know if all that work I just did to encapsulate 5 different objects was actually going to be run slower by PHP than if I had left it as one big blob.

The Code

$iterations = 10000;
//--------------------------------------------------
$start = microtime(true);
class test{

public $apples;
public $oranges;
public $pares;

public function apples(){
$this->apples++;
}
public function oranges(){
$this->oranges++;
}
public function pares(){
$this->pares++;
}
}

$test = new test;
for($x=0; $x<$iterations; $x++){ $test->apples();
$test->oranges();
$test->pares();
}
$end = microtime(true) - $start;
$output .= '<hr/>Single Object Elapsed: ' . $end;
//--------------------------------------------------

//--------------------------------------------------
$start = microtime(true);
class apple{
public $apples;
public function apples(){
$this->apples++;
}
}
class orange extends apple{
public $oranges;
public function oranges(){
$this->oranges++;
}
}
class pare extends orange{
public $pares;
public function pares(){
$this->pares++;
}
}
class test2 extends pare{

}

$test2 = new test2;
for($x=0; $x<$iterations; $x++){ $test2->apples();
$test2->oranges();
$test2->pares();
}
$end = microtime(true) - $start;
$output .= '<hr/>Multiple Objects Elapsed: ' . $end;
//--------------------------------------------------

The Results

Conclusion
Now I’m just more confused than when I started. On average, it looks like chaining objects together is marginally slower than just lumping all the functions together in one object. Although the fringe cases prove that sometimes it is much faster… and yet, sometimes much slower.

Looks like a wash to me.