Why you should probably use objects

1. Objects is a more powerful and concise way to handle data than mere associative arrays, and the aspiring PHP developer will appreciate that objects may be used in similar ways as arrays. E.g. we may even use the foreach loop to iterate over the the properties in an object:

$containerObject = new stdClass();
$containerObject->one = 1;
$containerObject->two = 2;

foreach ($containerObject as $property_name => $value) {
  echo $property_name .' '. $value . PHP_EOL;
}

Again, however, developer restraints might prevent us from doing that; an object might have defined its properties as "private", which means that we will not be able to access them directly. Instead the object might have a public method (a function belonging to the object), which we can use to access certain data within the object. E.g. An all_elements() method could return the results from a database query as an array, and we will often be able to loop over the output of such a function.

2. A great benefit of using objects is the fact that editors will expose public method- and property names when other developers are using our data structures, which reduce the risk of typos and other mistakes; if you were to use a non-existent method on an object you would get an error – with arrays the exact behaviour if you were to misspell an array key is more unpredictable, and potential resulting bugs can be harder to trace when using arrays.

3. Through the use of typed properties, you can define specific data types acceptable to a given property or method; if some other developer were to feed one of our methods an unsupported data type, they would get an error telling them exactly what they did wrong. In fact, you can even specify return types, so if an unexpected data type is suddenly returned, an exception will be thrown, and you will be able to more easily debug what has happened.

Anonymous classes in PHP 7

PHP 7 improved OOP even further by adding support for on-the-fly anonymous classes, avoiding the use of the generic, and clumsy, stdClass when spewing out object "data containers".

For example, the below example is created on-the-fly within an existing class:

// Anonymous class
$containerObject = new class() {
  public $one;
  public $two;
};

$containerObject->one = 1;
$containerObject->two = 2;
$containerObject->three = 3;

foreach ($containerObject as $property_name => $value) {
  echo $property_name .' '. $value . PHP_EOL;
}

For all intends and purposes, this is the equivalent of creating a traditional class. We can even add magic methods to the class. For example, using __set() we may prevent adding properties from the outside:

public function __set($name, $value) {
  throw new \Exception("Adding new properties is not allowed on this object");
}

Allowed characters in variables

As you may know, with arrays, we can use any string as a key name, but when using object properties we will normally be limited to using underscores, letters and numbers.

There is at least couple of ways around this problem:

1. We can use variable variables to allow special characters in the variable name.
2. We can use an array inside the object.

A dynamically named variable can be assigned like this:

$a = '##'; // Name of the variable

$$a = 'Hallo World'; // Data in the variable

echo ${'##'}; // Output the variable

Or, even easier:

${'%&¤'} = 'Hallo World';
echo ${'%&¤'};

To declare a property with special characters in an OO context, we may do like:

$myObject->${'##'} = 'Hallo World'; // Assign value
echo $myObject->${'##'}; // Output data

Tell us what you think: