Sous-programmes Perl (fonctions)
Les sous-programmes Perl sont des fonctions définies par l'utilisateur.
Le sous-programme Perl est un morceau de code séparé qui effectue une tâche spéciale. Il peut réduire le code répété et rendre le programme plus facile à lire.
Le sous-programme Perl peut apparaître n'importe où dans le programme, le format de syntaxe est le suivant :
sub subroutine{
statements;
}Le format de syntaxe pour appeler un sous-programme :
subroutine( 参数列表 );
Appeler la méthode du sous-programme dans les versions ci-dessous Perl 5.0 Comme suit :
&subroutine( 参数列表 );
Dans la nouvelle version, bien que cette méthode d'appel soit également prise en charge, elle n'est pas recommandée.
Regardons ensuite un exemple simple :
#!/usr/bin/perl
# 函数定义
sub Hello{
print "Hello, World!\n";
}
# 函数调用
Hello();Exécutez le programme ci-dessus, le résultat de sortie est :
Hello, World!
Passez les paramètres au sous-programme
Le sous-programme Perl peut accepter plusieurs paramètres, comme les autres paramètres de programmation sont marqués d'un tableau spécial @_.
Donc, le premier paramètre du sous-programme est $_[0], le deuxième paramètre est $_[1], et ainsi de suite.
Peu importe que les paramètres soient scalaires ou matriciels, lorsque l'utilisateur transmet les paramètres au sous-programme, Perl les appellera par référence par défaut.
#!/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);Exécutez le programme ci-dessus, le résultat de sortie est :
传入的参数为 : 10 20 30 第一个参数值为 : 10 传入参数的平均值为 : 20
Les utilisateurs peuvent modifier la valeur du paramètre réel correspondant en modifiant la valeur dans le tableau @_.
Passer une liste à un sous-programme
Puisque la variable @_ est un tableau, elle peut transmettre une liste au sous-programme.
Mais si nous devons transmettre des paramètres scalaires et matriciels, nous devons mettre la liste sur le dernier paramètre, comme indiqué ci-dessous :
#!/usr/bin/perl
# 定义函数
sub PrintList{
my @list = @_;
print "列表为 : @list\n";
}
$a = 10;
@b = (1, 2, 3, 4);
# 列表参数
PrintList($a, @b);Le programme ci-dessus combine des scalaires et des tableaux, et des sorties le résultat Pour :
列表为 : 10 1 2 3 4
Nous pouvons transmettre plusieurs tableaux et hachages au sous-programme, mais lors du passage de plusieurs tableaux et hachages, les identités indépendantes seront perdues. Nous devons donc utiliser des références (qui seront présentées dans le prochain chapitre) pour réussir.
Passer un hachage à un sous-programme
Lorsqu'une table de hachage est passée à un sous-programme, elle sera copiée dans @_ et la table de hachage sera développée en une liste de combinaisons clé/valeur .
#!/usr/bin/perl
# 方法定义
sub PrintHash{
my (%hash) = @_;
foreach my $key ( keys %hash ){
my $value = $hash{$key};
print "$key : $value\n";
}
}
%hash = ('name' => 'php', 'age' => 3);
# 传递哈希
PrintHash(%hash);Le résultat de l'exécution du programme ci-dessus est :
age : 3 name : php
Valeur de retour du sous-programme
Les sous-programmes peuvent utiliser l'instruction return pour renvoyer les valeurs de fonction comme les autres programmes langues.
Si aucune instruction return n'est utilisée, la dernière ligne du sous-programme sera utilisée comme valeur de retour.
#!/usr/bin/perl
# 方法定义
sub add_a_b{
# 不使用 return
$_[0]+$_[1];
# 使用 return
# return $_[0]+$_[1];
}
print add_a_b(1, 2)Le résultat de l'exécution du programme ci-dessus est :
3
Dans le sous-programme, nous pouvons renvoyer des scalaires, des tableaux et des hachages, mais lors du retour de plusieurs tableaux et hachages, des valeurs indépendantes seront logo perdu. Nous devons donc utiliser des références (qui seront présentées dans le chapitre suivant) pour renvoyer plusieurs tableaux et fonctions.
Variables privées des sous-programmes
Par défaut, toutes les variables en Perl sont des variables globales, ce qui signifie que les variables peuvent être appelées n'importe où dans le programme.
Si nous devons définir une variable privée, nous pouvons utiliser l'opérateur mon pour la définir. L'opérateur
my est utilisé pour créer des variables de portée lexicale. Les variables créées via my survivent du début de la déclaration jusqu'à la fin de la portée fermée.
La portée fermée fait référence à la zone située à l'intérieur d'une paire d'accolades, cela peut être un fichier ou une chaîne if, while, for, foreach, eval.
L'exemple suivant montre comment déclarer une ou plusieurs variables privées :
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, php!";
print "函数内字符串：$string\n";
}
# 调用函数
PrintHello();
print "函数外字符串：$string\n";Le résultat de l'exécution du programme ci-dessus est :
函数内字符串：Hello, php! 函数外字符串：Hello, World!
Affectation temporaire de variables
Nous pouvons utiliser local pour fournir des valeurs temporaires pour les variables globales et renvoyer les valeurs d'origine après avoir quitté la portée.
Les variables locales définies n'existent pas dans le programme principal, mais existent dans le sous-programme et les sous-programmes appelés par le sous-programme. Vous pouvez lui attribuer une valeur lors de la définition, telle que :
#!/usr/bin/perl
# 全局变量
$string = "Hello, World!";
sub Printphp{
# PrintHello 函数私有变量
local $string;
$string = "Hello, php!";
# 子程序调用的子程序
PrintMe();
print "Printphp 函数内字符串值：$string\n";
}
sub PrintMe{
print "PrintMe 函数内字符串值：$string\n";
}
sub PrintHello{
print "PrintHello 函数内字符串值：$string\n";
}
# 函数调用
Printphp();
PrintHello();
print "函数外部字符串值：$string\n";Le résultat de l'exécution du programme ci-dessus est :
PrintMe 函数内字符串值：Hello, php! Printphp 函数内字符串值：Hello, php! PrintHello 函数内字符串值：Hello, World! 函数外部字符串值：Hello, World!
Variable statique
La fonction du L'opérateur d'état est similaire à celui en C. Le modificateur static et le mot-clé state rendent les variables locales persistantes.
state est également une variable lexicale, elle n'est donc valable que dans la portée lexicale dans laquelle la variable est définie. Par exemple :
#!/usr/bin/perl
use feature 'state';
sub PrintCount{
state $count = 0; # 初始化变量
print "counter 值为：$count\n";
$count++;
}
for (1..5){
PrintCount();
}Le résultat de sortie de l'exécution du programme ci-dessus est. :
counter 值为：0 counter 值为：1 counter 值为：2 counter 值为：3 counter 值为：4
Remarque 1 : l'état ne peut créer que des variables dont la portée fermée est à l'intérieur du sous-programme.
Remarque 2 : state a été introduit à partir de Perl 5.9.4, donc use doit être ajouté avant utilisation.
Remarque 3 : l'état peut déclarer des scalaires, des tableaux et des hachages. Mais les tableaux et les hachages ne peuvent pas être initialisés lorsqu'ils sont déclarés (du moins pas en Perl 5.14).
Contexte d'appel du sous-programme
Pendant le processus d'appel du sous-programme, différents types de valeurs seront renvoyés en fonction du contexte. Par exemple, le sous-programme localtime() suivant. renvoie dans un contexte scalaire Chaîne, renvoie la liste dans un contexte de liste :
#!/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";Le résultat de l'exécution du programme ci-dessus est :
Sun Jun 12 15:58:09 2016 2106-6-12 15:58:9
