Perl subroutine (funzione)

Perl subroutine che è funzione definita dall'utente.

Perl subroutine che è un pezzo di codice per eseguire la separazione compiti speciali, si può fare per ridurre la duplicazione di codice e rendere il programma facile da leggere.

Perl subroutine può comparire in qualsiasi parte del programma, la sintassi è la seguente:

sub subroutine{
   statements;
}

sintassi di chiamata dei sottoprogrammi:

subroutine( 参数列表 );

Perl 5.0 nelle seguenti versioni richiamo del sottoprogramma come segue:

&subroutine( 参数列表 );

Nella nuova versione, anche se supporta il metodo di chiamata, ma non è raccomandato.

Prossimo guardiamo è un semplice esempio:

#!/usr/bin/perl

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

# 函数调用
Hello();

Il programma precedente, l'uscita è:

Hello, World!

Passaggio di parametri a sottoprogrammi

Perl subroutine può accettare più parametri e altri programmi, utilizzare la matrice @_ parametri speciali subroutine indicati.

Così, il primo argomento subroutine è $ _ [0], il secondo è $ _ [1], e così via.

Se i parametri sono di tipo scalare o array, l'utente del parametro passato alla subroutine, di default Perl dal riferimento li chiamano.

#!/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);

Il programma precedente, l'uscita è:

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

L'utente può modificare il valore dei corrispondenti parametri attuali modificando i valori nella matrice @_.

Passato alla lista subroutine

Dal momento che @_ variabile è un array, in modo che possa passare l'elenco per la subroutine.

Ma se abbiamo bisogno di passare uno scalare e array di parametri, è necessario elencare l'ultimo parametro, come segue:

#!/usr/bin/perl

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

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

Il programma di cui sopra si fonderanno lo scalare e una serie di risultati di output:

列表为 : 10 1 2 3 4

Siamo in grado di passare ad array multipli sottoprogrammi e hash, ma se è passato più array e hash, porterà alla perdita di una identità indipendente. Quindi abbiamo bisogno di usare il riferimento (la prossima sezione introdurrà) a passare.

Hash passato a un sottoprogramma

Quando la tabella di hash viene passato alla subroutine, che verrà copiato @_ nella tabella hash sarà quello di espandere l'elenco delle coppie chiave / valore.

#!/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);

L'output sopra l'esecuzione del programma è il seguente:

age : 3
name : w3big

valore di ritorno subroutine

Una subroutine può essere come gli altri linguaggi di programmazione utilizzare l'istruzione return per restituire i valori.

Se nessuna dichiarazione di ritorno, quindi l'ultima riga della dichiarazione subroutine come valore di ritorno.

#!/usr/bin/perl

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

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

L'output sopra l'esecuzione del programma è il seguente:

Subroutine possiamo tornare scalari, array e hash, ma in cambio più array e hash, porterà alla perdita di una identità indipendente. Quindi abbiamo bisogno di usare il riferimento (la prossima sezione introdurrà) per tornare più array e funzioni.

variabili private di subroutine

Per impostazione predefinita, Perl, tutte le variabili sono variabili globali, il che significa che la variabile può essere chiamato da qualsiasi punto del programma.

Se abbiamo bisogno di impostare le variabili private, utilizzareil mio operatore per impostare.

il mio operatore crea variabili con scope lessicale, le variabili create con il mioposto sopravvivenza nel principio della dichiarazione fino alla fine del campo di applicazione di chiusura.

Scope riferisce alla chiusura può essere nella regione bretelle coppia può essere un file, può anche essere un caso, mentre, per, foreach, stringa eval.

L'esempio seguente mostra come dichiarare una o più variabili private:

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";

L'output sopra l'esecuzione del programma è il seguente:

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

variabili assegnazione temporanea

Siamo in grado di utilizzare i valori temporanei locali per le variabili globali, il campo di applicazione del valore originale dopo l'uscita è anche indietro.

variabili locali definite nel programma principale non esiste, ma esistono nel subroutine e il richiamo del sottoprogramma subroutine. Quando si definisce in grado di dare un valore, come ad esempio:

#!/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";

L'output sopra l'esecuzione del programma è il seguente:

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

Le variabili statiche

funzione di operatori statali è simile al modificatore static di C, le parole chiave di stato diventano variabili locali persistenti.

variabili di stato anche lessicali, solo la definizione del dominio variabile lessicale è valido, ad esempio:

#!/usr/bin/perl

use feature 'state';

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

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

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

L'output sopra l'esecuzione del programma è il seguente:

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

Nota 1: Stato può creare solo variabili chiusi con ambito all'interno della subroutine.
Nota 2: stato viene introdotto da Perl 5.9.4, si deve aggiungere prima dell'uso per usare.
Nota 3: Stato può dichiarare scalari, array, hash. Ma quando si dichiara array e hash, non è possibile inizializzare (almeno Perl 5.14 non è supportato).

contesto Chiamata di sottoprogramma

le chiamate di subroutine, si tornerà ai valori di tipo diverso a seconda del contesto, come ad esempio il seguente localtime () subroutine in contesto scalare restituisce la stringa in un contesto di lista restituisce 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";

L'output sopra l'esecuzione del programma è il seguente:

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

Precedente: Data di Perl

Next: riferimenti Perl

Perl corso

Perl subroutine (funzione)

Passaggio di parametri a sottoprogrammi

Passato alla lista subroutine

Hash passato a un sottoprogramma

valore di ritorno subroutine

variabili private di subroutine

variabili assegnazione temporanea

Le variabili statiche

contesto Chiamata di sottoprogramma