perl | Referencias a una subrutina

Requisito previo: referencias de Perl
 

Declaración de referencias a una subrutina

En Perl, una referencia es, exactamente como sugiere su nombre, una referencia o puntero a otro objeto. Las referencias en realidad brindan todo tipo de habilidades y facilidades que de otro modo no estarían disponibles y se pueden usar para crear estructuras sofisticadas como tablas de despacho , procedimientos de orden superior , cierres , etc. Para los programadores de C que usan Perl por primera vez, una referencia es exactamente como un puntero, excepto que dentro de Perl es más fácil de usar y, más concretamente, más práctico. Hay dos tipos de referencias: simbólicas y duras . 
Simbólicoreferencia le permite utilizar el valor de otra variable como referencia a una variable por nombre. Por ejemplo, si la variable $val contiene la string «Texto», la referencia simbólica a $val se refiere a la variable $Texto. 
Una referencia dura es un término para los datos reales que están contenidos en una estructura de datos. Sin embargo, la forma de la estructura de datos a la que apunta es en gran medida irrelevante. Aunque una referencia dura puede referirse a un solo escalar, también puede referirse a una array de escalares, un hash o una subrutina.

$val = "Text";
$val_ref = \$val;

# For other variables
$array = \@ARGV;
$hash = \%ENV;

# For reference to subroutine
sub val { print "val" };
$valsub = \&val;

Llamar a una referencia de subrutina

Llamar a una referencia de subrutina también se conoce como desreferenciación . Es el acto de extraer información de las estructuras. Cuando elimina la referencia de una referencia escalar, de hecho se está refiriendo a la estructura de datos original. El enfoque más directo para desreferenciar una referencia es anteponer el carácter de tipo de datos relevante ( $ para escalares, @ para arrays, % para hashes y & para subrutinas) que espera antes de la variable escalar que contiene la referencia.

$val_ref = \$val;       # Create reference to scalar
$array = \@ARGV;        # Create reference to array
$hash = \%ENV;          # Create reference to hash
$valsub = \&            # Create reference to subroutine

# Dereferencing
$$val_ref;
$$array[0, 1, ....];
$$hash{'...'};
&$valsub;

Nota: El acto de desreferenciar información debe ser explícito. Perl no admite desreferenciación implícita en ninguna estructura.

Las subrutinas pueden ser tanto con nombre como anónimas . Perl ofrece la posibilidad de declarar referencias a los tipos de subrutinas y de desreferenciarlas. 
Ejemplo 1: 

#!/usr/bin/perl
 
# Perl program to demonstrate
# reference to subroutines
 
# Creating a named subroutine
sub name
{
    return "GeeksforGeeks";
}
 
# Create callable reference
# to named subroutine
$rs1 = \&name;    
print("Reference to named subroutine: ", $rs1);
print("\nAfter dereferencing, value : ", &$rs1);
 
# Create a reference to an
# anonymous subroutine
$rs2 = sub{
               return "GFG";
          };
print("\n");
print("\nReference to anonymous subroutine: ", $rs2);
print("\nAfter dereferencing, value : ", &$rs2);

Reference to named subroutine: CODE(0x981750)
After dereferencing, value : GeeksforGeeks

Reference to anonymous subroutine: CODE(0x981870)
After dereferencing, value : GFG

El uso de la operación infix se muestra en el siguiente ejemplo. La operación infix proporciona una forma mejor y más fácil de extraer información de las estructuras complejas o anidadas.
Ejemplo 2: 

#!/usr/bin/perl
 
# Perl program to demonstrate
# reference to subroutines
 
$rs = \&func1;
 
# Prints "GeeksforGeeks"
$rs->("Geeks")->("for")->("Geeks");    
 
sub func1
{
    my $val = shift;
    print "$val";
    return \&func2;
}
 
sub func2
{
    my $val = shift;
    print "$val";
    return \&func3;
}
 
sub func3
{
    my $val = shift;
    print "$val\n";
}

GeeksforGeeks

devoluciones de llamada

Las devoluciones de llamadas son uno de los elementos importantes que se deben recordar al desarrollar interfaces Perl Tk . Devuelve una pieza de código de otra parte del script cuando alcanzamos un cierto punto de condición o realizamos una determinada acción. 
Las devoluciones de llamada son algo así como una ejecución retrasada de código, que se desenstring por un evento en lugar de ejecutar las cosas de forma lineal. Para tal funcionalidad de código basada en eventos, a menudo hacemos uso de referencias de subrutinas para llamar a tales piezas de código cuando sea necesario.
Ejemplo: 

# Perl program to demonstrate
# the use of callbacks
sub alt {
            print "$a $b\n";
            $arr{$a} cmp $arr{$b};
        }
 
%arr = ("Marcelo", "Lewis",
        "Rodrygo", "Peter",
        "Sandro", "James");
 
# @names = sort alt (keys(%arr));
@names = calc ("Alternate", keys(%arr));
foreach $person (@names)
{
    print "$person teams up with $arr{$person}\n";
}
 
# Example code to show
# what really goes on inside sort.
sub calc
{
    my ($subn, @final) = @_;
    for ($k = 0; $k < $final; $k++)
    {
        $count = 0;
        for ($j = 0; $j < $final - $k; $j++)
        {
            $a = $final[$j];
            $b = $final[$j + 1];
            if (&{$subn}() > 0 )
            {
                $final[$j] = $b;
                $final[$j + 1] = $a;
                $count++;
            }
        }
        last unless ($count);
    }
    return @final
}

Sandro teams up with James
Rodrygo teams up with Peter
Marcelo teams up with Lewis

El ejemplo anterior muestra la clasificación de una lista de claves hash según la cantidad de caracteres (longitud) en el valor contenido en el hash mediante una función de devolución de llamada calc .
 

Arrays y hashes de referencias

Más allá de las restricciones normales de arrays y hashes, también puede crear estructuras complejas formadas por combinaciones de los dos. Estas son estructuras anidadas o complejas y se pueden usar para modelar datos complejos en un formato fácil de usar. Lo que realmente sucede con una estructura anidada es que Perl almacena el tipo de datos anidados como una referencia a una variable anónima. Por ejemplo, en una array bidimensional, la array principal es una lista de referencias y las sub-arrays son arrays anónimas a las que apuntan estas referencias. Esto significa que una «array de arrays» en realidad significa una array de referencias a arrays. Lo mismo es cierto para todas las estructuras anidadas; y, aunque parece complejo, proporciona un método convenientemente poderoso para crear estructuras anidadas complejas.
Ejemplo 1: 

w
# Perl program to demonstrate
# array of references
 
# Declaring a reference to a nested array
$array = [[1, 2, 3, 4, 5],
          ['Geeks', 'for', 'Geeks'],
          [6, 7, 8, 9]];
 
# Access element using index
# Dereferencing performed
print("$$array[1][2]");    
 
# Access element using infix method
print("\n$array->[1][1]");
print("\n$array->[1]->[0]");
 
# Printing complete nested array
print("\nElements in the array are :");
print("\n");
for(my $i = 0; $i < scalar(@{$array}); $i++)
{
    for(my $j = 0; 
           $j < scalar(@{$array->[$i]}); $j++)
    {
        print($$array[$i][$j]);
        print(" ");
    }
    print("\n");
}

Geeks
for
Geeks
Elements in the array are :
1 2 3 4 5 
Geeks for Geeks 
6 7 8 9

Ejemplo 2:

#!/usr/bin/perl
 
# Perl program to demonstrate
# array of references
use strict;
use warnings;
 
my %friends = ( 1 => 'John',     4 => 'Sandro',
                2 => 'Rodrygo', 5 => 'Peter',
                3 => 'Marcelo', 6 => 'Luis' );
 
# Declaring a Reference to the hash
my $hash_ref = \%friends;
 
# Access element from hash using key value
print("$$hash_ref{1}\n");     # prints John
 
# Access element using infix operation
print("$hash_ref->{3}\n");
 
# Print all elements of the hash
# with their keys
print ("The hash stored is :\n");
 
for (keys %$hash_ref)
{
    print("$_ = $hash_ref->{$_}\n");
}

John
Marcelo
The hash stored is :
4 = Sandro
1 = John
2 = Rodrygo
5 = Peter
3 = Marcelo
6 = Luis