Sous-programmes Perl (fonctions)

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

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

Les sous-programmes Perl peuvent apparaître n'importe où dans le programme et le format de syntaxe est le suivant :

 sous-sous-programme{instructions;}

Format de syntaxe pour appeler le sous-programme :

 sous-programme (liste de paramètres);

Dans les versions inférieures à Perl 5.0, la méthode d'appel d'un sous-programme est la suivante :

 &subroutine(liste de paramètres);

Dans la nouvelle version, bien que cette méthode d'appel soit également prise en charge, son utilisation n'est pas recommandée.

Regardons ensuite un exemple simple :

Exemple

#!/usr/bin/perl # Définition de la fonction sous Bonjour { imprimer " Bonjour tout le monde ! n " } # Appel de fonction Bonjour ( ) ;

En exécutant le programme ci-dessus, le résultat de sortie est :

 Bonjour le monde!

Passer les paramètres au sous-programme

Les sous-programmes Perl peuvent accepter plusieurs paramètres, comme les autres paramètres de sous-programme sont marqués du tableau spécial @_.

Par conséquent, le premier paramètre du sous-programme est $_[0], le deuxième paramètre est $_[1], et ainsi de suite.

Que les paramètres soient scalaires ou matriciels, lorsque l'utilisateur transmet les paramètres au sous-programme, Perl les appelle par référence par défaut.

Exemple

#!/usr/bin/perl #Définir la fonction de moyenne sous Moyenne { # Récupère tous les paramètres entrants $n = scalaire ( @_ ) ; $ somme = 0 ; $article ( @_ ) { $somme += $ élément } $average = $sum / $n; print 'Le paramètre transmis est : ',"@_n" # Imprimer l'intégralité du tableau print "La première valeur du paramètre est : $_[0]n"; Le premier paramètre print "La valeur moyenne des paramètres transmis est : $averagen"; #Imprimer la valeur moyenne} #Appeler la fonction Average(10, 20, 30);

En exécutant le programme ci-dessus, le résultat de sortie est :

 Les paramètres transmis sont : 10 20 30 La valeur du premier paramètre est : 10 La valeur moyenne des paramètres transmis est : 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, une liste peut lui être transmise dans le 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 :

Exemple

#!/usr/bin/perl # définir la fonction sous ImprimerListe { mon @liste = @_ ; imprimer " La liste est : @list n " ; $a = 10 ; @b = ( 1 , 2 , 3 , 4 ) # Liste des paramètres ; Liste d'impression ( $a , @b ) ;

Le programme ci-dessus combine des scalaires et des tableaux, et le résultat est :

 La liste est : 10 1 2 3 4

Nous pouvons transmettre plusieurs tableaux et hachages au sous-programme, mais lors de la transmission 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 le hachage au sous-programme

Lorsqu'une table de hachage est transmise au sous-programme, elle est copiée dans @_ et la table de hachage est développée en une liste de combinaisons clé/valeur.

Exemple

#!/usr/bin/perl #Définition de la méthode sous ImprimerHash { mon ( %hash ) = @_ ; pour chaque mon $clé ( clés %hacher ) { mon $value = $hash { $ key } ; " $clé : $ valeur n " ; } %hash = ( ' name ' => ' codercto ' , ' age ' => 3 ) # Passer le hachage ; PrintHash ( %hash ) ;

Le résultat de l’exécution du programme ci-dessus est :

 âge : 3 ansnom : codercto

valeur de retour du sous-programme

Les sous-programmes peuvent renvoyer des valeurs de fonction à l'aide de l'instruction return, tout comme dans d'autres langages de programmation.

Si aucune instruction return n'est utilisée, la dernière ligne du sous-programme est utilisée comme valeur de retour.

Exemple

#!/usr/bin/perl #Définition de la méthode sous ajouter_a_b { # N'utilisez pas de retour $_ [ 0 ] + $_ [ 1 ] ; # Utiliser le retour # renvoie $_[0]+$_[1]; } imprimer ajouter_a_b ( 1 , 2 )

Le résultat de l’exécution du programme ci-dessus est :

 3

Nous pouvons renvoyer des scalaires, des tableaux et des hachages dans des sous-programmes, mais lors du renvoi de plusieurs tableaux et hachages, les identités indépendantes seront perdues. Nous devons donc utiliser des références (introduites dans le chapitre suivant) pour renvoyer plusieurs tableaux et fonctions.

Variables privées de sous-programme

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 my 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 dans 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 n'est pas visible en dehors de la méthode somefunc() my ($another, @an_array, %a_hash); # Déclarez plusieurs variables en même temps}

Exemple

#!/usr/bin/perl #Variables globales $string = " Bonjour tout le monde ! " # Définition de la fonction sous ImprimerBonjour { #Variables privées de la fonction PrintHello mon $string ; $string = " Bonjour , Codercto ! " ; " Chaîne dans la fonction : $string n " ; # Fonction d'appel ImprimerBonjour ( ) ; imprimer " Chaîne en dehors de la fonction : $string n " ;

Le résultat de l’exécution du programme ci-dessus est :

 Chaîne à l'intérieur de la fonction : Bonjour, Codercto ! Chaîne à l'extérieur de la fonction : Bonjour, Monde !

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 définies par local 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 sa définition, telle que :

Exemple

#!/usr/bin/perl #Variables globales $string = " Bonjour tout le monde ! " ; ImprimerCodercto { Variable privée de la fonction #PrintHello locale $string ; $string = " Bonjour , Codercto ! " # Sous-programme appelé par le sous-programme Imprime-moi ( ) ; imprimer " Valeur de chaîne dans la fonction PrintCodercto : $ string n " } sous Imprime-moi { imprimer " Valeur de chaîne dans la fonction PrintMe : $ string n " } sous ImprimerBonjour { imprimer " Valeur de chaîne dans la fonction PrintHello : $ string n " } # Appel de fonction PrintCodercto ( ) ; PrintBonjour ( ) ;​ " Valeur de chaîne en dehors de la fonction : $string n " ;

Le résultat de l’exécution du programme ci-dessus est :

 Valeur de chaîne dans la fonction PrintMe : Bonjour, Codercto!PrintCodercto Valeur de chaîne dans la fonction : Bonjour, Codercto!PrintHello Valeur de chaîne dans la fonction : Bonjour, Monde ! Valeur de chaîne en dehors de la fonction : Bonjour, Monde !

variable statique

La fonction de l'opérateur d'état est similaire au modificateur statique 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 dans laquelle la variable est définie. Par exemple :

Exemple

#!/usr/bin/perl utiliser la fonctionnalité ' état ' ;​ Nombre d'impressions { État $count = 0 ; #Initialiser les variables imprimer " la valeur du compteur est : $count n " ; $count ++ ; pour ( 1 . .5 ) { Nombre d' impressions ( ) ;

Le résultat de l’exécution du programme ci-dessus est :

 La valeur du compteur est : 0 compteur La valeur est : 1 compteur La valeur est : 2 compteur La valeur est : 3 compteur La valeur est : 4

Remarque 1 : l'état ne peut créer que des variables dont la portée fermée se trouve dans le 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 de sous-programme

Lors du processus d'appel du sous-programme, différents types de valeurs seront renvoyés selon le contexte. Par exemple, le sous-programme localtime() suivant renvoie une chaîne dans un contexte scalaire et une liste dans un contexte de liste :

Exemple

#!/usr/bin/perl # Contexte scalaire mon $datestring = heure locale ( temps ) ; imprimer $chaîne de date ; imprimer " n " ; # contexte de liste ( $sec , $min , $hour , $mday , $mon , $year , $wday , $yday , $isdst ) = heure locale ( heure ) ( " % d- %d-%d %d:% d :%d " , $année + 1990 , $mon + 1 , $mday , $hour , $min , $sec ) ; imprimer " n » ;

Le résultat de l’exécution du programme ci-dessus est :

 Dim. 12 juin 15:58:09 20162106-6-12 15:58:9