¿Cómo puedo llamar un nombre de función definido en una cadena literal en perl?

Question

Si $name='name' ¿Por qué funciona $object_ref->$name pero no $object_ref->('name')?

Answer 1

$obj->$name  # Method call with no args 
$obj->name  # Method call with no args 
$obj->$name()  # Method call with no args 
$obj->name()  # Method call with no args 

$sub->('name') # Sub call (via ref) with one arg. 
sub('name')  # Sub call with one arg. 

Answer 2

La sintaxis para las llamadas a métodos es $object->method o $object->$method. Sin embargo, la sintaxis que proporcionó se puede usar para $sub_ref->(@param).

Answer 3

En Perl, el símbolo -> tiene dos significados. Si está seguido por una palabra clave $obj->name o un escalar $obj->$name, entonces -> significa método de llamada.

Si en lugar de la -> es seguida por una llave de apertura, entonces es una dereference, de acuerdo con la siguiente tabla:

$obj->(...) # dereference as code, which calls the subroutine 
$obj->[...] # dereference as array, which accesses an element 
$obj->{...} # dereference as hash, which accesses an element 

Cuando -> se dereferencing un valor, Perl comprobar para ver si el valor es ya sea el tipo indicado por el corsé, o si se puede forzar en ese tipo a través de la sobrecarga. Entonces, el ->( en su ejemplo significa que Perl intentará convertir $object_ref en una referencia de código, y probablemente fallará, arrojando un error.

Si el -> es una llamada a un método, a continuación, Perl hace algo como:

if (reftype $name eq 'CODE') { # if $name is code, ignore $object_ref's type 
    $name->($object_ref)  # call the coderef in $name, with $object_ref 
}        # followed by any other arguments 

elsif (my $code = $object_ref->can($name)) { # otherwise, try to look up the 
    # coderef for the method named $name in $object_ref's namespace and then 
    $code->($object_ref) # call it with the object and any other arguments 
} 
else {die "no method $name on $object_ref"} 

Sólo para hacer las cosas más claras:

sub foo {"foo(@_)"} 

my $foo = \&foo; 

say foo 'bar';  # 'foo(bar)' 
say $foo->('bar'); # 'foo(bar)' 
say 'bar'->$foo; # 'foo(bar)' 

y

sub Foo::bar {"Foo::bar(@_)"} 
my $obj = bless [] => 'Foo'; 

my $method = 'bar'; 

say $obj->bar(1);  # Foo::bar($obj, 1) 
say $obj->$method(1); # Foo::bar($obj, 1)