Perl subrutinas (funciones)

Una subrutina Perl (subroutine) es una función definida por el usuario.

Una subrutina Perl es un fragmento de código separado que realiza una tarea específica; puede reducir la repetición de código y hacer que el programa sea más legible.

Una subrutina Perl es un bloque de código que encapsula una serie de operaciones o cálculos; puede ser invocada repetidamente para reutilizarla en un programa.

Las subrutinas Perl ayudan a modularizar los programas, haciendo que el código sea más fácil de entender, mantener y reutilizar.

Las subrutinas Perl pueden aparecer en cualquier lugar del programa; el formato de sintaxis es el siguiente:

sub subroutine{
   statements;
}

Formato de sintaxis para llamar a una subrutina:

subroutine( 参数列表 );

En versiones anteriores a Perl 5.0, el método para llamar a una subrutina es el siguiente:

&subroutine( 参数列表 );

En las versiones nuevas, aunque este método de llamada también es compatible, no se recomienda su uso.

A continuación veamos un ejemplo simple:

Ejemplo

#!/usr/bin/perl # Definición de la función sub Hello{ print "Hello, World!\n"; } # Llamada a la función Hello();

Al ejecutar el programa anterior, el resultado es:

Hello, World!

Pasar parámetros a una subrutina

Las subrutinas Perl, como en otros lenguajes de programación, pueden aceptar múltiples parámetros. Los parámetros de la subrutina se indican mediante el array especial @_.

Por lo tanto, el primer parámetro de la subrutina es $_

Ya sea que los parámetros sean de tipo escalar o de tipo array, cuando el usuario los pasa a la subrutina, Perl los invoca por referencia de forma predeterminada.

Ejemplo

#!/usr/bin/perl # Definir la función para calcular el promedio sub Average{ # Obtener todos los parámetros pasados $n = scalar(@_); $sum = 0; foreach $item (@_){ $sum += $item; } $average = $sum /$n; print 'Los parámetros pasados son : ',"@_\n"; # Imprimir todo el array print "El primer parámetro es : $_

Al ejecutar el programa anterior, el resultado es:

传入的参数为 : 10 20 30
第一个参数值为 : 10
传入参数的平均值为 : 20

Los usuarios pueden modificar el valor de los parámetros reales correspondientes cambiando los valores en el array @_.

Pasar una lista a una subrutina

Dado que la variable @_ es un array, puede pasar una lista a la subrutina.

Pero si necesitamos pasar parámetros escalares y de array, debemos colocar la lista como último parámetro, como se muestra a continuación:

Ejemplo

#!/usr/bin/perl # Definir la función sub PrintList{ my @list = @_; print "La lista es : @list\n"; } $a = 10; @b = (1, 2, 3, 4); # Parámetro de lista PrintList($a, @b);

El programa anterior combina el escalar y el array, el resultado es:

列表为 : 10 1 2 3 4

Podemos pasar múltiples arrays y hashes a la subrutina, pero al pasar múltiples arrays y hashes, se pierde la identidad independiente. Por lo tanto, necesitamos usar referencias (que se presentarán en el próximo capítulo) para pasarlos.

Pasar un hash a una subrutina

Cuando se pasa un hash a una subrutina, se copia en @_ y el hash se expande como una lista de combinaciones clave/valor.

Ejemplo

#!/usr/bin/perl # Definición del método sub PrintHash{ my (%hash) = @_; foreach my $key ( keys %hash ){ my $value = $hash{$key}; print "$key : $value\n"; } } %hash = ('name' => 'ejemplo', 'age' => 3); # Pasar el hash PrintHash(%hash);

Al ejecutar el programa anterior, el resultado es:

age : 3
name : ejemplo

Valor de retorno de una subrutina

Las subrutinas pueden usar la declaración return para devolver el valor de la función, como en otros lenguajes de programación.

Si no se usa return, la última declaración de la subrutina se tomará como valor de retorno.

Ejemplo

#!/usr/bin/perl # Definición del método sub add_a_b{ # Sin usar return $_[0]+$_[1]; # Usando return # return $_[0]+$_[1]; } print add_a_b(1, 2)

Al ejecutar el programa anterior, el resultado es:

3

En Perl, se pueden usar referencias para devolver múltiples arrays y hashes. Una referencia es un valor escalar que apunta a una estructura de datos (como un array o un hash). A través de las referencias, podemos empaquetar múltiples arrays y hashes en un solo valor de retorno para pasarlo al programa llamante. Esto mantiene la independencia e integridad de las estructuras de datos.

Ejemplo

sub return_multiple_data {
    my @array1 = (1, 2, 3);
    my @array2 = ('a', 'b', 'c');
    my %hash1 = ('key1' => 'value1', 'key2' => 'value2');
    my %hash2 = ('foo' => 'bar', 'baz' => 'qux');
   
    return (\@array1, \@array2, \%hash1, \%hash2);
}

my ($array_ref1, $array_ref2, $hash_ref1, $hash_ref2) = return_multiple_data();

# Acceder a los datos devueltos usando referencias
print "Array 1: @{$array_ref1}\n";
print "Array 2: @{$array_ref2}\n";
print "Hash 1: " . join(", ", %{$hash_ref1}) . "\n";
print "Hash 2: " . join(", ", %{$hash_ref2}) . "\n";

En el código anterior, la subrutina return_multiple_data devuelve referencias a cuatro estructuras de datos.

En el programa llamante, accedemos a los arrays y hashes devueltos mediante la desreferencia de estas referencias, manteniendo así su independencia e integridad.

El resultado es:

Array 1: 1 2 3
Array 2: a b c
Hash 1: key1, value1, key2, value2
Hash 2: foo, bar, baz, qux

Variables privadas de una subrutina

De forma predeterminada, todas las variables en Perl son globales, lo que significa que pueden ser utilizadas en cualquier lugar del programa.

Si necesitamos establecer variables privadas, podemos usarmyel operador para establecerlas.

myEl operador se usa para crear variables de ámbito léxico; mediantemylas variables así creadas viven desde donde se declaran hasta el final del ámbito contenedor.

El ámbito contenedor puede ser una región entre llaves, puede ser un archivo, o también puede ser una cadena if, while, for, foreach, eval.

El siguiente ejemplo demuestra cómo declarar una o más variables privadas:

sub somefunc {
   my $variable; # $variable 在方法 somefunc() 外不可见
   my ($another, @an_array, %a_hash); #  同时声明多个变量
}

Ejemplo

#!/usr/bin/perl # Variable global $string = "Hello, World!"; # Definición de la función sub PrintHello{ # Variable privada de la función PrintHello my $string; $string = "Hello, Ejemplo!"; print "Cadena dentro de la función:$string\n"; } # Llamar a la función PrintHello(); print "Cadena fuera de la función:$string\n";

Al ejecutar el programa anterior, el resultado es:

函数内字符串:Hello, Ejemplo!
函数外字符串:Hello, World!

Asignación temporal de una variable

Podemos usar local para proporcionar un valor temporal a una variable global, y al salir del ámbito se restaura el valor original.

Las variables definidas con local no existen en el programa principal, pero existen en la subrutina y en las subrutinas llamadas por ella. Al definirlas se les puede asignar un valor, por ejemplo:

Ejemplo

#!/usr/bin/perl # Variable global $string = "Hello, World!"; sub PrintEjemplo{ # Variable privada de la función PrintHello local $string; $string = "Hello, Ejemplo!"; # Subrutina llamada por la subrutina PrintMe(); print "Valor de la cadena dentro de la función PrintEjemplo:$string\n"; } sub PrintMe{ print "Valor de la cadena dentro de la función PrintMe:$string\n"; } sub PrintHello{ print "Valor de la cadena dentro de la función PrintHello:$string\n"; } # Llamada a la función PrintEjemplo(); PrintHello(); print "Valor de la cadena fuera de la función:$string\n";

Al ejecutar el programa anterior, el resultado es:

PrintMe 函数内字符串值:Hello, Ejemplo!
PrintEjemplo 函数内字符串值:Hello, Ejemplo!
PrintHello 函数内字符串值:Hello, World!
函数外部字符串值:Hello, World!

Variables estáticas

El operador state funciona de manera similar al modificador static de C; la palabra clave state hace que las variables locales sean persistentes.

state también es una variable léxica, por lo que solo es válida en el ámbito léxico donde se define. Por ejemplo:

Ejemplo

#!/usr/bin/perl use feature 'state'; sub PrintCount{ state $count = 0; # Inicializar la variable print "El valor de counter es:$count\n"; $count++; } for (1..5){ PrintCount(); }

Al ejecutar el programa anterior, el resultado es:

counter 值为:0
counter 值为:1
counter 值为:2
counter 值为:3
counter 值为:4

Nota 1: state solo puede crear variables cuyo ámbito de cierre sea el interior de una subrutina.

Nota 2: state se introdujo a partir de Perl 5.9.4, por lo que antes de usarlo se debe anteponer use.

Nota 3: state puede declarar escalares, arrays y hashes. Sin embargo, al declarar arrays y hashes, no se pueden inicializar (al menos Perl 5.14 no lo admite).


Contexto de llamada de una subrutina

Durante la llamada a una subrutina, se devuelven diferentes tipos de valores según el contexto. Por ejemplo, la subrutina localtime() devuelve una cadena en contexto escalar y una lista en contexto de lista:

Ejemplo

#!/usr/bin/perl # Contexto escalar my $datestring = localtime( time ); print $datestring; print "\n"; # Contexto de lista # El valor de $year es un recuento que comienza en 1900 como año inicial ($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time); printf("%d-%d-%d %d:%d:%d",$year+1900,$mon+1,$mday,$hour,$min,$sec); print "\n";

Al ejecutar el programa anterior, el resultado es:

Sun Jun 12 15:58:09 2016
2106-6-12 15:58:9
Otras extensiones