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
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().