Sous-routines Perl (fonctions)

Les sous-routines Perl sont des fonctions définies par l'utilisateur.

Une sous-routine Perl est un morceau de code distinct qui effectue une tâche spécifique, ce qui peut réduire le code répétitif et rendre le programme plus facile à lire.

Une sous-routine Perl est un bloc de code qui encapsule une série d'opérations ou de calculs, et elle peut être appelée à plusieurs reprises pour être réutilisée dans un programme.

Les sous-routines Perl aident à modulariser les programmes, ce qui rend le code plus facile à comprendre, à maintenir et à réutiliser.

Les sous-routines Perl peuvent apparaître n'importe où dans le programme, avec le format de syntaxe suivant :

sub subroutine{
   statements;
}

Syntaxe d'appel d'une sous-routine :

subroutine( 参数列表 );

Dans les versions antérieures à Perl 5.0, la méthode pour appeler une sous-routine est la suivante :

&subroutine( 参数列表 );

Dans les versions plus récentes, bien que cette méthode d'appel soit toujours prise en charge, elle n'est pas recommandée.

Voyons maintenant un exemple simple :

Exemple

#!/usr/bin/perl # Définition de fonction sub Hello{ print "Hello, World!\n"; } # Appel de fonction Hello();

L'exécution du programme ci-dessus produit la sortie suivante :

Hello, World!

Passage de paramètres aux sous-programmes

Comme dans les autres langages de programmation, les sous-programmes Perl peuvent accepter plusieurs paramètres. Les paramètres de sous-programme sont indiqués par le tableau spécial @_.

Par conséquent, le premier paramètre du sous-programme est $_

Que les paramètres soient de type scalaire ou tableau, lorsque les utilisateurs passent des paramètres à un sous-programme, Perl les appelle par référence par défaut.

Exemple

#!/usr/bin/perl # Définir une fonction pour calculer la moyenne sub Average{ # Obtenir tous les paramètres passés $n = scalar(@_); $sum = 0; foreach $item (@_){ $sum += $item; } $average = $sum /$n; print 'Les paramètres passés sont : ',"@_\n"; # Afficher tout le tableau print "La valeur du premier paramètre est : $_

L'exécution du programme ci-dessus produit la sortie suivante :

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

Les utilisateurs peuvent modifier les valeurs des paramètres réels correspondants en modifiant les valeurs du tableau @_.

Passage de listes aux sous-programmes

Comme la variable @_ est un tableau, elle peut transmettre des listes aux sous-programmes.

Cependant, si nous devons transmettre des paramètres scalaires et des paramètres de tableau, la liste doit être placée en dernier, comme indiqué ci-dessous :

Exemple

#!/usr/bin/perl # Définir une fonction sub PrintList{ my @list = @_; print "List is : @list\n"; } $a = 10; @b = (1, 2, 3, 4); # Paramètre de liste PrintList($a, @b);

Le programme ci-dessus fusionne le scalaire et le tableau, et la sortie est :

列表为 : 10 1 2 3 4

Nous pouvons transmettre plusieurs tableaux et hachages aux sous-programmes, mais en faisant cela, les identités indépendantes (des tableaux et des hachages) peuvent être perdues. Par conséquent, nous devons utiliser des références (introduites dans le chapitre suivant) pour les transmettre.

Passage de hachages aux sous-programmes

Lorsqu'on transmet un hachage à un sous-programme, il est copié dans @_, et le hachage est développé en une liste de paires clé/valeur.

Exemple

#!/usr/bin/perl # Définition de méthode sub PrintHash{ my (%hash) = @_; foreach my $key ( keys %hash ){ my $value = $hash{$key}; print "$key : $value\n"; } } %hash = ('name' => 'example', 'age' => 3); # Passer le hash PrintHash(%hash);

L'exécution du programme ci-dessus produit la sortie suivante :

age : 3
name : example

Valeurs de retour des sous-programmes

Comme d'autres langages de programmation, les sous-programmes peuvent utiliser l'instruction return pour renvoyer une valeur.

Si aucune instruction return n'est utilisée, la dernière instruction exécutée dans le sous-programme est traitée comme la valeur de retour.

Exemple

#!/usr/bin/perl # Définition de la méthode sub add_a_b{ # Sans utiliser return $_[0]+$_[1]; # Utilisation de return # return $_[0]+$_[1]; } print add_a_b(1, 2)

L'exécution du programme ci-dessus produit la sortie suivante :

3

En Perl, les références peuvent être utilisées pour renvoyer plusieurs tableaux et hash. Une référence est une valeur scalaire qui pointe vers une structure de données (comme un tableau ou un hash). Grâce aux références, nous pouvons regrouper plusieurs tableaux et hash dans une seule valeur de retour à transmettre au programme appelant. Cela préserve l'indépendance et l'intégrité des structures de données.

Exemple

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();

# Utilisez des références pour accéder aux données renvoyées
print "Tableau 1 : @{$array_ref1}\n";
print "Tableau 2 : @{$array_ref2}\n";
print "Hash 1: " . join(", ", %{$hash_ref1}) . "\n";
print "Hash 2: " . join(", ", %{$hash_ref2}) . "\n";

Dans le code ci-dessus, la sous-routine return_multiple_data renvoie des références vers quatre structures de données.

Dans le programme appelant, nous déréférençons ces références pour accéder aux tableaux et hachages retournés, préservant ainsi leur indépendance et leur intégrité.

La sortie est :

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

Variables privées dans les sous-routines

Par défaut, toutes les variables en Perl sont des variables globales, ce qui signifie qu'elles sont accessibles n'importe où dans le programme.

Si nous devons définir des variables privées, nous pouvons utiliser l'opérateurmy`my` pour les définir.

myL'opérateur `my` est utilisé pour créer des variables à portée lexicale.myLes variables créées par `my` existent du point de déclaration jusqu'à la fin de la portée englobante.

La portée englobante peut être la région comprise entre une paire d'accolades, un fichier, ou une chaîne if, while, for, foreach ou 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); #  同时声明多个变量
}

Exemple

#!/usr/bin/perl # Variable globale $string = "Hello, World!"; # Définition de fonction sub PrintHello{ # Variable privée de la fonction PrintHello my $string; $string = "Bonjour, Exemple !"; print "Chaîne à l'intérieur de la fonction :$string\n"; } # Appeler la fonction PrintHello(); print "Chaîne en dehors de la fonction :$string\n";

L'exécution du programme ci-dessus produit la sortie suivante :

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

Affectation temporaire de variables

Nous pouvons utiliser local pour fournir une valeur temporaire à une variable globale, et la valeur d'origine est restaurée après avoir quitté la portée.

Les variables définies avec local n'existent pas dans le programme principal, mais elles existent dans la sous-routine et dans les sous-routines appelées par cette sous-routine. Elles peuvent recevoir une valeur lors de la définition, par exemple :

Exemple

#!/usr/bin/perl # Variable globale $string = "Hello, World!"; sub PrintExample{ # Variable privée de la fonction PrintHello local $string; $string = "Bonjour, Exemple !"; # Sous-routine appelée par la sous-routine PrintMe(); print "Valeur de la chaîne à l'intérieur de la fonction PrintExample :$string\n"; } sub PrintMe{ print "Valeur de la chaîne à l'intérieur de la fonction PrintMe :$string\n"; } sub PrintHello{ print "Valeur de la chaîne à l'intérieur de la fonction PrintHello :$string\n"; } # Appeler la fonction PrintExample(); PrintHello(); print "Valeur de la chaîne en dehors de la fonction :$string\n";

L'exécution du programme ci-dessus produit la sortie suivante :

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

Variables statiques

L'opérateur state fonctionne comme le modificateur static en C ; le mot-clé state rend les variables locales persistantes.

state est également une variable lexicale, elle n'est donc valide que dans la portée lexicale où la variable est définie. Par exemple :

Exemple

#!/usr/bin/perl use feature 'state'; sub PrintCount{ state $count = 0; # Initialiser la variable print "La valeur du compteur est :$count\n"; $count++; } for (1..5){ PrintCount(); }

L'exécution du programme ci-dessus produit la sortie suivante :

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

Remarque 1 : state ne peut créer que des variables dont la portée englobante se trouve à l'intérieur d'une sous-routine.

Remarque 2 : state a été introduit à partir de Perl 5.9.4, vous devez donc ajouter `use` avant de l'utiliser.

Remarque 3 : state peut déclarer des scalaires, des tableaux et des hachages. Toutefois, lors de la déclaration de tableaux et de hachages, ils ne peuvent pas être initialisés (du moins, non pris en charge dans Perl 5.14).

Contexte d'appel de sous-routine

Lors d'un appel de sous-routine, différents types de valeurs sont renvoyés selon le contexte. Par exemple, la sous-routine localtime() ci-dessous renvoie une chaîne en contexte scalaire et une liste en contexte de liste :

Exemple

#!/usr/bin/perl # Contexte scalaire my $datestring = localtime( time ); print $datestring; print "\n"; # Contexte de liste # La valeur de $year est un compteur commençant à 1900 comme année de base ($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";

L'exécution du programme ci-dessus produit la sortie suivante :

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