I try not to get overly technical in this space, but when I get a chance to implement one of my very favorite programming techniques, I have a hard time keeping it to myself. I want to tell you about recursion. Per wikipedia:
A common method of simplification is to divide a problem into subproblems of the same type […] where problems are solved by solving smaller and smaller instances.
Here’s the example. Earlier this week I was dealing with a problem where I needed to turn the english words “true” and “false” into the boolean values true and false. This would be easy enough to do if it were simply one instance of the words:
That’s easy enough. But what if the words were in an array?
A little more work, but still not too bad. But what if I didn’t know ahead of time if the words were in an array? What if I didn’t know how deeply nested they were into the array? The answer is recursion.
Notice anything weird there? Notice that I have the function calling itself. In case you don’t know, that’s pretty weird. That’s a bit like having your phone call itself. The end result is that it’s going to keep breaking down deeper and deeper into the original variable, until all the true/false words are boolean.
Dear lord, who cares?
It’s a fair question. The real point here is that there was a simpler way to do this that probably could have worked. I could have done some combination of the first two techniques, crossed my fingers that I’d never encounter a deeper array, and moved on the something else. Why make something bulletproof? Why make something overkill? Because I can. And because the next time I need it, when maybe it’s not overkill but it’s the only way to get by, it will be easy.
Update: Since posting this, LexBlog’s own Angelo Carosio pointed out to me that I could also have used php’s excellent array_walk_recursive().