Incrementing Strings in PHP (and Perl)

Question

PHP allows you to increment strings. Why?

Let's jump ahead a bit. Take the following code:

$string = '9ZzZ';
echo ++$string; // 10AaA

From a purist point of view this may seem like nonsense, however, you can see there is clearly a pattern here. Each column is treated as a set, (numbers, uppercase letters, lowercase letters). Then each set behaves like its own numbering system.

The manual confirms this and states that they copied Perl:

PHP follows Perl's convention when dealing with arithmetic operations on character variables and not C's. For example, in PHP and Perl $a = 'Z'; $a++; turns $a into 'AA', while in C a = 'Z'; a++; turns a into '[' (ASCII value of 'Z' is 90, ASCII value of '[' is 91). Note that character variables can be incremented but not decremented and even so only plain ASCII alphabets and digits (a-z, A-Z and 0-9) are supported. Incrementing/decrementing other character variables has no effect, the original string is unchanged.

But, it doesn't actually explain why.

Perls manual states something very similar, but again goes in to no explanation as to why this extra magic was added.

The auto-increment operator has a little extra builtin magic to it. If you increment a variable that is numeric, or that has ever been used in a numeric context, you get a normal increment. If, however, the variable has been used in only string contexts since it was set, and has a value that is not the empty string and matches the pattern /^[a-zA-Z][0-9]\z/ , the increment is done as a string, preserving each character within its range, with carry

Similarly enigmatically:

The auto-decrement operator is not magical.

Why is increment so important but decrement isn't? And why would they do this at all?

It's logical in its own way, and I can see uses for it (though you could write something more obvious in its place). I can even see why they didn't to mill through the ASCII character set (since that might not be the character set your using) or through the character set defined in php.ini as that could significantly alter behaviour between systems. So why bother at all?

Answer 1

My understanding is that the feature was originally intended for generating sequences of filenames for scripts that need to produce variable numbers of output files. While you could use a simple counter for the purpose, this hasa few drawbacks (unpredictable name length causes bad sorting when files are listed alphabetically; letters are preferable to digits when many files are needed in order to keep generated names short), both of which can be solved by initialising your counter to (for example) 'aaaa'.

While other solutions are clearly possible and arenot even especially hard, perl's solution is remarkably concise.

Why php copied the idea, I'm not sure. It was never really intended for the type of application that benefits from this. It perhaps has something to do with the fact that perl was the dominant language for web scripting at the time.

Answer 2

There is a really useful utility in the unix world for splitting up large files named (unsuprisingly) split.

Output pieces of FILE to PREFIXaa, PREFIXab, ...; default size is 1000 lines, and default PREFIX is 'x'.

You can see that incrementing of strings there.

Perl is especially useful in situations where one wants to pull out the swiss army chainsaw of the unix utility world. I have in the past used this functionality for writing my own tools that needed to have similar functionality as that provided by split. And 26³ possible values in two characters is quite a bit more than 10³.

---

As to why ++ is magical while -- isn't? Its because it is easy to identify a consistent expectation for what ++ on a string does on boundary conditions while -- doesn't have easy expectations.

$foo = "zz";
$foo++;
print "$foo\n";

This is aaa. Very similar to how one would expect the following to behave:

$foo = 99;
$foo++;
print "$foo\n";

And while:

$foo = 0;
$foo--;
print "$foo\n";

gives you -1, would should:

$foo = "a";
$foo--;
print "$foo\n";

return? And with that, the designer throws up his arms and says "you know what, there's not a use case for it and I can't make it work consistently that isn't surprising to the programmer." and says instead "it isn't magical" and leaves it at that.