We all optimize. Sometimes we do so needlessly, sometimes speed is of utter importance.
I think most of us would agree that readability, maintainability and speed of programming are often way more important than execution speed. But, what if optimizations actually make things more readable, what if optimization increase maintainability, and even let you code faster?
There are some simple tricks that have no down-side to them, and we often recommend them. There are simple optimizations like using $foo instead of "$foo", using $foo == 0 instead of $foo eq 0 (assuming $foo is numeric), etcetera. Then, there are the "doesn't really matter" optimizations, like using length $foo in boolean context instead of $foo ne '' (and of course, length with an implicit $_ is nicer compared to $_ ne ''). And of course, we have more complicated optimizations like the Schwartzian transform (map sort map).
Considering the alternatives, these optimizations make code more readable, maintainable and improve programming speed (although the more complicated ones might be a bit overwhelming the first time).
Can we list these tricks? What are your favourite idiomatic optimiziations?
For the overview, here's a summary of what I already mentioned:
- $foo vs "$foo" (don't interpolate when not needed)
- $foo eq 0 vs $foo == 0 (use the right scalar context)
- length vs $_ ne '' (scalars already "know" their length)
- scharzian transform vs disassembling and re-assembling data