Is that all that's wrong with PHP?

Strings

Imagine setting up the following variable in PHP:

This is an array whose only element is an array of one element (with one key). While a contrived example, it is is perfectly common to have two dimensional arrays in programming. Now, as the keys of these arrays and the value in the innermost array are all strings, it is natural to want to create a string using a reference to $a and its contents.

For example, the documentation says you can do this:

and the result would be Array because the array $b gets cast to the string Array. Equivalently you can run:

which returns the same answer, but uses the fact that within double quotes, the string keys of array elements must not be enclosed within quotes at all. This might be surprising, but if you do the natural thing of putting single quotes in the example above, you get this error back:

Parse error: syntax error, unexpected T_ENCAPSED_AND_WHITESPACE, expecting T_STRING or T_VARIABLE or T_NUM_STRING

Extending these examples, it is perfectly possible to do:

and get the answer d as expected. Remembering the syntax error above, then, you might think that the following would be perfectly syntactically legal:

and you’d be right. What it returns, though, is Array[c] which is precisely what you don’t want, and it doesn’t even produce a warning to tell you it’s done this. Apart from a vague comment that:

“For anything more complex, you should use the complex syntax.”

the fine documentation does not indicate that accessing the second dimension of an array should be impossible in what it calls the “simple syntax” for strings. As some of my co-workers would argue, though, this is why one should always use the complex syntax.

Type juggling

Now consider the following code:

A textbook example of defensive coding, no? No, a textbook example of underhanded coding. Admittedly this mistake cropped up quite legitimately in a piece of excellent code written by a co-worker, but the danger of this code is that PHP is happy to follow your logic and everything will work as you intend, until $arrayFoo has the value you were trying to treat specially, at which point your code will execute the wrong branch and you will be left wondering why.

The reason this is an issue with PHP and not (just) with coding mistakes should become more clear when I explain the type juggling that PHP is doing while interpreting this code. To put this in context, then, $arrayFoo is supposed to be an array (and if it isn’t, you should be using is_array() for starters), but it could be empty, so a check is needed to see whether it has more than zero elements. What the code above actually does, though, is to compare $arrayFoo with zero, which means silently converting $arrayFoo into an integer first. For an empty array, the integer version is zero, and zero is not bigger than zero, so the innermost brackets of the first line evaluate to false.

That is only the first undesired behaviour, though. What then happens is, the sizeof(false) is determined, which does not produce the result 0 or false or throw an error, but is in fact 1. The final bit of type juggling is that 1 of course is considered true, so the if condition passes and the else block never gets executed.

Groovy

Also in some PHP code recently I saw something like this:

which I wanted to refactor but realised that without writing a for loop or a special function, I had to leave this monstrosity in. Then I imagined rewriting the whole project in Groovy and found that thought somehow comforting. So that evening, I went home, fired up the Groovy console, waited for it to load, and started typing code into it while trying to work out from the wonderful documentation exactly what it was I was supposed to be doing.

The result of all this effort is the beautiful one-liner in the code below:

which produces the following output:

This is such easy to understand, concise code, it almost slips right off the page and into your brain directly. What’s more, it is also easily maintainable, and you could add the equivalent of two whole PHP lines of code just by changing the 5 to a 7, a one bit change in Groovy! Compared to PHP’s 62 bytes extra, that means PHP is 496 times more bloated. Unfortunately, though, Groovy takes about 496 times as long to execute this code in the Groovy console, so it’s a bit of a trade-off.

It also took me about 496 times as long to work out what the magic syntax is in Groovy for populating a map like that this. Is it a good enough excuse to say that I haven’t written any Groovy in a long time and that’s why it took me so many attempts to write that one-liner?