Why implement it in PHP code rather than make a change to the syntax itself? Well, the reason is fairly simple; having too many syntaxes for the same thing can make code very difficult to read and understand unless the reader is a guru in that particular language. Anyone who has been forced to use Perl will know what I mean.

The above comment suggested the use of the eval() function. Whilst this would work, I don’t particularly like the idea for a number of reasons:

• If there is an error in the eval’d code, this will show up in a back-trace as occurring in eval’d code rather than pointing to the actual problem itself – messy.
• If like me, you are used to a nice, cushy IDE, you’ll know that almost all of your code completion / highlighting immediately goes out the window inside of a string.
• I try to avoid eval() as a rule of thumb. It just makes me feel dirty.

I thought I might try a similar solution however, using PHP 5.3′s new closures feature. Closures (A.K.A. anonymous functions) will most likely be familiar to anyone who has used JavaScript in any serious fashion, so I will not go into them here. If you are unfamiliar with the concept, please RTFM.

In order to make this work there are a few things we need:

• An array to iterate over
• A condition of some sort to evaluate on each loop
• A callback to execute if the condition evaluates to true
• Some measure of control over variable names passed to the callback would also be nice

The bottom line is that it is possible, but it’s nowhere near as nice, or elegant as I had hoped.

Method 1: using closures

Using nothing but the new closures syntax I was able to come up with the following reasonable-looking foreachif() function:

This seemed fine until the time came to actually use the thing. Reproducing one of the examples from the aforementioned article resulted in this mess:

Not particularly readable huh? Downright horrible is more like it.

Method 2: mixed closures and eval’d strings

The above mess made me think perhaps I could just use eval() for the condition – perhaps this would help remove some clutter from the statement? Well, yes it does, but it also presents its own problems. Here is the new function:

In order to retain flexibility in naming the variable used to store the current iteration value, I was forced to pass the variable name as a string. I didn’t like this at all, and the situation would only get worse if you wanted to be able to choose the name of the array key inside the condition also.

For the sake of completeness, here is an example the utilises the above function:

Then suddenly I realised I was forgetting a very, very important point; variable scope.

The big problem

What neither of the above implementations give you is access to any variables defined outside of the closure / eval’d code itself. Granted this could be worked around by grabbing every defined variable and re-defining them within the scope of the loop content, but this would almost certainly have major performance issues when used in any real-world situation.

At this point I basically abandoned the search for a function-based implementation and started considering PHP syntax alternatives, which turned out to be a much more elegant solution in the end…

Method 3: using existing PHP syntax in alternative ways

Starting with the ultra-obvious solution gives us the following:

There is also PHP’s alternate syntax for these structures to consider, and I think the following actually comes out looking quite nice:

The main area in which I intended to use this structure was in native PHP templating. In line with this thinking, here is the above restated as I would present it in a template:

As you can see, these last three examples are actually quite readable (the last one as much so as native PHP templating can be). The big bonus of course is that they still allow access to all variables in their scope and have no significant performance impact (provided of course that your condition is not intensive on resources).

If you missed part 1 (you probably did), you can read it here.

“What the hell is a reverse combined operator?” I hear you scream. Well, technically they probably don’t exist yet, so I’m sure a better name could be found, but bear with me and I’ll try to explain…

If you’ve ever done any programming, then you’ve almost certainly used operators whether you realise it or not. Basically, they are some of the most basic building blocks of a programming language, things like +, -, = and == are all operators. For a more detailed description, see the PHP manual.

One of the most commonly used operators in any language is the assignment operator (=). This operator is used to assign a value to a variable. Here is a simple example:

In the above example, PHP first uses the addition operator to get the sum of 1 and 1. It then stores the result in $variable using the assignment operator.

Now consider the following situation; you have a variable that you want to add a certain amount to. Rather than writing the whole expression out like this:

PHP allows you to shorten the above to just:

This is called a combined operator because it is effectively a combination of the + and = operators. This combining of operators is only ever done with the assignment operator and one other operator. Here are all the combined operators that I am aware of:

What I would like to see are reverse combined operators. Essentially these would be the same as regular combined operators, except with the order of operands reversed. This would produce the following options:

Note that not every combined operator would imply the need for a reverse version because the order of operands has no effect on the result in some cases.

I’ll now provide you with a couple of examples where something like this could come in handy.

Inverting a number:

Controlling which array takes precedence when merging arrays using the array union operator (basically just the + operator, but when used on arrays you get the union of the two):

I’m sure if you racked your brain you could come up with dozens of other handy little uses for this feature. Let me know if you can think of any others!

Sometimes though, I do wish for something more. Never enough to switch teams (sorry Python), but there are a few points I keep coming back to. This, in fact, is at the present moment the sole reason for this blog’s existence – I simply don’t have anywhere else to voice my frustration.

So, without further ado I give you part 1 of my PHP wish list: the foreachif() construct!

The foreach() construct is a feature of many modern programming languages, including PHP. In PHP’s case, there are two syntaxes:

foreach (array_expression as $value)
    statement
foreach (array_expression as $key => $value)
    statement

Basically it will iterate over every value in an array but it has advantages over a regular for() loop in cases where the array keys are non-sequential (and it can also iterate over an object’s member variables).

Whilst foreach() is a very useful construct in itself, I too often find myself wrapping everything inside the foreach() loop in one big if() statement:

Now, imagine if there were a new construct formed by combining the above foreach() with PHP’s basic if() construct…

if (expr)
    statement

…to form a new construct, foreachif() with the following syntaxes:

foreachif (array_expression as $value; expr)
    statement
foreachif (array_expression as $key => $value; expr)
    statement

Where statement would be executed for each value in array_expression where expr‘s Boolean value equates to TRUE.

The expr part of the syntax would have to be evaluated last so that the logic of expr could involve the use of $value (and $key in the second form).

For example, the following code (which will echo only even number values from an array):

Could be written much more concisely using foreachif():

Of course some people would call this lazy, but to me it feels natural. In any case, don’t hold your breath, due to a clear lack of any real need for this feature it’s doubtful this will ever make into PHP 6. Perhaps PHP 10?