Consider the following code, in which the setter is deliberately broken due to a mundane programming error that I have made for real a few times in the past:
<?php
class TestClass {
private $testField;
function setField($newVal) {
$testField = $newVal;
// deliberately broken; should be `$this->testField = $newVal`
}
function getField() {
return $this->testField;
}
}
$testInstance = new TestClass();
$testInstance->setField("Hello world!");
// Actually prints nothing; getField() returns null
echo $testInstance->getField();
?>
The fact that I declared $testField at the top of the class helps conceal that programming error from me. If I hadn’t declared the field, then I would get something similar to the following warning printed to my error log upon calling this script, which would potentially be valuable to helping my debugging – especially if I were to make an error like this in a large and complicated real-world application:
PHP Notice: Undefined property: TestClass::$testField in /var/www/test.php on line 13
With the declaration, there is no warning.
Perhaps I’m missing something, but I’m aware of only two reasons to declare class fields in PHP: firstly, that the declarations act as documentation, and secondly, that without declarations one can’t use the private and protected access modifiers, which are arguably useful. Since the latter argument doesn’t apply to public fields – assigning to an undeclared field of an object makes it public – it seems to me that I ought to at least comment out all my public field declarations. The comments will provide the exact same documentation value, but I will benefit from warnings if I try to read an uninitialized field.
On further thought, though, it doesn’t seem to make sense to stop there. Since in my experience trying to read an uninitialized field is a much more common cause of error than trying to inappropriately read or modify a private or protected field (I’ve done the former several times already in my short programming career, but never the latter), it looks to me like commenting out all field declarations – not just public ones – would be best practice.
What makes me hesitate is that I’ve never seen anybody else do it in their code. Why not? Is there a benefit to declaring class fields that I’m not aware of? Or can I modify PHP’s configuration in some way to change the behavior of field declarations so that I can use real field declarations and still benefit from “Undefined property” warnings? Or is there anything else at all that I’ve missed in my analysis?
22
You should always declare your class properties ahead of time. While PHP is a dynamic language and will happily go right along with you creating your properties at runtime, there are several downsides to this path.
- The compiler can optimize declared properties. When you dynamically declare a property this is a performance hit as the compiler has to create a dynamic hash table to store your dynamic properties.
- I’m not 100% on this one but I believe that bytecode optimizers like APC won’t be as useful since they won’t have a full picture of your class. (And optimizers like APC are a must)
- Makes your code 1000x harder to read. People will hate you.
- Makes it 1000x more likely that you will make a mistake. (Was it getId or getID? Wait, you used both. Fail.)
- No IDE autocompleting or type hinting.
- Documentation generators won’t see your property.
The problem you described is actually a minor one when compared to the problem of not declaring your properties in your class definition. Here’s a good solution.
Get used to declaring defaults for your properties.
private $testField = null;
private $testField = '';
private $testField = 0;
private $testField = []; //array()
private $testField = false;
Except for properties that will be storing objects, this will cover the majority of base types that you will be storing. The properties that will be storing objects can be set in your constructor.
A good rule for class design is that after your object has been created and your constructor has run you shouldn’t have any properties out there “undefined”.
7
I worked on some code that used dynamically created object properties. I thought that using dynamically created object properties was pretty cool (true, in my opinion). However, my program took 7 seconds to run. I removed the dynamic object properties and replaced them object properties declared as part of each class (public in this case). CPU time went from over 7 seconds to 0.177 seconds. That’s pretty substantial.
It is possible that I was doing something wrong in the way I was using dynamic object properties. It is also possible that my configuration is broken in some way. Of course, I should say that I have a very plain vanilla PHP configuration on my machine.