In the first step, an element of @a is being interpolated into the string. That element's index is given as %d (in your first example), which is a valid expression that produces 0, since it's an empty hash in scalar context. In the second example, the expression given as the index is invalid and produces a syntax error. In the third, the \ makes the $ literal, so no interpolation is attempted.

Some people find it easier to think of strings as being compiled rather than interpolated at runtime. So you can think of your first two examples as compiling to concatenated literals and variables:

perl -wle 'my @a=1..9; printf $a[%d] . "\n", 4'

perl -wle 'my @a=1..9; printf $a[%2d] . "\n", 4'
[download]

Seeing "$a[%d]", the interpolation rules require that $a[...] interpolates an element of @a in the string. That means that the part inside [...] is interpreted as Perl code, not as part of the string. Thus %d is evaluated as an undeclared hash in scalar context (it can because you are running without strict), which is 0. The result is the same as "$a[0]", which is "1".

For similar reasons, "$a[%2d]" is a syntax error.

In "\$a[%d]" the dollar sigil is escaped, so the part in [...] is a plain string and the result is $a[%d].

If something is weird about the behavior, it's string interpolation itself. Mainly your example serves as an object lesson on the importance of strictures.

Anno

My interpretation is that printf makes variable substitution before format the output. This means that in:

printf"$a[%d]\n", 4
[download]

$a[%d] is interpreted before %d, then warns. The same happens in the second example

In the last one:

perl -wle 'my @a=1..9; printf"\$a[%d]\n", 4'
[download]

Because the $ is scaped, there is no variable substitution and the format process behaves normally

citromatik

My interpretation is that printf makes variable substitution before format the output. This means that in:

Nope, it's not printf: it just takes a qq|| string, which in turn does variable interpolation as usual.

"foo $a[%d] bar"
is converted to
"foo " . $a[%d] . " bar"
when the double-quoted string is compiled. This is called "interpolation".

printf("$a[%d]\n", 4);
is therefore the same thing as
printf($a[%d] . "\n", 4);
which is definitely not what you want.

Single-quotes avoid interpolation, and so does escaping the characters ($ and @) that would cause interpolation
printf('$a[%d]'."\n", 4);
printf("\$a[%d]\n", 4);

"print behavior" is a very recent discussion on behavior of "print" ( not printf ). I thought it worth these two threads linked together.

To do otherwise would be inconsistent.

To do otherwise, but only in the specific case of sprintf format strings (or other contexts where $, @, or % have special meanings), is to enter a morass of special-case rules which will surely lead to madness.