需要帮助来了解Perl 5如何解析引用相同变量的复合赋值语句

Question

I need to understand how this simple expression is being evaluated, since the result is not as I expected.

I'm quite new to Perl, but thought I had enough understanding to explain the outcome of this seemingly straightforward snippet. Clearly I'm missing something. I've used Deparse to see how Perl is processing the expression, and Deparse does not change the parentheses I already had in place.

$i = 12;
$i = (($i /= 2) + ($i = 100));
print $i;

According to my understanding, the result should be 106, assuming the expression is evaluated in the order indicated by parentheses, and in the manner it seems it should be. I would think: $i is first divided by 2, thereby assigning 6 to $i and resulting in a value of 6. Then 100 is assigned to $i, and 100 is the result of that second expression. 6 + 100 = 106, which I would think would finally be assigned to $i. Instead, it prints "200" .

In PHP, the same code indeed yields "106", leading me to believe that this has to do with some part of the expression being interpreted as a list, or something equally Perl-wonderful. Can't wait to find out what I got wrong.

Answer 1

By far and large, most languages don't define what happens when you both read and write the same value variable in a single expression. Perl is no exception. The expression you posted does not have a defined result.

This is documented in perlop:

modifying a variable twice in the same statement will lead to undefined behavior. Avoid statements like:

  $i = $i ++; print ++ $i + $i ++; 

---

What's happening is that $i /= 2 and $i = 100 both return $i —not the value of $i , but $i itself— so you eventually do $i + $i instead of 6 + 100 . You can't count on this behaviour. Furthermore, Perl happened to evaluate the addition's left operand before its right one —something else you can't count on— so $i is 100 come time to perform the addition.

If someone wants to fool around, here's a recreation of what currently happens when perl evaluates the OP's code:

use strict;
use warnings;
use feature qw( say );
use experimental qw( refaliasing declared_refs );

my $i = 12;

my @ST;  # Stack
{                                      \$ST[@ST] = \( $i                    ); }
{                                      \$ST[@ST] = \( 2                     ); }
{ \my ($lhs, $rhs) = \splice(@ST, -2); \$ST[@ST] = \( $lhs /= $rhs          ); }
{                                      \$ST[@ST] = \( 100                   ); }
{                                      \$ST[@ST] = \( $i                    ); }
{ \my ($rhs, $lhs) = \splice(@ST, -2); \$ST[@ST] = \( $lhs = $rhs           ); }
{ \my ($lhs, $rhs) = \splice(@ST, -2); \$ST[@ST] = \( my $sum = $lhs + $rhs ); }
{                                      \$ST[@ST] = \( $i                    ); }
{ \my ($rhs, $lhs) = \splice(@ST, -2); \$ST[@ST] = \( $lhs = $rhs           ); }

say $i;  # 200

If you use Devel::Peek's Dump , you'll notice that most of the variables above have the same address. They're what we call "aliases" in Perl jargon.

The following uses references instead (though no actual reference is created in reality):

use strict;
use warnings;
use feature qw( say );

my $i = 12;

my @ST;  # Stack
{                                         push @ST, \( $i                          ); }
{                                         push @ST, \( 2                           ); }
{ my ($lhs_p, $rhs_p) = splice(@ST, -2);  push @ST, \( $$lhs_p /= $$rhs_p          ); }
{                                         push @ST, \( 100                         ); }
{                                         push @ST, \( $i                          ); }
{ my ($rhs_p, $lhs_p) = splice(@ST, -2);  push @ST, \( $$lhs_p = $$rhs_p           ); }
{ my ($lhs_p, $rhs_p) = splice(@ST, -2);  push @ST, \( my $sum = $$lhs_p + $$rhs_p ); }
{                                         push @ST, \( $i                          ); }
{ my ($rhs_p, $lhs_p) = splice(@ST, -2);  push @ST, \( $$lhs_p = $$rhs_p           ); }

say $i;  # 200

Answer 2

The perl-wonderful thing is that arguments (whether lvalues or rvalues) are always passed to perl operators as references to the actual variables, not as copies of their values. This is different from most other languages, and is keeping with the fact that perl is a pass-by-reference language (like Fortran).

Your example is an very unfortunate red-herring , since it assumes that the operands of + are evaluated left-to-right, which (while absolutely true for the only usable perl5 implementation) is afaik not guaranteed by any docs.

Let's try it with a comma operator, which really is [1] guaranteed to evaluate its arguments left-to-right:

perl -le 'print @y = ($x = 1, $x = 2, $x = 3)'

That should print 123 right?

No, because perl will first evaluate all the assignments from left to right, each of which returning $x , not a copy of it, and then will proceed 3 times to "resolve" it by derefencing it, getting each time in the last value that was stored in it. Thence 333 .

[1]: from perlop(1) : "Comma operator ... In list context, it's just the list argument separator, and inserts both its arguments into the list. These arguments are also evaluated from left to right".

[the extra assignment above in order to avoid a discussion about how and why in perl an argument list is actually a list, built with the comma-operator, not something special as in C]

Answer 3

perldoc perlop:

Note that just as in C, Perl doesn't define when the variable is incremented or decremented. You just know it will be done sometime before or after the value is returned. This also means that modifying a variable twice in the same statement will lead to undefined behavior. Avoid statements like:

  $i = $i ++; print ++ $i + $i ++;