I’m cleaning up a lot of PHP code and always program with PHP error_reporting set to E_ALL and display_errors turned on so that I make sure to catch any PHP messages that come up. Since starting on this site, I have fixed literally hundreds (maybe thousands) of PHP Notices about using uninitialized variables and non-existent array indexes. I have been fixing problems like this where $somevar is sometimes undefined: by changing it to: This successfully gets rid of the NOTICEs, but adds some overhead because PHP has to perform two checks. After fixing a lot of this in this manner, I’ve noticed that the pages seem to be generated a little slower. So, to provide some conclusive results to myself, I wrote up a quick benchmarking script – available at php_empty_benchmark.php. It goes through
1,000,000 tests using each of these methods: It measures the
time to perform 1 million tests using a defined percentage of values that are set. It then computes the difference as a percentage of the time taken for the original test (the one that generates the notices).  A ‘diff’ of 100 means that the execution time is the same, greater than 100 means that it is faster, and less than 100 means that it is slower. A typical test produced these results: In summary, using the if (isset($a) && $a) syntax is about 8-10%
slower than generating the PHP Notice. Using !empty() should be a drop-in replacement that doesn’t generate the notice and has virtually no performance impact. Using ifset() also has no performance impact, but is not exactly the same as ‘if($a)’ since isset() will return true if the variable is set to a false value. I included it here, because it often make the code a little more readable than the !empty($a) syntax. For example: Versus Post navigationI'm aware of the benchmarks for isset() vs empty(), but I have code I need to execute only when the argument is null. This is in a function that executes many times so I'd like to optimize it. I know that isset() is faster than empty(), but what about !isset() vs. === null? I know that the variable will exist, so I only need to test it against null. I'm thinking of the possible penalty for the ! operator. asked Jul 2, 2017 at 6:11
I felt lazy asking someone else to benchmark this, so I tried a million iterations. The difference is trivial, so !isset() is a better option since === null would throw an error if the variable was ever undefined. One Million iterations:
BTW, there is an (also trivial) penalty for the ! operator.
answered Jul 2, 2017 at 6:21
Bob RayBob Ray 9089 silver badges20 bronze badges 2 It's a known flaw in PHP that functions in standard library are inconsistent. Some of them have a terrible API that may return anything from object to null and false. Some of them take arguments by reference, like for instance array sorting functions do. In short there's quite a bit features that work in a complicated fashion that makes the code worse. A part of being a good programmer is to identify features in the language that hurt the code, the software we're building. Once those things are identified, a good programmer will minimize the impact of using those features or completely avoid using them if possible. So, i've been stumbling lately quite a lot on issetisset function in PHP docs:
And by example:
Looking at the definition in PHP docs we can see that the function does two things.
On the example there's three usages that i've witnessed as use cases for Now, the thing why using We don't know if a variable is declared? How did this happen? Either we are doing something very clever, which as we know is an awful habit, or we are working with a completely procedural legacy system. If we do know that the variable is declared, then the only reason we'd use
An alternative using the same solution that would be even more explicit and clear to the reader would be to null check with
Third situation i've seen, and personally used quite a lot, is checking if an array has a specific key:
This is also another case where there's
already a more explicit way to handle the problem.
I admit, using emptyempty function in PHP docs:
Wow, so i might be dealing with a string, integer, float, boolean, null or an array.
If First step to resolve the problem is to use type hints everywhere. Use argument type hints and return type hints in every method and function you write. NOTE: This applies to those developers who work with PHP7 or higher. Second step is to use more explicit conditionals. This means that the
readers of the code don't have to dig deep to boring details when trying to understand what you're trying to accomplish. Using strict comparison (
As a side note, using return type hints is a very good practice. It will result to more clear interfaces. Once you have a return type hint in place, there's no way you can return multiple different things from your method (assuming you don't use nullable type hints, as you should not). Are
you ready to throw |