Value objects vs associative arrays in PHP

Question

(This question uses PHP as context but isn't restricted to PHP only. e.g. Any language with built in hash is also relevant)

Let's look at this example (PHP):

function makeAFredUsingAssoc() {     return array(         'id'=>1337,         'height'=>137,         'name'=>"Green Fred"); } 

Versus:

class Fred {     public $id;     public $height;     public $name;      public function __construct($id, $height, $name)     {         $this->id = $id;         $this->height = $height;         $this->name = $name;     } }  function makeAFredUsingValueObject() {     return new Fred(1337, 137, "Green Fred"); } 

Method #1 is of course terser, however it may easily lead to error such as

$myFred = makeAFredUsingAssoc(); return $myFred['naem']; // notice teh typo here 

Of course, one might argue that $myFred->naem will equally lead to error, which is true. However having a formal class just feels more rigid to me, but I can't really justify it.

What would be the pros/cons to using each approach and when should people use which approach?

Answer 1

Under the surface, the two approaches are equivalent. However, you get most of the standard OO benefits when using a class: encapsulation, inheritance, etc.

Also, look at the following examples:

$arr['naem'] = 'John'; 

is perfectly valid and could be a difficult bug to find.

On the other hand,

$class->setNaem('John'); 

will never work.

Answer 2

A simple class like this one:

class PersonalData {     protected $firstname;     protected $lastname;      // Getters/setters here } 

Has few advantages over an array.

1. There is no possibility to make some typos. $data['firtsname'] = 'Chris'; will work while $data->setFirtsname('Chris'); will throw en error.

2. Type hinting: PHP arrays can contain everything (including nothing) while well defined class contains only specified data.

   public function doSth(array $personalData) {     $this->doSthElse($personalData['firstname']); // What if "firstname" index doesn't exist? }   public function doSth(PersonalData $personalData) {     // I am guaranteed that following method exists.      // In worst case it will return NULL or some default value     $this->doSthElse($personalData->getFirstname()); } 

3. We can add some extra code before set/get operations, like validation or logging:

   public function setFirstname($firstname) {     if (/* doesn't match "firstname" regular expression */) {         throw new InvalidArgumentException('blah blah blah');     }   
   if (/* in debbug mode */) {     log('Firstname set to: ' . $firstname); }   $this->firstname = $firstname; 
     } 

4. We can use all the benefits of OOP like inheritance, polymorphism, type hinting, encapsulation and so on...
5. As mentioned before all of our "structs" can inherit from some base class that provides implementation for Countable, Serializable or Iterator interfaces, so our structs could use foreach loops etc.
6. IDE support.

The only disadvantage seems to be speed. Creation of an array and operating on it is faster. However we all know that in many cases CPU time is much cheaper than programmer time. ;)