FAQ PerlConsultez toutes les FAQ

Nombre d'auteurs : 18, nombre de questions : 250, dernière mise à jour : 29 octobre 2015  Ajouter une question

 

Bienvenue sur la FAQ Perl. Cette FAQ a pour vocation de vous enseigner ou de vous faire revoir les notions élémentaires de ce fantastique langage. Perl est très utilisé dans différents domaines depuis la gestion système, le réseaux, l'administration de bases de données, le web (CGI), la bureautique, la conception d'interfaces graphiques ou des contextes scientifiques telle la bioinformatique. Nous espérons que cette FAQ vous sera d'une grande utilité.

Vous souhaitez participer à l'amélioration de cette FAQ, n'hésitez pas !! Commentez

Bonne lecture !


SommaireS'initier à PerlStructures de contrôle (20)
précédent sommaire suivant
 

En Perl, il est possible et même souhaitable d'organiser le code en blocs d'instructions. Ces blocs seront exécutés ou non en fonction de différentes conditions (que l'on nomme alternatives) ou pourront être répétés autant que de besoin (itératives).
Un bloc débute par une accolade ouvrante et se termine par une accolade fermante.
Les blocs peuvent être imbriqués les uns dans les autres. Un bloc peut contenir indifféremment d'autres blocs ou des commandes isolées. Il est de coutume d'indenter les blocs, c'est-à-dire d'introduire un ou plusieurs espaces de marge à gauche des instructions contenues dans les blocs. Plus il y a des niveaux d'imbrication, plus on introduit des espaces. Ceci permet une lecture plus aisée de la structure du code et permet même à certains éditeurs de texte de la mettre en valeur par des barres verticales reliant le début à la fin du bloc, ou par l'apparition de boutons permettant de masquer/démasquer le bloc à volonté (cas de Scintilla Text Editor, logiciel libre d'édition de code source).

Mis à jour le 5 mai 2005 2Eurocents

La notion de bloc d'instructions limite la visibilité des variables. En effet, quel que soit leur type (scalaire, tableau, table associative), les variables ne sont visibles - accessibles - qu'à l'intérieur du bloc où elles sont définies. Elles sont donc utilisables à l'intérieur de la paire d'accolades contenant leur déclaration ou à l'intérieur des blocs que celle-ci contient. En outre, toute redéclaration d'une variable de même nom à l'intérieur d'un bloc masquera automatiquement la valeur que la variable avait acquise à l'extérieur de ce bloc. La variable reprendra sa valeur d'origine aussitôt que l'exécution du bloc contenant la redéclaration sera terminée. On parle alors de variables locales, la portée de la variable (là où l'on peut l'utiliser) étant limitée à ce seul bloc d'instructions.

Mis à jour le 5 mai 2005 2Eurocents

La portée et la visibilité que l'on vient de définir sont en fait valables pour les variables déclarées au moyen du mot-clef my. Celui-ci limite la portée de la variable au bloc en cours d'exécution. Pour qu'une variable soit accessible hors de ce bloc, il existe deux solutions :

  • définir cette variable hors de tout bloc d'instructions. Elle est alors disponible dans tout le script ;
  • déclarer cette variable avec le mot-clef our. Elle est alors disponible dans tout le script et peut même - sous certaines conditions (cas des modules) - être accédée depuis l'extérieur.

Mis à jour le 5 mai 2005 2Eurocents

Il y a souvent besoin de réaliser un choix entre deux blocs à traiter selon la valeur d'une condition. C'est ce que l'on appelle une alternative.

En Perl, une condition est une expression, constituée de variables, de valeurs, d'opérateurs de test (<,>, ne, !=, le, ge, cmp...) et éventuellement d'opérateurs de combinaison logique (not, and, or, xor). Le tout doit être habilement mis entre parenthèses afin de garantir les associations de tests souhaitées.

Perl met à notre disposition deux types d'alternative :

  • l'instruction if, qui représente l'alternative favorable - quand une condition est remplie ;
  • l'instruction unless, qui représente l'alternative défavorable - quand une condition n'est pas remplie.

La syntaxe est simple :

Code perl : Sélectionner tout
1
2
3
if ( condition ) { 
  # bloc d'instructions à exécuter si la condition est vraie 
}
Pour le cas où l'on souhaite une alternative complète, on peut même faire :

Code perl : Sélectionner tout
1
2
3
4
5
if ( condition ) { 
  # bloc d'instructions à exécuter si la condition est vraie 
} else { 
  # bloc d'instructions à exécuter si la condition est fausse 
}
Et pour les cas de suites d'alternatives imbriquées :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
if ( condition_primaire ) { 
  # bloc d'instructions à exécuter si la condition primaire est vraie 
}  
elsif (nouvelle_condition) { 
  # bloc d'instructions à exécuter si la nouvelle condition est vraie 
  #                                alors que la condition primaire est fausse 
}  
else { 
  # bloc d'instructions à exécuter si la nouvelle condition est fausse 
  #                                alors que la condition primaire est fausse 
}
Il est ainsi possible de cascader les elsif dans chaque condition fausse. L'instruction unless fonctionne exactement comme le if, simplement sa condition est inversée. Ainsi, il est équivalent d'écrire :

Code perl : Sélectionner tout
1
2
3
unless ( condition ) { ... } 
# et  
if ( ! ( condition ) ) { ... }

Mis à jour le 5 mai 2005 2Eurocents

Il est possible en Perl d'utiliser les conditions ternaires si vous souhaitez faire des if/elsif/elsif/else. Son utilisation est pratique du fait qu'on ait moins de lignes de code à écrire, que la visibilité du code peut être meilleure et cela nous oblige à faire un else sous peine de recevoir un message d'erreur.

L'écriture est de la sorte : Condition ? exécution si vrai : exécution si faux;

Rien de mieux qu'un exemple.

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/perl 
use strict; 
use warnings; 
  
my $nombre = 20; 
my $limite = 20; 
my $reponse; 
  
# if/elsif/else 
if ( $nombre < $limite ) { 
  $reponse = "$nombre plus petit que $limite"; 
} 
elsif  ( $nombre > $limite ) { 
  $reponse = "$nombre plus grand que $limite"; 
} 
else { 
  $reponse = "$nombre est identique à $limite"; 
} 
print "if/else/else : $reponse\n";
Nous allons maintenant faire l'équivalent en utilisant les conditions ternaires.

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/perl 
use strict; 
use warnings; 
  
my $nombre = 20; 
my $limite = 20; 
my $reponse; 
  
               # condition            # reponse 
my $reponse2 = $nombre < $limite ? "$nombre plus petit que $limite" 
            :  $nombre > $limite ? "$nombre plus grand que $limite" 
            :                         "$nombre est identique à $limite"; 
print "condition ternaire : $reponse2\n";
Voilà, c'est simple, clair et en plus, cela nous oblige à utiliser l'équivalent de la condition else. Si vous faites juste :

Code perl : Sélectionner tout
my $reponse2 = $nombre < $limite ? "$nombre plus petit que $limite";
vous aurez un message d'erreur Perl de type syntax error at ....

Mis à jour le 20 octobre 2009 djibril

Les alternatives que nous venons de voir sont très utiles mais nécessitent l'ouverture et la fermeture de blocs de codes. Cela peut être fastidieux, juste pour une instruction dont l'exécution est conditionnelle. Perl a donc introduit une expression simplifiée pour l'exécution conditionnelle d'une seule instruction :

Code perl : Sélectionner tout
instruction if (condition);
ou

Code perl : Sélectionner tout
instruction unless (condition);
exécuteront l'instruction indiquée si la condition est vraie (cas du if) ou fausse (cas du unless).

N.B. Bien que Perl donne la possibilité d'écrire votre code comme bon vous semble, il y a quand même des recommandations utiles à respecter.
Ce type d'écriture est recommandé lorsque vous faites appel aux fonctions internes de Perl last, next et redo. Dans les autres cas, il est demandé d'utiliser l'écriture classique. C'est une question de lisibilité améliorée permettant une meilleure maintenance de votre programme.

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
foreach my $case ( @tableau ) { 
	next if ( condition1 ); 
  
	if ( condition2 ) { 
		# action 1 
		# action 2 
	}  
}

Mis à jour le 5 mai 2005 2Eurocents djibril

Lorsque l'on a une même variable à tester dans différentes conditions, pour vérifier les différentes valeurs possibles, il est nécessaire d'utiliser une batterie de if/elsif/else, ce qui peut paraître rapidement fastidieux et peu clair :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
if ( $choix == 0 ) { 
  
  # traitement du 0 
} 
elsif ( $choix == 1 ) { 
  
  # traitement du 1 
} 
elsif ( $choix == 2 ) { 
  
  # traitement du 2 
} 
elsif ( $choix == 3 ) { 
  
  # traitement du 3 
} 
else { 
  
  # traitement par défaut 
}
  • Utilisateurs d'une version de Perl inférieure ou égale à la 5.8

Le mécanisme de la sélection (le switch des programmeurs C, la case des pascalistes et des basicois) n'est malheureusement pas disponible pour ces versions de Perl. Toutefois, devant l'intérêt qu'une telle structure présente, une construction non standard a été ébauchée, et elle sera probablement standardisée pour la version 6 du langage.

En attendant, cette fonctionnalité dépend d'un module (une unité d'extension du langage) qui est présent la plupart du temps lors de l'installation de Perl. Il faut l'utiliser avec précaution car elle n'est pas totalement finalisée et possède encore quelques effets de bord, notamment dans les scripts les plus longs. Cependant, voici une réécriture de la sélection, sans les if :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
use Switch 'Perl6'; 
  
# pour avoir le mécanisme de la sélection conforme à ce que permettra Perl6 
given ($choix) { 
  when 0 { 
  
    # traitement du 0 
  } 
  when 1 { 
  
    # traitement du 1 
  } 
  when 2 { 
  
    # traitement du 2 
  } 
  when 3 { 
  
    # traitement du 3 
  } 
  when /.*/ { 
  
    # traitement par défaut 
  } 
}
C'est un mécanisme à suivre car il réservera de nombreuses (bonnes) surprises.

  • Utilisateurs d'une version de Perl supérieure ou égale à la 5.10

Depuis la version 5.10, vous pouvez utiliser given/when. Exemple de code :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
use feature qw/switch/; 
  
given ($string) { 
  when (/^abc/) { $abc     = 1; } 
  when (/^def/) { $def     = 1; } 
  when (/^xyz/) { $xyz     = 1; } 
  default       { $nothing = 1; } 
} 
  
# Code issu de la documentation de Sébastien Aperghis-Tramoni 
given ($number) { 
  when (42) { say "La Réponse"; } 
  when (56) { say "fer standard"; } 
} 
  
use Regexp::Common qw/net/; 
  
given ($host) { 
  when ("localhost")        { say "adresse locale"; } 
  when (/$RE{net}{IPv4}/)   { say "adresse IPv4"; } 
  when (/$RE{net}{domain}/) { say "FQDN"; } 
  default                   { say "type d'argument inconnu"; } 
}
  • un when réussi termine le given correspondant ;
  • un break permet de sortir du given ;
  • un continue permet d'aller au when suivant ;
  • default est lu si rien d'autre ne correspond.

Dans le core de Perl 5.10 ou plus, le module Switch existe et s'utilise de la façon suivante :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
use Switch; 
  
switch ($string) { 
  case /^abc/ { $abc     = 1; } 
  case /^def/ { $def     = 1; } 
  case /^xyz/ { $xyz     = 1; } 
  else        { $nothing = 1; } 
}

Mis à jour le 5 mai 2005 2Eurocents djibril

Plusieurs formes de parcours de boucles, de répétitions ou d'itérations sont disponibles. Elles sont à adapter en fonction des besoins. Le but est toujours de parcourir un bloc de code tant que certaines conditions sont vérifiées, ou bien un certain nombre de fois, ou bien pour toutes les valeurs d'une liste, comme les fonctions map et grep.

Mis à jour le 5 mai 2005 2Eurocents

Ce sont les boucles qui exigent une condition de sortie. On y trouve les boucles avec une condition permanente :

Code perl : Sélectionner tout
1
2
3
4
while (condition) 
  { 
    # bloc d'instructions 
  }
où le bloc d'instructions est exécuté tant que la condition est vraie. On y trouve aussi les boucles avec une condition terminale :

Code perl : Sélectionner tout
1
2
3
4
until (condition) 
  { 
    # bloc d'instructions 
  }
où le bloc d'instructions est exécuté jusqu'à ce que la condition soit vraie.
Ces deux formes de boucle acceptent aussi une syntaxe abrégée lorsque le bloc d'instructions se réduit à une seule instruction :

Code perl : Sélectionner tout
instruction while (condition);
ou

Code perl : Sélectionner tout
instruction until (condition);

Mis à jour le 5 mai 2005 2Eurocents

Ce sont des boucles pour lesquelles une variable sert à dénombrer les itérations et à arrêter la répétition lorsqu'une valeur donnée est atteinte. La syntaxe est alors :

Code perl : Sélectionner tout
1
2
3
4
for (initialisation ; condition ; incrementation) 
{ 
  # bloc d'instructions 
}
où l'initialisation est l'affectation de valeurs initiales aux variables d'index de boucle ; la condition est la condition d'arrêt de la répétition et l'incrémentation est l'instruction qui altère les variables d'index de boucle à chaque passage. Chacune des trois clauses est optionnelle. L'initialisation peut être faite en dehors de la boucle, la condition et l'incrémentation pouvant être réalisées dans le bloc d'instructions. Par exemple :

Code perl : Sélectionner tout
1
2
3
for ($i=0 ; $i<10 ; $i++) { 
  print "$i\n"; 
}
affiche les valeurs de 0 à 9.

Code perl : Sélectionner tout
1
2
3
for (($i, $j)=(0, 10) ; $i<10 ; ($i++,$j--)) { 
  print "[$i,$j]\n"; 
}
affiche un $i croissant et un $j décroissant. En fait, la syntaxe est équivalente à un :

Code perl : Sélectionner tout
1
2
3
4
5
initialisation 
while (condition) { 
  # bloc d'instructions 
  incrémentation 
}

Mis à jour le 5 mai 2005 2Eurocents

Il est possible de parcourir la totalité des éléments d'une liste, et pas seulement au moyen des instructions map et grep. La fonction each() est destinée aux énumérations de tableaux associatifs. Elle prend une table de hachage comme argument et retourne une clef de cette table. A l'appel suivant, elle retournera la clef suivante. Et ainsi de suite jusqu'à épuisement des clefs. On voit bien qu'intégrée à une boucle while/until ou for, cette fonction peut énumérer tous les éléments d'un hachage. L'autre construction d'énumération très utilisée est la boucle foreach. La syntaxe complète est :

Code perl : Sélectionner tout
1
2
3
foreach $variable ( @liste ) { 
  # bloc d'instructions 
}
Le bloc d'instructions est exécuté pour chaque valeur contenue dans la liste @liste. La variable $variable prendra, à chaque itération, les valeurs successives des éléments de @liste. Il existe aussi une syntaxe abrégée utilisant la variable implicite de contexte $_. Cette variable, interne à Perl permet de simplifier de nombreuses syntaxes. La variable $_ contient, le plus souvent, l'élément en cours de traitement - d'où l'appellation de variable de contexte :

Code perl : Sélectionner tout
1
2
3
4
foreach ( @liste ) { 
  # bloc d'instructions 
  # l'élément en cours est $_ 
}
Un petit exemple supplémentaire, sachant que la fonction rand retourne un nombre flottant pseudo aléatoire dans l'intervalle [0..n], n étant passé en paramètre :

Code perl : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
# liste des sentences pour chaque pétale possible (6 x 10) 
my @marguerite = ( 'je t\'aime', 'un peu', 'beaucoup', 'passionnément', 'à la folie', 'pas du tout' ) x 10; 
  
# Tirage du nombre de pétales, de 0 à 59 
my $i = int( rand(59) ); 
  
# Pour tous les pétales... 
foreach ( 0 .. $i ) { 
  
  # On effeuille la marguerite 
  print $marguerite[$_] . "\n"; 
}

Mis à jour le 5 mai 2005 2Eurocents

Un programme avec un bon algorithme se déroule normalement sans problème. Tous les cas sont prévus dans les alternatives, les boucles sont bien conçues et tout est pour le mieux. Cependant, il arrive que des changements dans les traitements, au cours de la maintenance du code, ou bien des difficultés imprévues de conception, obligent le programmeur à introduire des conditions particulières de rupture des structures de contrôle. Ces ruptures ne sont pas un signe de bonne conception... plutôt le signe qu'une modification, apparemment bénigne qui aurait eu de grosses répercussions sur la structure du code et qu'il a été préférable d'en limiter l'ampleur par un petit traitement localisé.

  • redo est l'instruction de rupture qui permet de reprendre l'itération en cours au début du bloc de code ;
  • next est l'instruction qui permet de passer à l'itération suivante. Elle effectue un saut direct à la fin du bloc de code ;
  • last est l'instruction qui permet d'arriver directement à la fin de la dernière itération. On sort des traitements/boucles et on continue l'exécution du programme aux instructions qui suivent.

Ces ruptures de séquence fonctionnent aussi sur des boucles imbriquées. Dans ce cas, pour savoir de quelle boucle on souhaite rompre la séquence, il faut étiqueter les boucles et préciser l'étiquette à la rupture de séquence :

Code perl : Sélectionner tout
1
2
3
4
5
6
EXTERNE: foreach $i ( 0 .. 10 ) { 
  INTERNE: foreach $j ( 0 .. 10 ) { 
      next EXTERNE if ( ( $i + $j ) > 10 ); 
      print "i=$i - j=$j\n"; 
  } 
}
Dès que la valeur de $j est suffisante pour que ($i+$j) soit supérieur à 10, on passe à la valeur suivante de $i, par passage à l'itération suivante de la boucle EXTERNE. On aurait aussi pu remplacer le next EXTERNE par un last INTERNE, le résultat aurait été le même... mais en Perl, il y a plus d'une façon de le faire !

Mis à jour le 5 mai 2005 2Eurocents

Il existe aussi une instruction goto qui permet de faire un saut dans l'exécution du code, jusqu'à une étiquette donnée (fixée à l'écriture du programme, ou évaluée dynamiquement. Utiliser ce type d'instruction n'est pas vraiment une bonne idée. Le langage étant par ailleurs riche en structures de contrôles et en instructions de ruptures, l'usage de cette instruction peut être carrément néfaste, à la maintenance du code si ce n'est à son exécution.

Mis à jour le 5 mai 2005 2Eurocents

Puisque les sauts sont déconseillés dans le contrôle du flux d'exécution du programme, il existe une structure "idoine" qui permet d'abandonner le bloc courant pour exécuter un autre bloc de code et revenir ensuite à notre point de "digression". C'est la notion de sous-routine, procédure ou fonction. Cela permet d'écrire une seule fois un bloc de code qui sera exécuté à de nombreuses reprises dans un programme, depuis plusieurs endroits différents. Une fonction se déclare avec le mot-clef "sub", suivi du nom de la fonction, suivi du bloc de code à exécuter :

Code perl : Sélectionner tout
1
2
3
sub a_la_trace { 
  print "Tout passage par la fonction est suivi a_la_trace\n"; 
}
Cette fonction s'appelle simplement par son nom, dans tout le code :

Code perl : Sélectionner tout
1
2
3
4
5
print "Début"; 
a_la_trace(); 
print "Milieu"; 
a_la_trace(); 
print "Fin";

Mis à jour le 5 mai 2005 2Eurocents

La fonction ainsi définie peut aussi admettre des paramètres. Perl n'étant pas très strict ni rigide, il peut même laisser le nombre de paramètres des fonctions totalement libre. Une fonction qui admet des paramètres s'appelle en précisant les paramètres entre parenthèses après le nom de la fonction :

Code perl : Sélectionner tout
1
2
3
4
5
print "Début"; 
A_la_trace("Début", "Milieu"); 
print "Milieu"; 
A_la_trace("Milieu", "Fin"); 
print "Fin";
réalise l'appel de A_la_trace en lui passant deux chaînes comme paramètres à chaque fois. Les parenthèses ne sont toutefois pas une obligation, mais elles aident grandement à la lisibilité du code et permettent d'éviter quelques soucis avec la précédence des opérateurs...

Mis à jour le 5 mai 2005 2Eurocents

Lors de l'appel à une fonction, Perl range les paramètres dans une liste spéciale, "@_", interne à la fonction. Cette liste se comporte comme toutes les autres. Il n'est, par contre, pas recommandé de tenter de la modifier. Il est donc possible de récupérer les valeurs de différentes façons :

Code perl : Sélectionner tout
my ($param1, $param2) = @_;
récupère les deux premiers paramètres (@_ est inchangée).

Code perl : Sélectionner tout
my ($param1) = @_;
est équivalent à my $param1 = $_[0];
Code perl : Sélectionner tout
my $param = shift;
récupère le premier paramètre de la liste et le supprime d'icelle. Le nombre de paramètres effectif étant laissé libre, il peut être pratique de le connaître, ne serait-ce que pour effectuer le nombre de shift correct pour récupérer toutes les valeurs. Le nombre de paramètres reçus se trouve simplement par l'évaluation de @_ en contexte scalaire.

Code perl : Sélectionner tout
1
2
3
my $nombre_arguments = @_;  
# ou bien  
my $nombre_arguments = scalar @_;

Mis à jour le 5 mai 2005 2Eurocents

On l'a vu, à la réception dans la fonction, les paramètres sont rangés dans une liste. Si lors de l'appel on a spécifié une liste comme paramètre de la fonction, celle-ci va s'aplatir dans la liste @_. Pour conserver le caractère "liste" des paramètres, il faut passer par la notion de référence, qui sera vue ultérieurement. De même, si l'on souhaite modifier la valeur des paramètres, les références pourront nous aider.

Mis à jour le 5 mai 2005 2Eurocents

Une fonction se termine dans deux cas :

  • la fin du bloc de code de la fonction est atteinte. Retour à l'appelant ;
  • une instruction return est rencontrée. Retour à l'appelant, mais on lui transmet les valeurs qui suivent le mot-clef return.

Les valeurs retournées peuvent être aussi bien un scalaire qu'une liste. Il est donc possible d'avoir des fonctions retournant des listes d'éléments (concept que l'on a finalement déjà rencontré avec map ou grep).

Nous sommes maintenant à peine aguerris mais suffisamment équipés pour aller beaucoup plus loin avec le langage Perl... l'odyssée ne fait que commencer !

Mis à jour le 5 mai 2005 2Eurocents

Perl vous permet de définir une fonction particulière qui sera appelée si l'utilisateur tente d'invoquer une fonction non définie dans le paquetage (l'espace de nom). Cette fonction particulière s'appelle AUTOLOAD. Si elle est appelée, une variable globale au paquetage nommée $AUTOLOAD, qui contiendra le nom de la fonction que l'on a essayé d'appeler, sera créée. Attention, pour utiliser cette variable, il faut la déclarer avec our, on ne peut pas l'utiliser sans la déclarer. Par exemple, si l'on veut signaler que la fonction appelée par l'utilisateur n'existe pas sans pour autant faire boguer le programme, on peut le faire ainsi :

Code perl : Sélectionner tout
1
2
3
4
sub AUTOLOAD { 
	our $AUTOLOAD; 
	print "La fonction $AUTOLOAD n'a pas été définie !"; 
}
Plus utile, si on a un module assez gros que l'on est susceptible d'utiliser dans un programme sans être sûr de le faire, on peut demander à la fonction AUTOLOAD de le faire via require (et non use, ce dernier étant réglé à la compilation et non à l'exécution comme require). Si l'utilisateur tente d'appeler une fonction du module et que ce dernier n'a pas été inclus, la fonction AUTOLOAD l'inclura et appellera la fonction en question sans que l'utilisateur n'ait quoi que ce soit à faire.

Mis à jour le 22 juillet 2007 Woufeil

La fonction AUTOLOAD permet de créer votre propre Shell en quelques lignes :

Code perl : Sélectionner tout
1
2
3
4
5
6
sub AUTOLOAD { 
	my $fonc = our $AUTOLOAD; 
	$fonc =~ s/.*:://; #on enlève le nom du paquetage et les :: 
	system($fonc, @_) #appelle $fonc avec la liste d'arguments passée à AUTOLOAD 
} 
cd (mount) #appelle la fonction système cd en lui passant mount en paramètre

Mis à jour le 22 juillet 2007 Woufeil

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Perl : djibril -