perl | Alcance de una subrutina

Las subrutinas en Perl sonunidades de código reutilizables . Es un concepto dinámico. Funciones y subrutinas son los dos términos que se pueden usar indistintamente. Si desea ser estricto con la semántica, las pequeñas piezas de bloques de código con nombre que aceptan argumentos y devuelven valores se denominan subrutinas. Las subrutinas integradas en Perl generalmente se denominan funciones de Perl porque brindan funcionalidad adicional. Una subrutina creada como parte de una definición de clase se llama método .
Las subrutinas se pueden llamar desde casi cualquier lugar y devolver el control al punto de la llamada cuando terminan de ejecutarse. Se pueden llamar con cero o más argumentos y pueden devolver cero o más resultados ..

Al igual que las variables, las subrutinas pueden declararse (sin definir el trabajo que realizan) o declararse y definirse. Para simplemente declarar una subrutina, usamos una de las siguientes formas:

Sintaxis:
sub SUB_NOMBRE
sub SUB_NOMBRE PROTOTIPO
sub SUB_NOMBRE ATRIBUTOS
sub SUB_NOMBRE ATRIBUTOS DE PROTOTIPO

donde SUB_NAME es el nombre de la subrutina que se está creando, PROTOTYPE es el prototipo de los argumentos que la subrutina debe esperar cuando se la llama y ATTRIBUTES es una lista de atributos que exhibe la subrutina. Los argumentos PROTOTYPE y ATTRIBUTES son opcionales.

NOTA: Las subrutinas se pueden nombrar o pueden ser anónimas. Perl también permite crear subrutinas anónimas, es decir, subrutinas sin nombre. Esto se puede hacer omitiendo el componente NOMBRE . Sin embargo, no puede crear una subrutina anónima sin una definición (Perl no tiene forma de adjuntar la definición más adelante sin conocer el nombre de la subrutina). También deberá asignar la subrutina a una variable escalar para llamarla más tarde.

Ejemplo:

# Perl program to demonstrate
# simple subroutine
  
sub message    # Declared subroutine 
{ 
    print "Hello!\n";   # Body of subroutine
}
  
$message = message;    # Calling subroutine

Hello!

La idea de alcance se refiere al área en la que se define una variable o subrutina y otras partes del programa pueden utilizarla y acceder a ella. Las subrutinas de Perl admiten principalmente dos tipos de ámbitos: léxico y global .

Al igual que las variables, las subrutinas también viven en un ámbito particular, ya sea un ámbito léxico o global .

Ámbito global
 
Las subrutinas y las variables tienen un ámbito global si se pueden usar en cualquier parte del programa completo, a menos que se anulen por una subrutina y una variable de ámbito léxico, respectivamente, del mismo nombre. Las variables globales están disponibles para todas las diferentes funciones y bibliotecas del programa, aunque es necesario cargarlas antes de usarlas para cada función por separado.

Sintaxis:
sub Dummy ($param1, $param2) { . . . }

Estas subrutinas solo pueden acceder a variables de ámbito global. La mayoría de las funciones integradas en Perl tienen un alcance global.

Ejemplo

#!/usr/bin/perl
  
# Subroutine definition
sub Max 
{
      
    # get total number of arguments passed.
    $n = scalar(@_);     # local scoped 
    $max = 0;             # local scoped
      
    foreach $item (@_) 
    {
        if ($item > $max)
        {
            $max = $item;
        }
    }
    print "Max from the given numbers : $max\n";
}
  
# Subroutine call
Max(10, 20, 30, 40, 50, 100); # called globally
  
$user_input = "GeeksforGeeks";
if (length($user_input) >= 7)
{
    Max(45, 56, 78, 76, 26, 90);     # called locally
}

Max from the given numbers : 100
Max from the given numbers : 90

Ámbito léxico
 
Las subrutinas también pueden ser léxicas al igual que las variables. Las subrutinas léxicas son aquellas que se declaran y definen dentro de una función o dentro de una condición If-Else y solo pueden operar dentro de ese ámbito. Fuera del alcance no son reconocidos por otras partes del programa. Las subrutinas léxicas pueden acceder tanto a variables globales como locales (definidas dentro de su alcance). Las subrutinas léxicas se llaman como una subrutina normal:

Sintaxis:
if $condición1
{
my sub sub1 ($param1, $param2)
{
. . .
}

sub1($arg1, $arg2); # Llamando dentro del ámbito
}

# sub1($arg3, $arg4); # error – Llamando fuera del alcance

La primera llamada a sub1 está bien, pero la segunda sería un error en tiempo de compilación porque se ha llamado a sub1 fuera de su ámbito de definición.

Ejemplo:

#!/usr/bin/perl
  
$user_input = "Geeks";
  
if (length($user_input) >= 7) 
{
    # Subroutine definition local to IF block
    sub Max 
    {
          
        # get total number of arguments passed.
        $n = scalar(@_);     # local scoped 
        $max = 0;             # local scoped
          
        foreach $item (@_) 
        {
            if ($item > $max) 
            {
                $max = $item;
            }
        }
        print "Max from the given numbers : $max\n";
    }
  
    Max(45, 56, 78, 76, 26, 90);     #called locally
}
else 
{
  
    # Subroutine definition local to ELSE block
    sub Max 
    {
          
        # get total number of arguments passed.
        $n = scalar(@_);     # local scoped 
        $max = 0;             # local scoped
          
        foreach $item (@_) 
        {
            if ($item > $max) 
            {
                $max = $item;
            }
        }
        print "Max from the given numbers : $max\n";
    }
  
    Max(4, 6, 17, 37, 6, 9);     #called locally
}

Max from the given numbers : 37

myy localen Perl las subrutinas se usan para limitar el alcance de una variable o una subrutina en el programa. Limitar el alcance significa limitar el área desde la cual se puede acceder a la variable respectiva.
 
Efectos demy
 
Todas las variables en Perl son variables globales predeterminadas , lo que significa que el compilador puede acceder a ellas desde cualquier parte del programa. Pero las variables privadas llamadas variables léxicas también se pueden crear usando myoperator.
La mypalabra clave declara una variable dentro del alcance del bloque actual. Mientras dure el bloque, la nueva variable prevalecerá sobre cualquier variable del ámbito anterior. Cuando finaliza el bloque, la variable queda fuera del alcance.

Ejemplo

#!/usr/bin/perl
  
my $string = "GeeksforGeeks";
print "$string\n";
myfunction();   # function call
print "$string\n";
  
# Subroutine 1 definition
sub myfunction 
{
      
    # Private variable for function
    my $string = "GFG";
    print "Inside myfunction $string\n";
    mysub();
}
  
# Subroutine 2 definition
sub mysub
{
    print "Inside mysub $string\n";
}

GeeksforGeeks
Inside myfunction GFG
Inside mysub GeeksforGeeks
GeeksforGeeks

En el momento en que termina el bloque, la variable desaparece efectivamente de la vista. No podemos acceder a una variable declarada con mydesde fuera del bloque dentro del cual está definida.
También significa que las variables declaradas con mydentro de un módulo no son accesibles fuera de ese módulo (ya que el módulo es un solo bloque), incluso cuando se las llama explícitamente usando $MyModule::string.

 
Efectos delocal
 
La localvariable es realmente una variable de ámbito dinámico. Crea efectivamente una copia de una variable global dentro del alcance actual. Funciona como una variable de ámbito léxico; sus efectos desaparecen cuando la variable sale del alcance actual, y la variable vuelve a su valor original en lugar de simplemente desaparecer.

Ejemplo:

#!/usr/bin/perl
  
$string = "GeeksforGeeks";
print "$string\n";
myfunction();
print "$string\n";
  
# Subroutine 1 definition
sub myfunction 
{
      
    # Private variable for function
    local $string = "GFG";
    print "Inside myfunction $string\n";
    mysub();
}
  
# Subroutine 2 definition
sub mysub
{
    print "Inside mysub $string\n";
}

GeeksforGeeks
Inside myfunction GFG
Inside mysub GFG
GeeksforGeeks

Nota: El valor de una variable modificada usando locales consistente para todas las funciones llamadas desde el bloque en el que se ha localizado la variable.

Entonces, localsimplemente suspende la variable global y crea un alcance temporal para la variable global mientras mydefine una nueva variable léxica dentro del alcance definido y esta variable se destruye una vez que salimos del alcance de su definición.
 
Effects ofour
 
Perl admite otra declaración de alcance que nos permite crear una variable global selectiva, utilizando la palabra clave our. La ourdeclaración es una invención relativamente nueva y le permite declarar una variable como global y potencialmente utilizable por cualquier otra subrutina definida en su script.
Ambos myy ourson ejemplos de variables de ámbito léxico. La única diferencia está en el nivel en el que se aplica el ámbito léxico.

Ejemplo:

#!/usr/bin/perl
  
our $string = "GeeksforGeeks";
print "$string\n";
myfunction();
print "$string\n";
  
# Subroutine definition
sub myfunction 
{
      
    # Private variable for function
    our $string = "GFG";
    print "Inside myfunction $string\n";
}

GeeksforGeeks
Inside myfunction GFG
GFG

El uso ourdentro de una función, o de hecho cualquier forma de anidamiento dentro de cualquier bloque, en la misma variable no tiene ningún efecto. Siempre se refiere a la misma variable global. El uso de oursobre una variable declarada con myno tendrá ningún efecto.