Dokuwiki

Outils pour utilisateurs

Outils du site

Piste :
perl:fonctions

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
perl:fonctions [2009/03/15 00:43] – modification externe 127.0.0.1perl:fonctions [2013/03/12 23:40] (Version actuelle) – root
Ligne 1: Ligne 1:
 +====== Fonctions ======
 +
 ====== 1. Déclaration ====== ====== 1. Déclaration ======
  
 Il y a plusieurs façons de déclarer et implémenter une fonction en Perl, mais en pratique une seule (la plus simple) est utilisée : Il y a plusieurs façons de déclarer et implémenter une fonction en Perl, mais en pratique une seule (la plus simple) est utilisée :
 +<code perl>
   sub produit {   sub produit {
   my ($a, $b) = @_;   my ($a, $b) = @_;
Ligne 7: Ligne 10:
   return $a * b;   return $a * b;
   }   }
 +</code>
  
 ===== Nommage ===== ===== Nommage =====
Ligne 15: Ligne 19:
  
 Il est possible de déclarer un simple prototype de fonction, comme en C, mais cela est en général inutile. En effet, le compilateur de Perl utilise "2 passes": dans la première il collecte les symboles (fonctions et variables déclarés), dans la deuxième il les compile et effectue l'édition des liens. Il est donc tout à fait possible d'écrire ceci : Il est possible de déclarer un simple prototype de fonction, comme en C, mais cela est en général inutile. En effet, le compilateur de Perl utilise "2 passes": dans la première il collecte les symboles (fonctions et variables déclarés), dans la deuxième il les compile et effectue l'édition des liens. Il est donc tout à fait possible d'écrire ceci :
 +<code perl>
   bonjour("world");   bonjour("world");
      
Ligne 21: Ligne 26:
   print "Hello $text !\n";   print "Hello $text !\n";
   }   }
 +</code>
  
 ===== Appel ===== ===== Appel =====
  
 Quand il n'y a pas d'ambiguité dans la syntaxe de l'instruction, les parenthèses pour passer les arguments sont facultatives : Quand il n'y a pas d'ambiguité dans la syntaxe de l'instruction, les parenthèses pour passer les arguments sont facultatives :
 +<code perl>
   my @cles = sort keys %hash; # Ou: sort(keys(%hash));   my @cles = sort keys %hash; # Ou: sort(keys(%hash));
 +</code>
  
 La pratique consiste à utiliser les parenthèses à bon escient en favorisant la lisibilité : La pratique consiste à utiliser les parenthèses à bon escient en favorisant la lisibilité :
Ligne 47: Ligne 55:
  
 Pour récupérer les paramètres en début de fonction, on utilise les fonctions de traitement de listes à notre disposition. Parmis les syntaxes les plus courantes, on trouve : Pour récupérer les paramètres en début de fonction, on utilise les fonctions de traitement de listes à notre disposition. Parmis les syntaxes les plus courantes, on trouve :
 +<code perl>
   sub methode_a {   sub methode_a {
   my ($nb, $temps, $item) = @_;   my ($nb, $temps, $item) = @_;
Ligne 58: Ligne 67:
   ...   ...
   }   }
 +</code>
  
 **Note**: si votre fonction accepte plusieurs scalaires et une unique liste en arguments, passez la liste en dernier argument - l'utilisation sera alors triviale (ex: my ($facteur, @valeurs) = @_). **Note**: si votre fonction accepte plusieurs scalaires et une unique liste en arguments, passez la liste en dernier argument - l'utilisation sera alors triviale (ex: my ($facteur, @valeurs) = @_).
Ligne 64: Ligne 74:
  
 Par défaut, les paramètres sont passés par référence. Cela signifie que les élements du tableau **@_** sont équivalents aux arguments passés à la fonction. Exemple : Par défaut, les paramètres sont passés par référence. Cela signifie que les élements du tableau **@_** sont équivalents aux arguments passés à la fonction. Exemple :
 +<code perl>
   sub incremente {   sub incremente {
   $_[0]++;   $_[0]++;
Ligne 71: Ligne 82:
   incremente($a);   incremente($a);
   # $a vaut 6   # $a vaut 6
 +</code>
  
 Si on veut obtenir un passage par copie (cas le plus courant), il suffit d'effectuer explicitement cette copie en créant des variables locales (ce qui est décrit plus haut dans la récupération traditionnelle des paramètres) : Si on veut obtenir un passage par copie (cas le plus courant), il suffit d'effectuer explicitement cette copie en créant des variables locales (ce qui est décrit plus haut dans la récupération traditionnelle des paramètres) :
 +<code perl>
   sub n_incremente_pas {   sub n_incremente_pas {
   my $val = $_[0]; # Ou: my ($val) = @_;   my $val = $_[0]; # Ou: my ($val) = @_;
Ligne 81: Ligne 94:
   n_incremente_pas($a);   n_incremente_pas($a);
   # $a vaut 5   # $a vaut 5
 +</code>
  
 **Note**: si une constante est passée à une fonction et que cette dernière tente de la modifier, une erreur aura lieu lors de l'exécution. **Note**: si une constante est passée à une fonction et que cette dernière tente de la modifier, une erreur aura lieu lors de l'exécution.
Ligne 92: Ligne 106:
  
 Par défaut, une fonction Perl retourne la valeur de la dernière instruction évaluée, par exemple ici le résultat (booléen) du test : Par défaut, une fonction Perl retourne la valeur de la dernière instruction évaluée, par exemple ici le résultat (booléen) du test :
 +<code perl>
   sub est_pair {   sub est_pair {
   $_[0] % 2 ====== 0;   $_[0] % 2 ====== 0;
   }   }
 +</code>
  
 Il est bien entendu possible de rendre ce fait explicite, et surtout de pouvoir retourner une valeur depuis n'importe quel endroit de la fonction avec l'instruction return : Il est bien entendu possible de rendre ce fait explicite, et surtout de pouvoir retourner une valeur depuis n'importe quel endroit de la fonction avec l'instruction return :
 +<code perl>
   sub est_pair {   sub est_pair {
   return $_[0] % 2 ====== 0;   return $_[0] % 2 ====== 0;
   }   }
 +</code>
  
 **Note**: pour les fonctions dont la valeur de retour n'a pas de signification particulière, il arrive souvent qu'on retour la valeur **1** (vrai en booléen), cette habitude venant de la programmation shell et du principe de "moindre surprise" quand on combine des fonctions dont attend un comportement "classique". Ex : **Note**: pour les fonctions dont la valeur de retour n'a pas de signification particulière, il arrive souvent qu'on retour la valeur **1** (vrai en booléen), cette habitude venant de la programmation shell et du principe de "moindre surprise" quand on combine des fonctions dont attend un comportement "classique". Ex :
 +<code perl>
   sub une_fonction {   sub une_fonction {
   ...   ...
   1;   1;
   }   }
 +</code>
  
 Pour retourner une liste, il n'y a pas de surprise, et l'utilisation pour l'appelant peut être très pratique : Pour retourner une liste, il n'y a pas de surprise, et l'utilisation pour l'appelant peut être très pratique :
 +<code perl>
   sub conjugue {   sub conjugue {
   my ($re, $im) = @_;   my ($re, $im) = @_;
   return ($re, -$im);   return ($re, -$im);
   }   }
-  +
   my($cr, $ci) = conjugue($cr, $ci);   my($cr, $ci) = conjugue($cr, $ci);
 +</code>
  
 ===== Contextualisation ===== ===== Contextualisation =====
  
 Afin de pouvoir programmer des fonctions qui profitent de la sensibilité au contexte, comme décrit dans le chapitre sur les variables, on a à disposition une simple fonction : Afin de pouvoir programmer des fonctions qui profitent de la sensibilité au contexte, comme décrit dans le chapitre sur les variables, on a à disposition une simple fonction :
 +<code perl>
   sub meteo {   sub meteo {
   ...   ...
Ligne 126: Ligne 148:
   my @mensuel = meteo;   my @mensuel = meteo;
   my $moyenne = meteo;   my $moyenne = meteo;
 +</code>
  
 Cette possibilité est très souvent utilisée par les fonctions qui renvoient des listes, pour également renvoyer une information "utile" dans le cas du contexte scalaire. Exemple avec la date du jour en heure locale : Cette possibilité est très souvent utilisée par les fonctions qui renvoient des listes, pour également renvoyer une information "utile" dans le cas du contexte scalaire. Exemple avec la date du jour en heure locale :
 +<code perl>
   ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();   ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
   $now = localtime(); # "Thu Oct 13 04:54:34 1994"   $now = localtime(); # "Thu Oct 13 04:54:34 1994"
 +</code>
  
 **Note**: il existe aussi le contexte //vide//, dans le cas où la fonction est appelée sans que sa valeur de retour soit utilisée (détectable par wantarray ====== undef). **Note**: il existe aussi le contexte //vide//, dans le cas où la fonction est appelée sans que sa valeur de retour soit utilisée (détectable par wantarray ====== undef).
- 
perl/fonctions.1237077782.txt.gz · Dernière modification : 2013/03/12 23:23 (modification externe)