Latest web development tutorials

subrutina Perl (función)

Perl subrutina que es la función definida por el usuario.

Perl subrutina que es un pedazo de código para realizar la separación de tareas especiales, que puede hacer para reducir la duplicación de código y que el programa sea fácil de leer.

subrutina Perl puede aparecer en cualquier parte del programa, la sintaxis es la siguiente: 

sub subroutine{
   statements;
}

sintaxis de llamada de subprogramas: 

subroutine( 参数列表 );

Perl 5.0 en la siguiente llamada a subrutina versiones de la siguiente manera: 

&subroutine( 参数列表 );

En la nueva versión, a pesar de que es compatible con el método de llamada, pero no es recomendable.

A continuación nos fijamos en que es un ejemplo sencillo: 

#!/usr/bin/perl

# 函数定义
sub Hello{
   print "Hello, World!\n";
}

# 函数调用
Hello();

El programa anterior, la salida es: 

Hello, World!

Pasar parámetros a subrutinas

Perl subrutina puede aceptar varios parámetros y otra programación, utilice la matriz @_ parámetros especiales subrutina indicada.

Por lo tanto, el primer argumento es subrutina $ _ [0], el segundo argumento es $ _ [1], y así sucesivamente.

Si los parámetros son de tipo escalar o matriz, el usuario del parámetro pasado a la subrutina, Perl predeterminado por la referencia de llamada ellos. 

#!/usr/bin/perl

# 定义求平均值函数
sub Average{
   # 获取所有传入的参数
   $n = scalar(@_);
   $sum = 0;

   foreach $item (@_){
      $sum += $item;
   }
   $average = $sum / $n;
   print '传入的参数为 : ',"@_\n";           # 打印整个数组
   print "第一个参数值为 : $_[0]\n";         # 打印第一个参数
   print "传入参数的平均值为 : $average\n";  # 打印平均值
}

# 调用函数
Average(10, 20, 30);

El programa anterior, la salida es: 

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

El usuario puede cambiar el valor de los parámetros reales correspondientes cambiando los valores de la matriz @_.

Se pasa a la lista de subrutina

Desde @_ variable es una matriz, por lo que puede pasar la lista a la subrutina.

Pero si tenemos que pasar unos escalares y matrices de parámetros, es necesario enumerar en el último parámetro, de la siguiente manera: 

#!/usr/bin/perl

# 定义函数
sub PrintList{
   my @list = @_;
   print "列表为 : @list\n";
}
$a = 10;
@b = (1, 2, 3, 4);

# 列表参数
PrintList($a, @b);

El programa anterior se fusionará el escalar y una matriz de resultados de salida: 

列表为 : 10 1 2 3 4

Podemos pasar a subprogramas múltiples arrays y hashes, pero si se hace pasar varios arrays y hashes, dará lugar a la pérdida de una identidad independiente. Así que tenemos que utilizar la referencia (la siguiente sección introducirá) para pasar.

Hash pasado a un subprograma

Cuando la tabla hash se pasa a la subrutina, se copia en @_ en la tabla hash será la de ampliar la lista de pares clave / valor. 

#!/usr/bin/perl

# 方法定义
sub PrintHash{
   my (%hash) = @_;

   foreach my $key ( keys %hash ){
      my $value = $hash{$key};
      print "$key : $value\n";
   }
}
%hash = ('name' => 'w3big', 'age' => 3);

# 传递哈希
PrintHash(%hash);

La salida por encima de la ejecución del programa es: 

age : 3
name : w3big

valor de retorno de subrutina

Una subrutina puede ser como otros lenguajes de programación utilizan la instrucción de retorno para devolver valores.

Si no hay instrucción de retorno, a continuación, la última línea de la declaración de subrutina como valor de retorno. 

#!/usr/bin/perl

# 方法定义
sub add_a_b{
   # 不使用 return
   $_[0]+$_[1];  

   # 使用 return
   # return $_[0]+$_[1];  
}
print add_a_b(1, 2)

La salida por encima de la ejecución del programa es: 

3

Subrutina podemos volver escalares, arrays y hashes, pero a cambio múltiples arreglos y hashes, dará lugar a la pérdida de una identidad independiente. Así que tenemos que utilizar la referencia (la siguiente sección introducirá) para devolver múltiples matrices y funciones.

variables privadas de subrutinas

De forma predeterminada, Perl, todas las variables son variables globales, lo que significa que la variable se puede llamar desde cualquier parte del programa.

Si tenemos que establecer las variables privadas, usarmi operador fijar.

mi operador crea variables de alcance léxico, las variables creadas por milugar la supervivencia en el principio de la sentencia hasta que el final del ámbito de cierre.

El alcance se refiere al cierre puede estar en la región se prepara par puede ser un archivo, también puede ser un caso, mientras que, para, foreach, cadena eval.

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

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

#!/usr/bin/perl

# 全局变量
$string = "Hello, World!";

# 函数定义
sub PrintHello{
   # PrintHello 函数的私有变量
   my $string;
   $string = "Hello, w3big!";
   print "函数内字符串：$string\n";
}
# 调用函数
PrintHello();
print "函数外字符串：$string\n";

La salida por encima de la ejecución del programa es: 

函数内字符串：Hello, w3big!
函数外字符串：Hello, World!

variables de asignación temporal

Podemos utilizar los valores temporales locales para las variables globales, el alcance del valor original después de la salida también está de regreso.

variables locales definidas en el programa principal no existe, sino que existen en la subrutina y la subrutina llamada a subrutina. Cuando se define la puede dar un valor, como por ejemplo: 

#!/usr/bin/perl

# 全局变量
$string = "Hello, World!";

sub Printw3big{
   # PrintHello 函数私有变量
   local $string;
   $string = "Hello, w3big!";
   # 子程序调用的子程序
   PrintMe();
   print "Printw3big 函数内字符串值：$string\n";
}
sub PrintMe{
   print "PrintMe 函数内字符串值：$string\n";
}

sub PrintHello{
   print "PrintHello 函数内字符串值：$string\n";
}

# 函数调用
Printw3big();
PrintHello();
print "函数外部字符串值：$string\n";

La salida por encima de la ejecución del programa es: 

PrintMe 函数内字符串值：Hello, w3big!
Printw3big 函数内字符串值：Hello, w3big!
PrintHello 函数内字符串值：Hello, World!
函数外部字符串值：Hello, World!

Las variables estáticas

la función de los operadores estatales es similar al modificador static de C, palabras clave estatales se convertirán en variables locales persistentes.

las variables de estado también léxicas, sólo la definición del dominio variable léxica es válido, por ejemplo: 

#!/usr/bin/perl

use feature 'state';

sub PrintCount{
   state $count = 0; # 初始化变量

   print "counter 值为：$count\n";
   $count++;
}

for (1..5){
   PrintCount();
}

La salida por encima de la ejecución del programa es: 

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

Nota 1: El Estado sólo puede crear una variable con ámbito cerrados dentro de la subrutina.

Nota 2: estado se introduce desde Perl 5.9.4, hay que añadir antes de su uso a utilizar.

Nota 3: El Estado puede declarar escalar, matriz, hash. Pero cuando declarar arrays y hashes, no se puede inicializar (al menos no es compatible con Perl 5.14).

contexto de la llamada de subprogramas

llamadas a subrutinas, que volverán a los valores de diferentes tipos, dependiendo del contexto, como la siguiente localtime () subrutina en contexto escalar devuelve la cadena en el contexto de la lista devuelve una lista: 

#!/usr/bin/perl

# 标量上下文
my $datestring = localtime( time );
print $datestring;

print "\n";

# 列表上下文
($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);
printf("%d-%d-%d %d:%d:%d",$year+1990,$mon+1,$mday,$hour,$min,$sec);

print "\n";

La salida por encima de la ejecución del programa es: 

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