¿Por qué Perl foreach variable assignment modifica los valores en la matriz?

Question

OK, tengo el siguiente código:

use strict; 
my @ar = (1, 2, 3); 
foreach my $a (@ar) 
{ 
    $a = $a + 1; 
} 

print join ", ", @ar; 

y la salida?

2, 3, 4

¿Qué diablos? ¿Porque hace eso? ¿Esto siempre sucederá? ¿$ a no es realmente una variable local? ¿En qué piensan?

Answer 1

Perl tiene muchas de estas cosas de sintaxis casi extrañas que simplifican en gran medida las tareas comunes (como iterar sobre una lista y cambiar el contenido de alguna manera), pero te pueden hacer tropezar si no estás enterado.

$a tiene un alias al valor en la matriz - esto le permite modificar la matriz dentro del ciclo. Si no quiere hacer eso, no modifique $a.

Answer 2

$a en este caso es un alias para el elemento de matriz. Simplemente no tiene $a = en su código y no modificará la matriz. :-)

Si no recuerdo mal, map, grep, etc. todos tienen el mismo comportamiento de aliasing.

Answer 3

Ver perldoc perlsyn:

Si ningún elemento de lista es un valor-I, se puede modificar mediante la modificación de VAR dentro del bucle. Por el contrario, si algún elemento de LIST no es un valor l, cualquier intento de modificar ese elemento fallará. En otras palabras, la variable de índice de bucle foreach es un alias implícito para cada elemento de la lista sobre el que está pasando el bucle.

No hay nada raro o impar sobre un documentado función lengua aunque yo lo encuentro extraño que muchas personas se niegan comprobar la documentación al encontrarse con un comportamiento que no entienden.

Answer 4

la distinción importante aquí es que cuando se declara una variable my en la sección de inicialización de un bucle for, parece compartir algunas propiedades de los habitantes locales y lexicals (alguien con más conocimiento de los cuidados internos para aclarar?)

my @src = 1 .. 10; 

for my $x (@src) { 
    # $x is an alias to elements of @src 
} 

for (@src) { 
    my $x = $_; 
    # $_ is an alias but $x is not an alias 
} 

el efecto secundario interesante de esto es que en el primer caso, un sub{} definido dentro del bucle for es un cierre alrededor de cualquier elemento de la lista $x fue un alias a. Sabiendo esto, es posible (aunque un poco extraño) cerrar alrededor de un valor de alias que incluso podría ser un global, que no creo que sea posible con ningún otro constructo.

our @global = 1 .. 10; 
my @subs; 
for my $x (@global) { 
    push @subs, sub {++$x} 
} 

$subs[5](); # modifies the @global array 

Answer 5

Como han dicho otros, esto está documentado.

Mi entendimiento es que el comportamiento de aliasing @_, for, map y grep ofrece una velocidad y una optimización de la memoria, así como proporcionar interesantes posibilidades para la creatividad.Lo que sucede es esencialmente una invocación de referencia paso a paso del bloque del constructo. Esto ahorra tiempo y memoria al evitar la copia innecesaria de datos.

use strict; 
use warnings; 

use List::MoreUtils qw(apply); 

my @array = qw(cat dog horse kanagaroo); 

foo(@array); 


print join "\n", '', 'foo()', @array; 

my @mapped = map { s/oo/ee/g } @array; 

print join "\n", '', 'map-array', @array; 
print join "\n", '', 'map-mapped', @mapped; 

my @applied = apply { s/fee//g } @array; 

print join "\n", '', 'apply-array', @array; 
print join "\n", '', 'apply-applied', @applied; 


sub foo { 
    $_ .= 'foo' for @_; 
} 

Nota el uso de List::MoreUtilsapply función. Funciona como map pero hace una copia de la variable de tema, en lugar de usar una referencia. Si no te gusta escribir código como:

my @foo = map { my $f = $_; $f =~ s/foo/bar/ } @bar; 

te encantará apply, que la convierte en:

my @foo = apply { s/foo/bar/ } @bar; 

Algo a tener en cuenta: si pasa leer sólo los valores en una de estas construcciones que modifica sus valores de entrada, obtendrá un error "Modificación de un valor de solo lectura intentada".

perl -e '$_++ for "o"' 

Answer 6

Su $ a simplemente se usa como un alias para cada elemento de la lista mientras lo recorre. Se está utilizando en lugar de $ _. Puede decir que $ a no es una variable local porque está declarada fuera del bloque.

Es más obvio por qué la asignación de $ a cambia el contenido de la lista si lo considera un soporte para $ _ (que es lo que es). De hecho, $ _ no existe si defines tu propio iterador así.

foreach my $a (1..10) 
    print $_; # error 
} 

Si usted se pregunta cuál es el punto, consideremos el caso:

my @row = (1..10); 
my @col = (1..10); 

foreach (@row){ 
    print $_; 
    foreach(@col){ 
     print $_; 
    } 
} 

En este caso, es más fácil de leer para proporcionar un nombre amigable para $ _

foreach my $x (@row){ 
    print $x; 
    foreach my $y (@col){ 
     print $y; 
    } 
} 

Answer 7

Pruebe

foreach my $a (@_ = @ar) 

ahora mod ifying $ a no modifica @ar. funciona para mí en v5.20.2