La majorité des livres sont édités par O'Reilly › ~chris › Documents › Perl.pdf · C. Aperghis-Tramoni Perl 6 Documentation. Plain Old Documentation. Documentation perl en

Perl 1C. Aperghis-Tramoni

Perl.

La majorité des livres sontédités par O'Reilly


Le premier programme.

Le premier programme que l'on écrit consiste toujours à écrireun message de bienvenue sur l'écran.

Bonjour tout le monde.

Ecrivons le donc en Perl.coruscant% cat prog.pl#!/usr/bin/perlprint "Bonjour tout le monde.\n";coruscant% chmod u+x prog.plcoruscant% prog.plBonjour tout le monde.coruscant%


Le fichier Perl.

Première ligne du fichier :

#!/usr/bin/perl

coruscant% cat prog.pl#!/usr/bin/perl$x = $y;print "Hello World\n";coruscant% chmod u+x prog.plcoruscant% prog.plHello Worldcoruscant%

coruscant% cat prog.pl#!/usr/bin/perl -w$x = $y;print "Hello World\n";coruscant% chmod u+x prog.plcoruscant% prog.pl# Name "main::x" used only once: possible typo. File prog.pl; Line2# Name "main::y" used only once: possible typo. File prog.pl; Line2Hello Worldcoruscant%


Option : -v.

Pour connaître le numéro de version. coruscant% perl -vThis is perl, version 5.004

Copyright 1987-1997, Larry WallMacintosh port Copyright 1991-1998, Matthias Neeracher

Perl may be copied only under the terms of either the Artistic Licenseor the GNU General Public License, which may be found in the Perl 5.0source kit.coruscant%


Option :-V.coruscant% perl -VSummary of my perl5 (5.0 patchlevel 5 subversion 3) configuration: Platform: osname=solaris, osvers=2.6, archname=sun4-solaris uname='sunos 5.6 generic_105181-06 sun4u sparc sunw,ultra-1 ' hint=recommended, useposix=true, d_sigaction=define usethreads=undef useperlio=undef d_sfio=undef Compiler: cc='gcc', optimize='-O', gccversion=2.8.1 cppflags='-I/usr/local/include' ccflags ='-I/usr/local/include' stdchar='unsigned char', d_stdstdio=define, usevfork=false intsize=4, longsize=4, ptrsize=4, doublesize=8 d_longlong=define, longlongsize=8, d_longdbl=define, longdblsize=16 alignbytes=8, usemymalloc=y, prototype=define Linker and Libraries: ld='gcc', ldflags =' -L/usr/local/lib' libpth=/usr/local/lib /lib /usr/lib /usr/ccs/lib libs=-lsocket -lnsl -ldb -ldl -lm -lc -lcrypt libc=/lib/libc.so, so=so, useshrplib=false, libperl=libperl.a Dynamic Linking: dlsrc=dl_dlopen.xs, dlext=so, d_dlsymun=undef, ccdlflags=' ' cccdlflags='-fPIC', lddlflags='-G -L/usr/local/lib'

Characteristics of this binary (from libperl): Built under solaris Compiled at Apr 3 1999 00:26:08 %ENV: PERLLIB="/usr/local/lib/perl5/5.00503:/usr/local/lib/mirror" @INC: /usr/local/lib/perl5/5.00503 /usr/local/lib/mirror /usr/local/lib/perl5/5.00503/sun4-solaris /usr/local/lib/perl5/5.00503 /usr/local/lib/perl5/site_perl/5.005/sun4-solaris /usr/local/lib/perl5/site_perl/5.005coruscant%


Documentation.

Plain Old Documentation.

Documentation perl en ligne.Le format POD a été défini par Larry Wall.

C:\Cat> perldoc -f pop pop ARRAY pop Pops and returns the last value of the array, shortening the array by one element. Has an effect similar to

$ARRAY[$#ARRAY--]

If there are no elements in the array, returns the undefined value (although this may happen at other times as well). If ARRAY is omitted, pops the "@ARGV" array in the main program, and the "@_" array in subroutines, just like "shift".C:\Cat>


Documenter un programme.coruscant% cat com.pl=pod

=head1 AUTEUR :

C. Aperghis-Tramoni

=head1 DESCRIPTION :

Ce programme Imprime "Bonjour tout le monde".

=head1 NOM DU PROGRAMME

hello.pl

=head1 APPEL.

Sous Unix : hello.pl

Sous Windows : perl hello.pl

=cut

#!/usr/bin/perl

=pod

Voici le pogramme.

=cut

print "Bonjour tout le monde.\n";coruscant%


Exécution.

coruscant% perldoc com.plAUTEUR : C. Aperghis-Tramoni

DESCRIPTION : Ce programme Imprime "Bonjour tout le monde".

NOM DU PROGRAMME hello.pl

APPEL. Sous Unix : hello.pl

Sous Windows : perl hello.pl

Voici le pogramme.

=cut

print "Bonjour tout le monde.\n";coruscant% perl com.plBonjour tout le monde.coruscant%


Les commandes de perldoc.

Identificateurs du format POD

=pod Début de code POD.=cut Fin de code POD.=head1 Texte Construit un titre de niveau 1.=head2 Texte Construit un titre de niveau 2.=over N Début de liste.=item Text Nouvel élément de liste.=back Fin de liste.=begin X Début de section spécifique au format X (html par exemple).=end X Fin de section spécifique au format X.


Séquences de mise en forme.

Liste des séquences de mise en forme de POD

I<texte> Italique (variables et les mises en valeur).B<texte> Gras (options de ligne de commande et les programmes).S<texte> Le texte contient des espaces insécables.C<code> Du code littéral.L<nom> Un lien (référence croisée) vers une page de manuel.L<nom/ident> Idem, vers un élément de la page de manuel.L<nom/"sec"> Idem, vers une section de la page de manuel.L</"section"> Lien vers une section de cette page de manuel.F<fichier> Nom de fichier.X<index> Entrée d'index.Z<> Caractère de taille nulle.E<entité> Un caractère accentué des entités HTML (E<Agrave> : à).E<lt> Le caractère <.E<gt> Le caractère >.


Types de données.

Types de base :

Scalaires.Listes.Hashes.

Scalaires :Chaînes.Nombres.Booléens.

En fonction du contexte.

Le type est déterminé par le premier caractère.

$ Scalaire. @ Liste. % Hash.

Nom : caractères (Chiffres, lettres et blanc souligné)

$nom_de_scalaire@nom_de_liste%nom_de_hash

Perl distingue les lettres minuscules des lettres majuscules..


Opérations arithmétiques.

# positionner $a à 32.$a = 32;

# positionner $b à $a + 6.$b = $a + 6;

# positionner $b à $b * 2.$b = $b * 2;

# positionner $a à 52, puis $c à $a + 10.# Autrement dit $c = 62.$c = 10 + ($a = 52);

# positionner simultanément $d et $c à 23.$d = ($c = 23);$d = $c = 23;

Toute variable non définie estpositionnée par défaut à 'undef'.

undef = 0 (zéro) pour un scalaire.undef = "" (chaîne vide) pour une chaîne.

coruscant% cat prog.pl$b = $a + 6;print "$b\n";coruscant% prog.pl6coruscant%


Opérateurs.

2 + 3 Addition, résultat : 55.8 - 3.3 Soustraction, résultat : 2.54 * 11 Multiplication, résultat : 4465 / 5 Division : résultat : 1310.5 / 0.5 Division : résultat : 2110 / 6 Division : résultat : 1.66666662 ** 4 Exponentiation, résultat : 1610 % 4 Modulo, résultat : 2

< plus petit que<= inférieur ou égal= = égal>= supérieur ou égal> plus grand que!= différent

Logic

$racine_carree = sqrt ($x);Fonctions arithmétiques.$logarithme_neperien = log ($x);$exponentielle_x = exp ($x);$valeur_absolue = abs ($x);$aleatoire = rand ($valeur);$entier = int ($nombre_flottant);$valeur_ascii = ord ($caractere);$caractère = chr ($valeur_ASCII);


Octal et hexadécimal.

coruscant% cat prog.pl #!/usr/bin/perl$octal = 047;print "Valeur decimale de la valeur octale 47 : $octal.\n";$hexa = 0xAF;print " Valeur decimale de la valeur hexadecimale AF : $hexa.\n";coruscant% prog.plValeur decimale de la valeur octale 47 : 39.Valeur decimale de la valeur hexadecimale AF : 175coruscant% cat err.pl#!/usr/bin/perl$octal = 084;print " Valeur decimale de la valeur octale 84 : $octal.\n";coruscant% err.pl# Illegal octal digit, at end of lineFile 'Untitled'; Line 1# Execution of Untitled aborted due to compilation errors.coruscant%


Assignement.

# Operation sans assignement.$a = $a + 5;# Même operation avec assignement.$a += 5;# Operation sans assignement.$a = $a * 5;# Même operation avec assignement.$a *= 5;# Operation sans assignement. $a = $a ** 3;# Même operation avec assignement.$a **= 3;# Operation sans assignement.$chaine = $chaine . " fin.";# Même operation avec assignement.$chaine .= " fin.";

Les liges suivantes sont parfaitement valides :$a = 5;$b = ($a += 9);

$a et $b sont tous deux positionnés à 14.


Auto incrément, auto décrément.Opérateur ++ ou - - $a = $a + 1;

$a += 1;

++$a;

$a++;

$a = $a - 1;

$a -= 1;

--$a;

$a--;

Préfixé par la gauche.Postfixé par la droite.

Un auto incrément (auto décrément) préfixé, est effectué avant l'opération.

$c = 10;$d = ++$c;

$c et $d prennent tous les deux la valeur 11.

Un auto incrément (auto décrément) postfixé, est effectué après l'opération.

$c = 10;$d = $c++;$d prend la valeur 10 et $c prend la valeur 11.

Les opérandes doivent impérativement être des scalaires.Il n'est pas autorisé d'écrire : ++2 (pour tenter d'obtenir 3)Il est interdit d'écrire : ++($a+$b) (pour avoir la somme de $a et $b incrémentée de 1).


Opérateurs bit à bit.

Une valeur peut être considérée comme une suite de bits..

$a & $b : 'et' logique entre les bits de $a et les bits de $b. $a | $b : 'ou' logique entre les bits de $a et les bits de $b. $a ^ $b : Exclusion mutuelle entre les bits de $a et les bits de $b. ~$a : Complément des bits de $a. $a >> $b : Décalage à droite des bits de $a de $b positions. $a << $b : Décalage à gauche des bits de $a de $b positions.

Par exemple, pour créer la valeur 130.$a = 128 + 2 = 27 + 21 = (1 << 7) | (1<<1)

Pour effectuer la division euclidienne de $a par 2.$q = $a >> 1;$r = $a & 1;


Opérateur "Spaceship" <=>

Permet d'établir une relation entre deux nombres.Indispensable pour les opérations de tri.

$x = $a <=> $b;$x vaut 1 si $a > $b.$x vaut 0 si $a = $b.$x vaut -1 si $a < $b.

coruscant% cat prog.pl #!/usr/bin/perl$a = 10; $b = 20;$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n";$a = 10; $b = 10;$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n";$a = 20; $b = 10;$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n"; coruscant% prog.plComparer 10 et 20 donne -1.Comparer 10 et 10 donne 0.Comparer 20 et 10 donne +1.coruscant%


Règles de détermination des types.

Déterminer ce qui doit être fait.

$var1 opérateur $var2;

function ($param);Vérifier quel est le type du paramètre sur lequel la fonction doit travailler.Si nécessaire, transformer $param dans le type requis.

Tester quel est le type qu'attend l'opérateur, tant à droite qu'à gauche.Si nécessaire, transformer $var1 et $var2 dans le type requis.

Lors d'un appel de fonction.

Dans une expression.


Exemples.

coruscant% cat prog.pl #!/usr/bin/perl$x = "72";$y = "25";$z = $x . $y;$r = sqrt ($z);print ("La racine carree de $z est egale a $r.\n");coruscant% prog.plLa racine carree de 7225 est egale a 85.coruscant%

coruscant% cat prog.pl #!/usr/bin/perl#!/usr/bin/perl$x = 7;$y = ord ($x);print ("La valeur ASCII de $x est egale a $y.\n");$z = chr($y);print ("Le caractere code $y en ASCII est $z.\n");coruscant% prog.plLa valeur ASCII de 7 est egale a 55.Le caractere code 55 en ASCII est 7.coruscant%


Bloc.

Un bloc est un ensemble d'instructions situé entre une accolade ouvranteet une accolade fermante.

{ Instruction 1; Instruction 2; . . . .; Instruction n; }

Les instructions sont exécutées en séquence de la première à la dernière.

Chaque instruction doit se terminer par un point virgule (;).

Un bloc peut être ouvert n'importe où dans le programme.


Instruction conditionnelle.

IF / THEN / ELSEif (expression) { instruction-vraie_1; instruction-vraie_2; instruction-vraie_3;} else { instruction-fausse_1; instruction-fausse_2; instruction-fausse_3;}

UNLESS / THEN / ELSEunless (expression) { instruction-fausse_1; instruction-fausse_2; instruction-fausse_3;} else { instruction-vraie_1; instruction-vraie_2; instruction-vraie_3;}


Boucles.

WHILEwhile (expression) { instruction_1; instruction_2; instruction_3;}

UNTILuntil (expression) { instruction_1; instruction_2; instruction_3;}

On évalue la valeur de 'expression'.

Si le résultat de cette évaluation est'vrai' alors le bloc est exécuté.

Le bloc cesse de s'exécuter aussitôtque l'évaluation de 'expression'retourne la valeur 'faux'.

On évalue la valeur de 'expression'.

Si le résultat de cette évaluation est'faux' alors le bloc est exécuté.

Le bloc cesse de s'exécuter aussitôtque l'évaluation de 'expression'retourne la valeur 'vrai'.


Exemple.

coruscant% cat prog.pl #!/usr/bin/perl$compteur = 0;while ($compteur++ <=5) { print ("Value : $compteur\n");}coruscant% prog.plValue : 1Value : 2Value : 3Value : 4Value : 5Value : 6coruscant%


Le bloc continue.

Dans une boucle "while", le bloc "continue" est systématiquement exécutéjuste avant que la condition soit à nouveau évaluée.

Il sera exécuté même si une fin prématurée du bloc (last ou next) seprésente.

coruscant% cat prog.pl #!/usr/bin/perlwhile ($x++ < 5) { print ("Valeur de x : $x.\n");} continue { print (" On est dans le bloc continue.\n");}coruscant% prog.plValeur de x : 1. On est dans le bloc continue.Valeur de x : 2. On est dans le bloc continue.Valeur de x : 3. On est dans le bloc continue.Valeur de x : 4. On est dans le bloc continue.Valeur de x : 5. On est dans le bloc continue.coruscant%


La boucle for.

FORfor (initial;test;increment) { instruction_1; instruction_2; instruction_3;}

initial;while (test) { instruction_1; instruction_2; instruction_3; increment;}

1 - "initial" sert généralement à attribuerla valeur de départ à la variabled'itération.

2 - "test" sera évalué comme un résultatbooléen, c'est à dire 'vrai' ou 'faux'.

Si le résultat est "vrai" le bloc d'itérationest exécuté, puis l'incrément est évalué.Cette opération est généralement unincrément de la variable d'itération.

Puis, on recommence en 2

Si le résultat est faux, alors c'est le blocsuivant qui sera exécuté.

Equivalent à :

La variable estincrémentée à lafin de la boucle.

coruscant% cat prog.pl #!/usr/bin/perl for ($i=1; $i<=10; $i++) {print "$i ";}coruscant% prog.pl1 2 3 4 5 6 7 8 9 10coruscant%


Fonctions defined() et undef().

Elles permettent de tester si une variable a été (ou pas) définie.

coruscant% cat prog.pl #!/usr/bin/perlprint "Test de la fonction 'define'.\n";$retour = defined($a);if ($retour ne ""){ print "La variable \$a est definie.\n"} else { print "La variable \$a est indefinie.\n"}print ("\nTest de la fonction 'undef'.\n");$retour = undef($a);if ($retour ne ""){ print ("La variable \$a est definie.\n")} else { print ("La variable \$a est indefinie.\n")}coruscant% prog.plTest de la fonction 'define'.La variable $a est indefinie.

Test de la fonction 'undef'.La variable $a est indefinie.coruscant%


Chaînes.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour"; $b = "Monde.";$c = "$a $b";print "Resulat : $c\n";coruscant% prog.pl Resulat : Bonjour Monde.coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour";$c = '$a Monde';print "Resulat : $c\n";coruscant% prog.pl Result : $a Monde.coruscant%

(") Activation du mécanisme de substitution.

(') Désactivation du mécanisme de substitution


Concaténation.

Concaténation :

"Bonjour" . "a" . "tous" donne "Bonjouratous""Bonjour" . " " . " Monde" donne "Bonjour Monde""Hello" . "\n" donne "Hello\n"

Opération Scalaire ChaîneEgal = = eq

Différent ! = ne

Inférieur < lt

Supérieur > gt

Inférieur ou égal <= le

Supérieur ou égal >= ge

Scalaire <-> chaîneLe conversion est automatique en fonction de l'opération.

7 lt 30 est faux (comparaison effectuée sur les chaînes.)7 < 30 est vrai (comparaison effectuée sur les nombres.)


Mélange de types.

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "128";$nombre = 211;$somme = $chaine * $nombre;print "Le produit de la chaine $chaine\n";print "Et du scalaire $nombre\n";print "Donne : $somme\n";coruscant% prog.plLe produit de la chaine 128Et du scalaire 211Donne : 27008coruscant%

coruscant% cat prog.pl #!/usr/bin/perl$nb1 = 1234;$nb2 = 5678;$chaine = $nb1 . $nb2;print "Resultat : $somme\n";coruscant% prog.plDonne : 12345678coruscant%


Multiplication de chaînes

C'est l'opérateur 'x'

"Chris." x 3 donne "Chris.Chris.Chris.""Chris-" x (6 - 2) donne " Chris- Chris- Chris- Chris-"(3 + 9) x 5 donne "1212121212"Explication :L'évaluation de : (3 + 9) donne 12.L'opération implique une chaîneet un scalaire.La chaîne doit se présenter à gaucheLa valeur 12 devient donc la chaîne"12"l'opération peut alors être effectuée.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Chris." x 3;$b = "Chris-" x (6 - 2);$c = (3 + 9) x 5;print "a = $a\n";print "b = $b\n";print "c = $c\n";coruscant% prog.pl a = Chris.Chris.Chris.b = Chris-Chris-Chris-Chris-c = 1212121212coruscant%


Fonctions sur les chaînes.

$ch = lc ($ch)Force tous les caractères en minuscule.

$a = lc ("ABCD");$a sera alors "abcd".

$ch = lcfirst ($ch) Force le premier caractère en minuscule.

$a = lcfirst ("ABCD");$a sera alors "aBCD".

$a = uc ($ch) Force tous les caractères en majuscule.

$a = uc ("abcd");$a sera alors "ABCD".

$ch = ucfirst ($ch) Force le premier caractère en majuscule.

$a = lcfirst ("abcd");$a sera alors "Abcd".

coruscant% cat prog.pl #!/usr/bin/perl$a = lc ("ABCD");print "resultat 1 : $a\n";$b = lcfirst ("ABCD");print "resultat 2 : $a\n";$b = uc ("abcd");print "resultat 3 : $a\n";$b = ucfirst ("ABCD");print "resultat 4 : $a\n";coruscant% prog.plresultat 1 : abcd resultat 2 : aBCDresultat 3 : ABCDresultat 1 : Abcd coruscant%


La fonction substr().

Cette fonction permet d'extraire une sous chaîne d'une chaînede référence dans laquelle est repérée par son emplacement etsa longueur.

Forme générale :

$x = substr ($chaine,$debut,$longueur);

La position de début commence à 0 pour le premier caractère.La longueur indique le nombre de caractères à extraire à partir de cetemplacement.


Exemples.

coruscant% cat prog.pl#!/usr/bin/perl $chaine = "Departement d'Informatique, Universite de la Mediterranee";$debut = 5;$longueur = 6;$x = substr($chaine,$debut,$longueur);print "Valeur de x : $x\n";coruscant% prog.pl Valeur de x : tementcoruscant%

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "Departement d'Informatique, Universite de la Mediterranee";$debut = 34; $longueur = 1000;$x = substr($chaine,$debut,$longueur);print "Valeur de x : $x\n";coruscant% prog.pl Valeur de x : site de la Mediterraneecoruscant%

La longueur spécifiée peut dépasser la fin de la chaîne de référence.


Application amusante.

coruscant% cat prog.pl #!/usr/bin/perl$exp = 0;while ($exp < 10) {print "10 ^ $exp est egal a ";$puiss = substr("10000000000",0,(++$exp));print "$puiss\n";}coruscant% prog.pl 10 ^ 0 est egal a 110 ^ 1 est egal a 1010 ^ 2 est egal a 10010 ^ 3 est egal a 100010 ^ 4 est egal a 1000010 ^ 5 est egal a 10000010 ^ 6 est egal a 100000010 ^ 7 est egal a 1000000010 ^ 8 est egal a 10000000010 ^ 9 est egal a 1000000000coruscant%

Calculer les 9 premières puissances de 10.


Particularités.

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "Departement d'Informatique, Universite de la Mediterranee";$debut = -12; $longueur = 6;$x = substr($chaine,$debut,$longueur);print "Valeur de x : $x\n";coruscant% prog.pl Valeur de x : Meditecoruscant%

La valeur de l'emplacement peut être négative.Le décompte est alors fait à partir de la fin de la chaîne de référence.

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "Departement d'Informatique, Universite de la Mediterranee";$debut = 28;$x = substr($chaine,$debut);print "Valeur de x : $x\n";coruscant% prog.pl Valeur de x : Universite de la Mediterranee coruscant%

Si la longueur est omise, la sous chaîne est considérée comme allantjusqu'à la fin de la chaîne de référence.


Substitution de sous chaînes.

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "Departement d'Informatique, Universite Aix Marseille II";$debut = 39; $longueur = 16;print "La chaine :\n$chaine\n";substr($chaine,$debut,$longueur) = "de la Mediterranee";print "Est devenue :\n$chaine";coruscant% prog.pl La chaine :Departement d'Informatique, Universite Aix Marseille IIEst devenue :Departement d'Informatique, Universite de la Mediterraneecoruscant%

La fonction substr() peut apparaître à gauche d'un signe d'affectation.Dans ces conditions, il y a substitution de la sous chaîne par lavaleur contenue dans la partie droite de l'affectation.


Substitution de sous chaînes.

coruscant% cat prog.pl #!/usr/bin/perl$chaine = "Departement d'Informatique, Universite Aix Marseille II";$debut = -16; $longueur = 16;print "La chaine :\n$chaine\n";substr($chaine,$debut,$longueur) = "de la Mediterranee";print "Est devenue :\n$chaine";coruscant% prog.pl La chaine :Departement d'Informatique, Universite Aix Marseille IIEst devenue :Departement d'Informatique, Universite de la Mediterraneecoruscant%

Dans ce cas aussi, la valeur de l'emplacement peut être négative.Si on désire que le décompte s'effectue à partir de la fin de la chaînede référence.


Caractères spéciaux.

\n Nouvelle ligne.\r Retour en début de ligne.\t Tabulation.\f Nouvelle page.\b Retour arrière d'un caractère.\v Tabulation verticale.\a Sonnerie.\e Escape.

\007 Valeur octale (007 = Sonnerie).\X7f Valeur hexadécimale (7f = Effacement).\cZ Caractère de contrôle (ctrl Z).\\ Anti slash.\" Double quote.\l Positionne le caractère suivant en minuscule.\L Départ de positionnement en minuscule.\u Positionne le caractère suivant en majuscule.\U Départ de positionnement en majuscule.\E Termine \U ou \L


Les délimiteurs.

On considère souvent les délimiteurs comme des constantes alors que,en Perl ils ont plutôt tendance à se comporter comme des opérateurs.

Perl propose ainsi des fonctions permettant de mettre en évidence cettecaractéristique.

Délimiteurcourant

Délimiteurgénérique Signification Interpolation

'xxx' q(xxx) Constante Non"xxx" qq(xxx) Constante Oui`xxx` qx(xxx) Commande Oui

(xx,yy,zz) qw(xx,yy,zz) liste Non


Exemples.

coruscant% cat prog.pl#!/usr/bin/perl$x = "Bonjour";$y = q($x tout le monde.);$z = qq[$x tout le monde.];@l = qw{$x tout le monde.};print ("\$x = $x\n");print ("\$y = $y\n");print ("\$z = $z\n");foreach (@l) { print ("\@l[",$i++,"] = $_\n");}coruscant% prog.pl$x = Bonjour$y = $x tout le monde.$z = Bonjour tout le monde.@l[0] = $x@l[1] = tout@l[2] = le@l[3] = monde.coruscant%


Les chaînes "ici même".Aussi appelées "Here Documents".L'opérateur "here document" se présente comme suit :

<<chaine;Toutes les lignes qui se trouvent << et la chaîne spécifiée sont convertiesen une chaîne qui est affectée à une variable.

La manière dont la transformation est effectuée dépend des éventuelscaractères de ponctuation qui entourent l'identifiant de fin.

<<chaine ou <<"chaine" valide le mécanisme de substitution.<<'chaine' invalide le mécanisme de substitution..

coruscant% cat prog.pl#!/usr/bin/perlprint <<FIN;Bonjour a touset a toutes....FINcoruscant% prog.plBonjour a touset a toutes....

coruscant%


Autre exemple.coruscant% cat prog.pl#!/usr/bin/perl$a = <<FIN;Bonjour a touset a toutes....FIN$b = <<;Ici,Tout un chacunSera le bienvenu.

print $a,$b;coruscant% prog.plBonjour a touset a toutes....Ici,Tout un chacunSera le bienvenu.

coruscant%

Attention à la ligne blanche.


L'opérateur chop().

chop ( ) Retire le dernier caractère d'une chaîne de caractères.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour Monde.";chop ($a);print "a = $a\n";coruscant% prog.pl a = Bonjour Mondecoruscant% cat prog.pl$a = 1.25;chop ($a);print "a = $a\n"coruscant% prog.pla = 1.2coruscant%

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour Monde.";$b = chop ($a);print "a = $a\n";print "b = $b\n";coruscant% prog.pla = Bonjour Mondeb = .coruscant%

En tant que fonction.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour Monde.";$a = chop ($a);print "a = $a\n";coruscant% prog.pla = .coruscant%

Attention au piège.


L'opérateur chomp().

Identique à chop(),Mais ne retire la dernier caractère que si ce caractèreest effectivement un \n.

En fait, il s'agit d'une comparaison avec le contenude la variable prédéfinie qui contient en permanencele séparateur de ligne ($/).Si elle n'a pas été modifiée, cette variable contient lecaractère standard "\n"

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour Monde.\n";$b = chomp ($a);print "a = $a\n";print "b = $b\n";coruscant% prog.pla = Bonjour Monde.b =

coruscant%

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour Monde.";$b = chomp ($a);print "a = $a\n";print "b = $b\n";coruscant% prog.pla = Bonjour Monde.b = coruscant%


Lecture d'information.

$a = <STDIN>Lecture d'une chaîne de caractères sur le clavier (\n compris).

Pour retirer le \n :$a = <STDIN>;chomp ($a);

Ou de manière plus simple.

chomp ($a = <STDIN>);

Lecture :


Lecture.

Lecture d'une suite de lignes.

Lecture depuis l'entrée standard : $a = <STDIN>;

coruscant% cat prog.pl #!/usr/bin/perlwhile ($a = <STDIN>) { chomp ($a); print "Line : $a\n";}print "Fin du programme."; coruscant% prog.plline 1Line : line 1line 2Line : line 2<ctrl>DFin du programme.coruscant%


Lecture.

coruscant% cat prog.pl

#!/usr/bin/perlwhile (<STDIN>) {# Equivalent : while ($_ = <stdin>)chomp; # Equivalent : chomp($_) print "Line : "; print; # Equivalent : print "$_" print "\n";}print " Fin du programme.";coruscant% prog.plline 1Line : line 1line 2Line : line 2<ctrl>DFin du programme.coruscant%

Utilisation de la variable scalaire prédéfinie $_.


La fonction print().

Dans Perl, toute procédure est aussi une fonction.Ce qui signifie que toute action retourne une valeur.Généralement, la valeur qui est retournée est :

"vrai" Tout s'est bien passé."faux" Il y a eu un problème.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour";$retour = print "$a \n\n";print "Code de retour : $retour\n"; coruscant% prog.plBonjour

Code de retour : 1coruscant%


La fonction print().

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour";$retour = print (2*10),"$a\n";print "\nCode de retour : $retour\n";coruscant% prog.pl20Code de retour : 1coruscant%

La chaîne "$a\n" a été ignorée.Aucune erreur n'est détectéeni à la compilation, ni à l'exécution.

coruscant% cat prog.pl #!/usr/bin/perl$a = "Bonjour";# Avec les parentheses.$ret = print ((3*10)," $a \n");print "\nCode de retour: $ret\n";$a = "Ciao";# Sans parentheses.$ret = print 5*10," $a \n";print "\nCode de retour : $ret\n";coruscant% prog.pl30 Bonjour

Code de retour : 150 Ciao

Code de retour : 1coruscant%


Quelques exercices.1 - Lire une information et l'imprimer deux fois sur la même ligne séparée par un tiret.

#!/usr/bin/perl$info = <STDIN>;chomp ($info);print ("$info - $info\n");

2 - Lire une information et l'imprimer deux fois sur deux lignes différentes#!/usr/bin/perl$info = <STDIN>;print ("$info$info\n");

3 - Lire deux informations et les imprimer sur la même ligne séparées par un tiret. #!/usr/bin/perlchomp($info1 = <STDIN>);$info2 = <STDIN>;print ("$info1 - $info2");

4 - Lire deux informations et n'imprimer que la seconde.#!/usr/bin/perl$info = <STDIN>;$info = <STDIN>;print ("$info");

5 - Lire deux informations et les imprimer en ordre inverse sur la même ligne séparées par un tiret.

#!/usr/bin/perl$info1 = <STDIN>;chomp($info2 = <STDIN>);print ("$info2 - $info1");


L'opérateur "cmp".

Identique à <=> (spaceship) mais destiné aux chaînes.Majoritairement utilisé pour les tris.

$x = $a cmp $b;$x vaut -1 si la chaîne $a précède la chaîne $b.$x vaut 0 si les deux chaînes sont identiques.$x vaut +1 si la chaîne $a suit la chaîne $b.

coruscant% cat prog.pl #!/usr/bin/perl$a = "abc"; $b = "def";$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n";$a = "xyz"; $b = "xyz";$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n";$a = "xyz"; $b = "abc";$retour = $a <=> $b;print "Comparer $a et $b donne $retour.\n"; coruscant% prog.plComparer abc et def donne -1.Comparer xyz et xyz donne 0.Comparer xyz et abc donne +1.coruscant%


Listes. $ : Scalaires.@ : Listes.

# positionne un élément à 100.$liste[$i+2]=100;

# Initialisation de la liste.@liste = (1, 2, 3, 4, 5, 6);

# Une liste vide.@vide = ();

# Copie la liste @A dans la liste @B.@B = @A

# crée @X comme sous liste de @Y.@X = @Y [$i, , $i+3,21];

$#A est la valeur de l'indice le plus élevé de la liste @A.

Les indices partent de la valeur 0 : $A[0] jusqu'à $A[$#A]

Les indices négatifs partent de la fin de la liste.$liste[-1] étant le dernier élément de la liste.


Le contexte.

Pour comprendre le fonctionnement de Perl, il faut toujoursgarder à l'esprit que le langage réagit en fonction du contextedans lequel on travaille.

Le changement de contexte répond à des règles très strictes.Il est par ailleurs possible de contraindre une expression dansun contexte donne

coruscant% cat prog.pl #!/usr/bin/perl$x = "Bonjour";$y = $x;$z = () = $x;print ("\$x = $x\n");print ("\$y = $y\n");print ("\$z = $z\n");coruscant% prog.pl$x = Bonjour$y = Bonjour$z = 1coruscant%


Quelques exemples.

@a=(1,2,3); print "a = @a"; a = 1 2 3

Programme Résultats

$i=1;@a=($i,10); print "a = @a"; a = 1 10

@a=("Chris",14.5); print "a = @a"; a = Chris 14.5

@a=(1..5); print "a = @a"; a = 1 2 3 4 5

$i=10;$j=5;@a=($i+$j,$i-$j); print "a = @a"; a = 15 5

@a=(1.5 .. 5.8); print "a = @a"; a = 1 2 3 4 5

@a=(1.5..5.5); print "a = @a"; a = 1 2 3 4 5

$i=1;$j=8;@a=($i..$j); print "a = @a"; a = 1 2 3 4 5 6 7 8

@a=(1..3,10,11); print "a = @a"; a = 1 2 3 10 11


Travail sur les listes.

coruscant% cat prog1.pl#!/usr/bin/perl@list1 = (1,2,3,4,5,6,7,8,9);@list2 = @list1;print "Contenu de list2 :\n@list2";coruscant% prog1.plContenu de list2 :1 2 3 4 5 6 7 8 9coruscant%

coruscant% cat prog2.pl #!/usr/bin/perl@list1 = (1,2,3,4,5,6,7,8,9);@list1 = 1;print " Contenu de list1 :\n@list1"; coruscant% prog2.plContenu de list1 :1coruscant%



coruscant% cat prog3.pl#!/usr/bin/perl@list1 = (4,5,6);@list2 = (1,2,3,@lis1,7,8,9);print " Contenu de list2 :\n@list2";coruscant% prog3.plContenu de list2 :1 2 3 4 5 6 7 8 9coruscant%

coruscant% cat prog4.pl#!/usr/bin/perl@list1 = ("Un","Deux");@list2 = ("Zero",@list1);print " Contenu de list2 :\n@list2";coruscant% prog4.plContenu de list2 :Zero Un Deuxcoruscant%



coruscant% cat prog5.pl#!/usr/bin/perl@list1 = ("Un","Deux");@list2 = (@list1,"Trois");print "Contenu de list2 :\n@list2";coruscant% prog5.plContenu de list2 :Un Deux Troiscoruscant%

coruscant% cat prog6.pl#!/usr/bin/perl($a,$b,$c) = (1,2,3);print ("a = $a, b = $b, c = $c");coruscant% prog6.pla = 1, b = 2, c = 3coruscant%



coruscant% cat prog7.pl#!/usr/bin/perl$a = "Premier"; $b = "Segond";($a,$b) = ($b,$a);print ("a = $a; b = $b");coruscant% prog7.pla = Segond; b = Premiercoruscant%

coruscant% cat prog8.pl#!/usr/bin/perl$a = 1;$b = 2;$c = 3;($d,@list) = ($a,$b,$c);print ("d = $d - list = @list\n");coruscant% prog8.pld = 1 - list = 2 3coruscant%



coruscant% cat prog9.pl#!/usr/bin/perl@list = (0,1,2,3,4,5);($d,@list) = @list;print ("d = $d - list = @list\n");coruscant% prog9.pld = 0 - list = 1 2 3 4 5coruscant%

coruscant% cat prog10.pl#!/usr/bin/perl@list = (0,1,2,3,4,5);$l = @list;print ("Longueur = $l\n");print ("list = @list\n");coruscant% prog10.plLongueur = 6list = 0 1 2 3 4 5coruscant%



coruscant% cat prog11.pl#!/usr/bin/perl@list = (0,1,2,3,4,5);($a) = @list;print ("a = $a - list = @list\n");coruscant% prog11.pla = 0 - list = 0 1 2 3 4 5coruscant%

coruscant% cat prog12.pl#!/usr/bin/perl@list2 = (@list1 = (0,1,2,3,4,5));print ("list1 = @list1\n");print ("list2 = @list2\n");coruscant% prog12.pllist1 = 0 1 2 3 4 5list2 = 0 1 2 3 4 5coruscant%



coruscant% cat prog13.pl#!/usr/bin/perl@list2 = @list1 = (0,1,2,3,4,5);print ("list1 = @list1\n");print ("list2 = @list2\n");coruscant% prog13.pllist1 = 0 1 2 3 4 5list2 = 0 1 2 3 4 5coruscant%

coruscant% cat prog14.pl#!/usr/bin/perl@list = (100,101,102,103);$b = $list[1];$list[2] += 100;print ("list : @list\n");print ("b = $b\n");coruscant% prog14.pllist : 100 101 202 103b = 101coruscant%



coruscant% cat prog15.pl#!/usr/bin/perl@list = (100,101,102,103);print ("-> @list[1,3]\n");coruscant% prog15.pl-> 101 103coruscant%

coruscant% cat prog16.pl#!/usr/bin/perl@list = (100,101,102,103);@list[0,2] = @list[2,0];print ("list : @list\n");coruscant% prog16.pllist : 102 101 100 103coruscant%



coruscant% cat prog17.pl#!/usr/bin/perl@list = (100,101,102,103);@list[0,1,2] = @list[1,1,1];print ("list : @list\n");coruscant% prog17.pllist : 101 101 101 103coruscant%

coruscant% cat prog18.pl#!/usr/bin/perl@list = (100,101,102,103);@list[0,2] = (AAA,BBB);print ("list : @list\n");coruscant% prog18.pllist : AAA 101 BBB 103coruscant%



coruscant% cat prog19.pl#!/usr/bin/perl@list = (100,101,102,103,104)[0,2,4];print ("list : @list\n");coruscant% prog19.pllist : 100 102 104coruscant%

coruscant% cat prog20.pl#!/usr/bin/perl@list = (100,101,102,103,104);@index = (0,2,4);@sublist = @list[@index];print ("sublist : @sublist\n");coruscant% prog20.plsublist : 100 102 104coruscant%



coruscant% cat prog21.pl#!/usr/bin/perl@list = (100,101,102,103,104);print ("list : @list\n");$list[5] = 205;print ("list : @list\n");$list[8] = 808;print ("list : @list\n");coruscant% prog21.pllist : 100 101 102 103 104list : 100 101 102 103 104 205list : 100 101 102 103 104 205 808coruscant%

coruscant% cat prog22.pl#!/usr/bin/perl@list = (100,101,102,103,104);print ("Dernier index : $#list\n");print ("Dernier element:$list[$#list]\n");coruscant% prog22.plDernier index : 4Dernier element : 104coruscant%



coruscant% cat prog23.pl#!/usr/bin/perl@list = (100,101,102,103,104);$i = 3;$t3 = $list[$i];$t2 = $list[$i-1];$c = (A,B,C,D,E) [$i+1];print ("list : @table\n");print ("i : $i\n");print ("t3 : $t3\n");print ("t2 : $t2\n");print ("c : $c\n");coruscant% prog23.pllist : 100 101 102 103 104i : 3t3 : 103t2 : 102c : Ecoruscant%


Utilisation des comparateurs ternaires.

coruscant% cat prog24.pl#!/usr/bin/perl$a = "Un";$b = "Deux";$c = 10;$d = 2;

print ("$a est ",("avant","identique","apres")[($a cmp $b)+1]," $b.\n");print ("$c est ",("inferieur","egal","superieur")[($c <=> $d)+1]," a $d.\n");print ("$a est ",("inferieur","egal","superieur")[($a <=> $b)+1]," a $b.\n");print ("$c est ",("avant","identique","apres")[($c cmp $d)+1]," $d.\n");coruscant% prog24.plUn est apres Deux.10 est superieur a 2.Un est egal a Deux.10 est avant 2.coruscant%


sort() et reverse().

coruscant% cat prog24.pl#!/usr/bin/perl@list1 = (A,B,C,D,E,F);@list2 = reverse(@list1);print ("List1 : @list1\n");print ("List2 : @list2\n");coruscant% prog24.plList1 : A B C D E FList2 : F E D C B Acoruscant%

coruscant% cat prog25.pl#!/usr/bin/perl@list1 = (1,2,4,10,11,20,A,a,B,c);@list2 = sort(@list1);print ("List1 : @list1\n");print ("List2 : @list2\n");coruscant% prog25.plList1 : 1 2 4 10 11 20 A a B cList2 : 1 10 11 2 20 4 A B a ccoruscant%


L'itérateur foreach.

coruscant% cat prog.pl#!/usr/bin/perl@a = (1,2,3,4,5);foreach $i (@a) {print "$i ";}coruscant% prog.pl1 2 3 4 5coruscant% cat prog.pl#!/usr/bin/perl@a = (1,2,3,4,5);foreach $i (reverse(@a)) {print "$i ";}coruscant% prog.pl5 4 3 2 1coruscant%

FOREACH

foreach $i (@liste_de_valeurs) { instruction_1; instruction_2; instruction_3;}

$i va prendre successivement les valeurs des éléments de laliste du premier jusqu'au dernier.


Modification de la variable d'itération.

coruscant% cat prog.pl@a = (1,2,3,4,5);print "Liste avant la boucle : @a.\n";foreach $i (@a) { $i**=3; print "$i ";}print "\nListe apres la boucle : @a.\n";

if (defined($i)) { print ("\$i est defini.\n") } else { print ("\$i est indefini.\n")}coruscant% prog.plListe avant la boucle : 1 2 3 4 5.1 8 27 64 125Liste apres la boucle : 1 8 27 64 125.$i est indefini.coruscant%

Toute modification de la variable d'itération entraîne unemodification de la valeur de l'élément correspondant de la liste.

De plus, la variabled'itération se déclarelocale au bloc foreach.


push() et unshift().

coruscant% cat prog26.pl#!/usr/bin/perl@list = (100,101,102,103,104);unshift (@list,"Tete");print ("Liste : @list\n");coruscant% prog26.plListe : Tete 100 101 102 103 104coruscant%

coruscant% cat prog27.pl#!/usr/bin/perl@list = (A,B,C,D);push (@list,(1,2,3));print ("Liste : @list\n");coruscant% prog27.plListe : A B C D 1 2 3coruscant%

Utilisation de la liste commeune liste ou une pile

push (@list,$val); ou push (@list,@val);unshift (@list,$val); ou unshift (@liste,@val);push ajoute $val (@val)

à la fin de la liste @liste,unshift ajoute $val (@val)

au début de la liste @liste.

coruscant% cat prog28.pl#!/usr/bin/perl@list = (100,101,102,103,104);push (@list,"tail");print ("Liste : @list\n");coruscant% prog28.plListe : 100 101 102 103 104 tailcoruscant%

0 npushunshift


pop() et shift().

coruscant% cat prog24.pl#!/usr/bin/perl@list = (100,101,102,103,104);$element = pop (@list);print ("List : @list\n");print ("Element : $element\n");coruscant% prog13.plList : 100 101 102 103Element : 104coruscant%

coruscant% cat prog25.pl#!/usr/bin/perl@list = (100,101,102,103,104);$element = shift (@list);print ("List : @list\n");print ("Element : $element\n");");coruscant% prog15.plList : 101 102 103 104Element : 100coruscant%

$val = pop (@liste,$val); $val = shift (@liste,$val);Retire une valeur de la liste et le renvoie en tant que valeur de retour

pop : Le dernier élément.shift :Le premier élément.

0 npopshift


En résumé.

0 npushunshift

0 npopshift

shift

pop

unshift push

Pile

File

File

Pile


split().

coruscant% cat prog24.pl#!/usr/bin/perl$name = "Departement d'Informatique Universite de la Mediterranée";print "$name\n";@list = split(/ /,$name);print "$list[0]\n";print "$list[1]\n";print "$list[2]\n";print "$list[3]\n";print "$list[4]\n";print "$list[5]\n";coruscant% prog24.plDepartement d'Informatique Universite de la MediterranéeDepartementd'InformatiqueUniversitedelaMéditerraneecoruscant%


Application.

coruscant% cat prog.plwhile (<STDIN>){ foreach $i (split(/,/)){ $s+=$i }print "Resultat : $s\n";$s = 0;}coruscant% prog.pl1,2,3,4Resultat : 1010,45,62Resultat 117<ctrl>Ccoruscant%

Un programme qui lit une suite de nombres séparés par unevirgule et qui en effectue la somme.


Application amusante.

coruscant% cat prog.pl#!/usr/bin/perlchop ($ligne = <STDIN>);$nb0 = split(/0/,$ligne) -1;$nb1 = split(/1/,$ligne) -1;print ("Dans la chaine $ligne, il y a :\n");print ("$nb0 fois le chiffre 0.\n");print ("$nb1 fois le chiffre 1.\n");coruscant% prog.pl10101011001011111000101011010Dans la chaine 10101011001011111000101011010, il y a :12 fois le chiffre 0.16 fois le chiffre 1.coruscant%

On dispose d'une chaîne de caractères lue sur <STDIN> (pour seterminer par un \n) et comportant exclusivement des 0 et des 1.On désire écrire un programme qui : Lise la chaîne.Affiche le nombre de 0.Affiche le nombre de 1.


join().

coruscant% cat prog25.pl#!/usr/bin/perl@list = ("Universite","de","la","Mediterranee");print "List[0] = $list[0]\n";print "List[1] = $list[1]\n";print "List[2] = $list[2]\n";print "List[3] = $list[3]\n";$name = join("-",@list);print "$nom\n";coruscant% prog25.plList[0] = UniversiteList[1] = deList[2] = laList[3] = MediterraneeUniversite-de-la-Mediterraneecoruscant%


La fonction splice().

La fonction splice permet de modifier des éléments d'une liste.Il y a de multiples manières d'utiliser cette fonction.Sa forme générale est :

@retour = splice (@variable, $elements_a_sauter, $longueur, @nouvelle_liste);

@variable est le nom de la variable contenant la liste.$elements_a_sauter indique le nombre d'éléments à sauter avant de

commencer l'opération.$longueur Si cette valeur est supérieure à zéro, @retour contiendra

la liste des éléments remplacés.


Exemple.

coruscant% cat prog.pl#!/usr/bin/perl@liste = ("Nombres","un","deux","trois","quatre","cinq");@valeurs = ("1","2","3","4","5");@retour = splice (@liste,1,2,@valeurs);print ("Liste d'éléments qui ont été remplacés :\n@retour\n");print ("\nNouvelle liste d'éléments :\n@liste\n");coruscant% prog.plListe d'éléments qui ont été remplacés :un deux

Nouvelle liste d'éléments :Nombres 1 2 3 4 5 trois quatre cinqcoruscant%


sort() en détail.

coruscant% cat prog26.pl#!/usr/bin/perl@b = (1,4,A,aa,BB,x,10,100);@a = sort @b;print "Resultat : @a\n";coruscant% prog26.plResultat : 1, 10, 100, 4, A, BB, aa, xcoruscant%

Le critère de tri est caché.On le considère comme implicite.

Tri alphabétique en ordre croissant.

En fait, il prend en compte deux variables ($a et $b)Et un opérateur de comparaison (<=> or cmp).

Le tri alphabétique ne ordre croissant devrait s'écrire :@a = sort { $a cmp $b } @b;


Tri en ordre inverse.coruscant% cat prog27.pl#!/usr/bin/perl@b = (1,4,A,aa,BB,x,10,100);@a = reverse(sort @b);print "Resultat : @a\n";coruscant% prog27.plResultat : x, aa, BB, A, 4, 100, 10, 1coruscant%

coruscant% cat prog28.pl#!/usr/bin/perl@b = (1,4,A,aa,BB,x,10,100);@a = sort { $b cmp $a } @b;print "Resultat : @a\n";coruscant% prog28.plResultat : x, aa, BB, A, 4, 100, 10, 1coruscant%

sort () génère toutes les paires possibles de deux variables.Ces deux variables sont renvoyées en tant que $a et $b.

On attend alors une réponse à la comparaison de $a et $b.Si la réponse est :

Une valeur négative : $a et $b sont conservés dans cet ordreUne valeur positive : On inverse les valeurs de $a et $b.


Tri numérique

coruscant% cat prog29.pl#!/usr/bin/perl@b = (1,20,8,3,16,25,10,12,11);@a = sort { $a <=>$b } @b;print "Resultat 1 : @a\n";@a = sort { $b <=>$a } @b;print "Result 2 : @a\n";coruscant% prog29.plResultat 1 : 1 3 8 10 11 12 16 20 25Resultat 2 : 25 20 16 12 11 10 8 3 1coruscant%


L'opérateur map().

L'opérateur map va permettre de considérer chaque élémentd'une liste tour à tour comme opérande d'une expression donnée.

La forme la plus simple est :

@liste_de_resultats = map(expression,@liste);

coruscant% cat prog29.pl#!/usr/bin/perl@liste =("1","2","3","4","5");@resultat = map($_*$_,@liste);print ("Liste d'origine :\n");print ("@liste\n");print ("\nListe aprés calcul :\n");print ("@resultat\n");coruscant% prog29.plListe d'origine :1 2 3 4 5

Liste aprés calcul :1 4 9 16 25coruscant%


Généralisation de l'opérateur map().

L'opérateur map est toutefois beaucoup plus puissant.Il permet en quelque sortd d'écrire en une seule instruction unprogramme de gestion de liste

La forme générale est :

@liste_de_resultats = map {Bloc de Programme} @liste;

coruscant% cat signature.pl#!/usr/bin/perlprint join('',map({$i=1-$i;$a=$i?10*$_."\b\b":pack"c",$a+$_+0x16}split(//,"5110789279758710838810587992861093898779948387799310")),"...\n");coruscant% signature.plI dream in Perl sometimes ...coruscant%

map( {$i=1-$i;$a=$i?10*$_."\b\b":pack"c",$a+$_+0x16} split(//,"5110789279758710838810587992861093898779948387799310"))

Bloc de Programme

Liste


La fonction grep().

Cette fonction va récupérer chacun des éléments d'une liste dansla variable $_.La variable standard sera alors évaluée en fonction d'unel'expression.Si l'évaluation de l'expression renvoie la valeur "vrai", la variablestandard sera alors insérée dans une nouvelle liste.

La forme générale est :

grep(Expression, @liste);

coruscant% cat grep.pl#!/usr/bin/perl@chiffres = (0,1,2,3,4,5,6,7,8,9);@impairs = grep($_ % 2 , @chiffres);print join(", ",@impairs),"\n";coruscant% grep.pl1, 3, 5, 7, 9coruscant%


La fonction index().

Cette fonction permet de détecter si une sous chaîne est ou n'est pasprésente dans une chaîne de référence, et à quel emplacement elle sesitue.

Forme générale :$x = index ($Chaine,$SousChaine);

La valeur de $x est :

0 : La chaîne de référence débute par la sous chaîne.n : La chaîne de référence débute par n caractères immédiatementsuivis de la sous chaîne.

-1 : La sous chaîne est absente de la chaîne de référence.

Si plusieurs occurrences de la sous chaîne sont présentes dans lachaîne de référence, seule la première, celle située la plus à gauche,sera prise en compte.


Application.

coruscant% cat index.pl#!/usr/bin/perl$c = "Bonjour";$m = "j";print ("Chaine de reference : $c\n");print ("Modele recherche : $m\n");$x = index ($c,$m);print "Reponse : $x\n\n";$c = "Il fait beau.";$m = "beau";print ("Chaine de reference : $c\n");print ("Modele recherche : $m\n");$x = index ($c,$m);print "Reponse : $x\n\n";$c = "123456789";$m = "0";print ("Chaine de reference : $c\n");print ("Modele recherche : $m\n");$x = index ($c,$m);print "Reponse : $x\n\n";coruscant%

coruscant% index.plChaine de reference : BonjourModele recherche jReponse : 3

Chaine de reference : Il fait beau.Modele recherche beauReponse : 8

Chaine de reference : 123456789Modele recherche 0Reponse : -1coruscant%


Le hash.

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("a","AA","b","BB","c","CC","d","DD");@indices = ("a","b","c","d");foreach $i (@indices) { print "Hash($i) = $hash{$i}\n";}coruscant% prog.plHash(a) = AAHash(b) = BBHash(c) = CCHash(d) = DDcoruscant%

On peut écrire :

$fish{"red"}+=23;

%F = %G;

@fish{"red","white","yellow"}=(12,15,7);

C'est une structure de données spécifique dans laquelle chaqueélément est identifié par une clé.


L'opérateur =>.

coruscant% cat prog.pl#!/usr/bin/perl%hash = ( "a" => "AA", "b" => "BB", "c" => "CC", "d" => "DD");@indices = ("a","b","c","d");foreach $i (@indices) { print "Hash($i) = $hash{$i}\n";}coruscant% prog.plHash(a) = AAHash(b) = BBHash(c) = CCHash(d) = DDcoruscant%


Programme.

coruscant% cat prog.pl#!/usr/bin/perl %semaine = ('01' => 'Lundi','02' => 'Mardi','03' => 'Mercredi', '04' => 'Jeudi','05' => 'Vendredi','06' => 'Samedi', '07' => 'Dimanche' );print ("\n========== Début du test ==========\n");foreach $i (sort keys %semaine) { printf ("$i est $semaine{$i} \n");}print ("=========== Fin du test ===========\n");coruscant% prog.pl========== Début du test ==========01 est Lundi02 est Mardi03 est Mercredi04 est Jeudi05 est Vendredi06 est Samedi07 est Dimanche=========== Fin du test ===========coruscant%


Le travail sur un hash.

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("a","AA","b","BB","c","CC","d","DD");@indices = (a,b,c,d);foreach $i (@indices) { $hash{$i} = "X ".$hash{$i}." X";}foreach $i (@indices) { print "Hash($i) = $hash{$i}\n";}coruscant% prog.plHash(a) = X AA XHash(b) = X BB XHash(c) = X CC XHash(d) = X DD Xcoruscant%


Transfert de hash.

coruscant% cat prog.pl#!/usr/bin/perl%hash1 = ("a","AA","b","BB","c","CC","d","DD");%hash2 = %hash1;@indices = ("a","b","c","d");print "Hash one :\n";foreach $i (@indices) {print " Hash1($i) = $hash1{$i}\n";}print "\nHash two :\n";foreach $i (@indices) {print " Hash2($i) = $Hash2{$i}\n";}coruscant% prog.plHash one : Hash1(a) = AA Hash1(b) = BB Hash1(c) = CC Hash1(d) = DD

Hash two : Hash2(a) = AA Hash2(b) = BB Hash2(c) = CC Hash2(d) = DDcoruscant%


Convertir un hash en une liste.

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("a","AA","b","BB","c","CC","d","DD");@list = %hash;print "List = @list\n";coruscant% prog.plList = a AA b BB c CC d DDcoruscant%


Convertir une liste en un hash.coruscant% cat prog.pl#!/usr/bin/perl@list = ("a","AA","b","BB","c","CC","d","DD");%hash = @list;@indices = ("a","b","c","d");print "Hash initial :\n";foreach $i (@indices) { print " hash($i) = $hash{$i}\n"; $hash{$i} = "* ".$hash{$i}." *";}print "\nHash modifie :\n";foreach $i (@indices) { print " hash($i) = $hash{$i}\n";}coruscant% prog.plHash initial : hash(a) = AA hash(b) = BB hash(c) = CC hash(d) = DD

Hash modifie : hash(a) = * AA * hash(b) = * BB * hash(c) = * CC * hash(d) = * DD *coruscant%


L'opérateur keys().

coruscant% cat prog.pl#!/usr/bin/perl%hash =("one","First","two","Second","three","Third","four","Fourth");$length = @keys = keys(%hash);print "Le hash contient $nbe elements.\n";print "Les cles sont : @keys\n\n";foreach $i (@keys) {print "Hash($i) = $hash{$i}\n";}coruscant% prog.plLe hash contient 4 elements.Les cles sont : three one two four

Hash(a) = ThirdHash(b) = FirstHash(c) = SecondHash(d) = Fourcoruscant%


L'opérateur values().

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("one","First","two","Second","three","Third","four","Fourth");$nbe = @vals = values(%hash);print "Taille du hash : $nbe\n";print "Valeurs : @vals\n";coruscant% prog.plTaille du hash : 4Valeurs : Third First Second Fourthcoruscant%


L'opérateur each().

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("one","First","two","Second","three","Third","four","Fourth");while (($key,$val) = each(%hash)) { print "La cle \"$key\" donne la valeur \"$val\"\n";}coruscant% prog.plLa cle "three" donne la valeur "Third"La cle "one" donne la valeur "First"La cle "two" donne la valeur "Second"La cle "four" donne la valeur "Fourth"coruscant%


L'opérateur delete().

coruscant% cat prog.pl#!/usr/bin/perl%hash = ("one","First","two","Second","three","Third","four","Fourth");print "On retire l'element : two,Second.\n";delete ($hash{"two"});while (($key,$val) = each(%hash)) { print " La cle \"$key\" donne la valeur \"$val\"\n";}print "\nOn ajoute l'element : five,Fifth.\n";$hash{"five"} = "Fifth";while (($key,$val) = each(%hash)) { print " La cle \"$key\" donne la valeur \"$val\"\n";}coruscant% prog.plOn retire l'element : two,Second. La cle "three" donne la valeur "Third" La cle "one" donne la valeur "First" La cle "four" donne la valeur "Fourth"

On ajoute l'element : five,Fifth. La cle "three" donne la valeur "Third" La cle "five" donne la valeur "Fifth" La cle "one" donne la valeur "First" La cle "four" donne la valeur "Fourth"coruscant%


Les fichiers.

Les identificateurs de fichiers standards sous Linux sont :

<STDIN> Standard input.<STDOUT> Standard output<STDERR> Standard error.


Les pseudo-fichiers.coruscant% cat prog.pl#!/usr/bin/perlwhile ($ligne = <DATA>) { print ++$n, " - $ligne";}__DATA__Premiere ligne du pseudo-fichier.Seconde ligne du pseudo-fichier.Troisième ligne du pseudo-fichier.Quatrieme ligne du pseudo-fichier.Cinquieme ligne du pseudo-fichier.Sixieme ligne du pseudo-fichier.Septieme ligne du pseudo-fichier.Huitieme ligne du pseudo-fichier.Neuvieme ligne du pseudo-fichier.coruscant% prog.pl1 - Premiere ligne du pseudo-fichier.2 - Seconde ligne du pseudo-fichier.3 - TroisiÞme ligne du pseudo-fichier.4 - Quatrieme ligne du pseudo-fichier.5 - Cinquieme ligne du pseudo-fichier.6 - Sixieme ligne du pseudo-fichier.7 - Septieme ligne du pseudo-fichier.8 - Huitieme ligne du pseudo-fichier.9 - Neuvieme ligne du pseudo-fichier.coruscant%

Il peur arriver que l'on aitbesoin s'accéder à unesérie de données detype fichier sans pour celaavoir envie de créer unfichier physique.

Dans ces conditions,on peut utiliser unpseudo-fichier.


L'opérateur "diamond" <>.

coruscant% cat prog.pl#!/usr/bin/perl@ARGV = ("perl.txt");while ($line = <>) { print "$line"}coruscant% prog.plWhat is Perl?Perl is a programming language which can be used for a large variety of tasks.A typical simple use of Perl would be for extracting information from a textfile and printing out a report or for converting a text file into another form.But Perl provides a large number of tools for quite complicated problems,including systems programming.Programs written in Perl are called Perl scripts, whereas the term the perlprogram refers to the system program named perl for executing Perl scripts.If you have used shell scripts or awk or sed or similar (Unix) utilitiesfor various purposes, you will find that you can normally use Perl forthose and many other purposes, and the code tends to be more compact.And if you haven't used such utilities but have started thinking you mighthave need for them, then perhaps what you really need to learn is Perlinstead of all kinds of futilities.coruscant%


Les variables prédéfinies.

coruscant% cat prog.pl#!/usr/bin/perl@ARGV = ("perl.txt");while (<>) { print}coruscant% prog.plWhat is Perl?Perl is a programming language which can be used for a large variety of tasks.A typical simple use of Perl would be for extracting information from a textfile and printing out a report or for converting a text file into another form.But Perl provides a large number of tools for quite complicated problems,including systems programming.Programs written in Perl are called Perl scripts, whereas the term the perlprogram refers to the system program named perl for executing Perl scripts.If you have used shell scripts or awk or sed or similar (Unix) utilitiesfor various purposes, you will find that you can normally use Perl forthose and many other purposes, and the code tends to be more compact.And if you haven't used such utilities but have started thinking you mighthave need for them, then perhaps what you really need to learn is Perlinstead of all kinds of futilities.coruscant%

$_ est une variable prédéfinie.


Ouverture de fichiers.

open (INPUT, "input_file.txt");Pour ouvrir un fichier en lecture.

open (NEWOUT, ">new_output_file.txt");Pour ouvrir en création un fichier en écriture.

open (OLDOUT, ">>old_output_file.txt");Pour ouvrir en écriture un fichier existant et en continuer l'écriture.

open (INANDOUT, "+>fichier_es");Pour ouvrir un fichier en lecture et en écriture.

close (FILE);Pour fermer un fichier.


Lecture d'un fichier.

coruscant% cat prog.pl#!/usr/bin/perlopen (READ,"perl.txt");while ($line = <READ>) { print $line}close (READ);coruscant% prog.plWhat is Perl?Perl is a programming language which can be used for a large variety of tasks.A typical simple use of Perl would be for extracting information from a textfile and printing out a report or for converting a text file into another form.But Perl provides a large number of tools for quite complicated problems,including systems programming.Programs written in Perl are called Perl scripts, whereas the term the perlprogram refers to the system program named perl for executing Perl scripts.If you have used shell scripts or awk or sed or similar (Unix) utilitiesfor various purposes, you will find that you can normally use Perl forthose and many other purposes, and the code tends to be more compact.And if you haven't used such utilities but have started thinking you mighthave need for them, then perhaps what you really need to learn is Perlinstead of all kinds of futilities.coruscant%


Ecrire un fichier.coruscant% cat prog.pl#!/usr/bin/perlopen (OUT,">new.txt")print "Creation du fichier.\n";while ($ligne = <STDIN>) { print OUT $ligne}close (OUT);open (IN,"new.txt");print "Lecture du fichier.\n";while ($l = <IN>) { print $l}close (IN);coruscant% prog.plCreation du fichier.Ligne Un.Ligne Deux.Ligne Trois.Ligne Quatre.<ctrl>DLecture du fichier.Ligne Un.Ligne Deux.Ligne Trois.Ligne Quatre.coruscant%


La fonction die().

Pour récupérer une erreur sur un fichieret transmettre un message d'alerte.

unless ( open (FICHIER, "/tmp/fichier")) { print "Desole, impossible d'acceder a /tmp/fichier.\n";} else { # Deroulement normal du programme.}

Utilisation de la fonction die(); unless ( open (FICHIER, "/tmp/fichier")) { die "Desole, impossible d'acceder a /tmp/fichier.\n";} # Deroulement normal du programme.

Ou plus simplement :open (FICHIER, "/tmp/fichier") || die "Desole, impossible d'acceder a /tmp/fichier.\n";


Particularité de la fonction die().

L. Wall résume de manière provocatrice l'action de die() :"Open that file or die".

Sous la forme :die "Erreur d'accès au fichier.";

Le texte spécifié.Nom du programme Perl qui a généré l'erreur.Numéro de la ligne contenant le die incriminée.

Sous la forme :die "Erreur d'accès au fichier.\n";

Seulement le texte spécifié.

open (FICH,"toto") or die "erreur 1"; # erreur 1File 'Untitled'; Line 1

open (FICH,"toto\n") or die "erreur 1"; # erreur 1


La fonction select().

La fonction "select" permet de modifier les périphériques standards

coruscant% cat prog.pl #!/usr/bin/perlopen (FICHIER,">Sortie.txt");$chaine = "Perl est vraiment un super langage.";select (stdout);&ecrire;select (FICHIER);&ecrire;close (FICHIER);

sub ecrire { print ("J'écris :\n$chaine\nsur le fichier de sortie.\n");}coruscant% prog.plJ'écris :Perl est vraiment un super langage.sur le fichier de sortie.coruscant% cat Sortie.txtJ'écris :Perl est vraiment un super langage.sur le fichier de sortie.coruscant%


Particularité.

Utilisé en tant que fonction, select retournele descripteur qui vient d’être remplacé.

select (SORTIE);

# Changement de STDOUT vers SORTIE. my $ancien = select (FICHIER);

# Changement de STDOUT vers FICHIER.# $ancien contient le descripteur SORTIE.


Les surprises des redirections.coruscant% cat prog.pl #!usr/bin/perlopen (STDOUT,">stdout.txt") ||

die ("Pas moyen d'ouvrir STDIN");open (STDERR,">STDOUT") || die ("Pas moyen d'ouvrir STDERR");print STDOUT ("Premiere ligne sur la sortie standard (STDOUT).\n");print STDERR ("Seconde ligne sur la sortie erreur (STDERR).\n");close (STDOUT);close (STDERR);coruscant% prog.plSeconde ligne sur la sortie erreu (STDERR). Premiere ligne sur la sortie standard (STDOUT).coruscant% prog.pl

La première instruction redirige la sortie standard (STDOUT)vers le fichier stdout.txt. La seconde instruction redirige la sortieerreur (STDERR) vers la sortie standard (STDOUT) soit en définitivevers la fichier stdout.txt.L'accès à un fichier (stdout.txt) se fait par l'intermédiaire d'un buffer,la copie effective se produit lorsque le buffer est plein ou lorsque leprogramme se termine.Les buffers pour STDOUT et STDERR sont différents (bien que en finde compte redirigés vers le même destination), la première ligne eststockée dans STDOUT, et la seconde ligne est stockée dans STDERR.C'est en fin d'exécution que les buffers sont recopiés dans leurdestination finale (stdout.txt) mais unix commence toujours parrecopier STDERR puis STDOUT.


La non bufferisation.

La variable prédéfinie $| doit contenir une valeur différente de zéro sion désire supprimer la bufferisation des données.Elle agit sur STDOUT ou sur le dernier fichier spécifié par une sélection.

coruscant% cat prog.pl #!usr/bin/perlopen (STDOUT,">stdout.txt") || die ("Pas moyen d'ouvrir STDIN");open (STDERR,">&STDOUT") || die ("Pas moyen d'ouvrir STDERR");# Suppression de la bufferisation de STDOUT.$| = 1;select (STDERR);# Suppression de la bufferisation de STDERR.$| = 1;print STDOUT ("Premiere ligne sur la sortie standard (STDOUT).\n");print STDERR ("Seconde ligne sur la sortie erreur (STDERR).\n");close (STDOUT); close (STDERR);coruscant% prog.plPremiere ligne sur la sortie standard (STDOUT).Seconde ligne sur la sortie erreur (STDERR).coruscant%


Purge d'un descripteur.

Utilisation pour purger les tubes de communication.

Permet d’effectuer la purge des deux accès liés auxdescripteurs FICHIER et SORTIE.

my $ancien = select (FICHIER); $| =1; select $ancien;my $ancien = select (SORTIE); $| =1; select $ancien;


Sauter ou relire des informations.

Pouvoir sauter des information ou de procéder à leur relecture.

Deux fonctions :seek();tell ();

La fonction seek() permet de sauter des caractères d'un fichier donné.

La fonction tell() permet de récupérer la distance (en caractères)qui sépare le début du fichier de la position courante dans le fichier.

La position courante est l'emplacement de la ligne qui va être lue.


Syntaxe.

seek (référence, distance, relativement_a);référence : référence du fichier concerné.distance : entier représentant le nombre de caractères à sauter.relativement_a : entier égal à 0, 1 ou 2.

0 : relativement au début du fichier.2 : relativement à la prochaine ligne qui doit être lue.3 : relativement à la fin du fichier.tell (référence);

référence : référence du fichier concerné.

Exemples : seek (REF,0,0) : Revenir au début du fichier.seek (REF,100,1) : Sauter de 100 caractères en avant.seek (REF,-100,1) : Sauter de 100 caractères en arrière.seek (REF,0,2) : Se positionner sur la fin de fichier.

seek et tell ne peuvent en aucun cas être utiliséssur des fichiers qui font référence à des tubes.


"Perliser" un programme.

#!/usr/bin/perlfor (@l = (1..20);($i+=($l[$i]%2))<@l;@p=(@p,$l[$i++])){};print "@p\n";

#!/usr/bin/perl@l = (1..20);for ($i=0;$i<=@l;$i++) { unless ($l[$i] % 2) { $p[$j++] = $l[$i]; }}print "@p\n";

Un petit exemple de programmation.Ecrire un programme qui rechercheles nombres pairs dans une liste donnée.


Un peu de programmation.

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi un nombre : ";chomp ($a = <STDIN>);unless ($a < 0) { ($r = sqrt($a))}if (defined $r){ print "La racine carree de $a est $r.\n"} else { print "La racine carree de $a n'est pas definie.\n"}coruscant% prog.plDonnez moi un nombre : 9La racine carree de 9 est 3.coruscant% prog.plDonnez moi un nombre : -9La racine carree de -9 n'est pas definie.coruscant%


Le modificateur d'instruction.

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi un nombre : ";chomp ($a = <STDIN>);$r = sqrt($a) unless ($a < 0);print "La racine carree de $a est $r." if (defined $r);print "La racine carree $a n'est pas definie." if !(defined $r);coruscant% prog.plDonnez moi un nombre : 9La racine carree de 9 est 3.coruscant% prog.plDonnez moi un nombre : -9La racine carree de -9 n'est pas definie.coruscant%


La structure de contrôle do.

Permet l'exécution d'un bloc.Utile pour renvoyer le test en fin de boucle.

coruscant% cat prog.pl#!/usr/bin/perl$ctr = 0;do {print ("Valeur : $ctr.\n");$ctr++;}until ($ctr == 5);print ("Fin du programme.\n");coruscant% prog.plValeur : 0.Valeur : 1.Valeur : 2.Valeur : 3.Valeur : 4.Fin du programme.coruscant%

coruscant% cat prog.pl#!/usr/bin/perl$ctr = 0;do {print ("Valeur : $ctr.\n");$ctr++;}while ($ctr <= 4);print ("Fin du programme.\n");coruscant% prog.plValeur : 0.Valeur : 1.Valeur : 2.Valeur : 3.Valeur : 4.Fin du programme.coruscant%


La structure de contrôle last.

Pour terminer une boucle avant son achèvement normal.Seuls peuvent être contrôlés les blocs de boucle(for, foreach, while).

while (cond) { instruction_w1; instruction_w2; if (condition) { instruction_i1; instruction_i2; last; } instruction_w3; instruction_w4;}# last vient ici.instruction;

La boucle la plus interne (while) est interrompue ici..

L'instruction last transfère le contrôle a cet endroit..


La structure de contrôle next.

Pour terminer une boucle avant son achèvement normal etdémarrer une nouvelle itération.L'expression de contrôle est alors réévaluée.Seuls peuvent être contrôlés les blocs de boucle(for, foreach, while).

while (cond) { instruction_w1; instruction_w2; if (condition) { instruction_i1; instruction_i2; next; } instruction_w3; instruction_w4;# next vient ici.}instruction;


L'instruction next transfère le contrôle a cet endroit.Et l'itération continue.


La structure de contrôle redo.

Pour rééxécuter une itération en conservant les mêmes paramètres.L'expression de contrôle n'est pas réévaluée.Seuls peuvent être contrôlés les blocs de boucle(for, foreach, while).

while (cond) {# redo vient ici. instruction_w1; instruction_w2; if (condition) { instruction_i1; instruction_i2; redo; } instruction_w3; instruction_w4;}instruction;


L'instruction redo transfère le contrôle a cet endroit.Et la boucle se rééxécute avec les mêmes paramètres..


Blocs identifiés.

On peut identifier un bloc afin de le contrôler au moyen d'undes opérateurs (last, next or redo).Un label est une suite de lettres ou de chiffres non précédésd'un caractère spécial (@,$,%)

LABEL: while (cond) { instruction_w1; instruction_w2; if (condition) { instruction_i1; instruction_i2; last LABEL; }}instruction;


Les blocs BEGIN et END.

Le bloc BEGIN est évalué dés qu'il est défini, avant tout autre.Il peut contenir des appels de fonction et utiliser des instructionsdo() ou require.Les blocs étant évalués immédiatement après leur définition, si ily a plusieurs blocs BEGIN, ils seront évalués dans l'ordre de leurapparition. Le bloc END est la toute dernière chose qui sera évaluée.Après un exit() ou un die() si de telles fonctions sont présentes.Ils peuvent être utilisés pour fermer des fichiers ou écrire desinformations dans les fichiers de surveillance. Si il y a plusieurs blocs END, ils sont évalués dans l'ordreinverse de leur apparition.


Un exemple de programme.coruscant% cat prog.pl#!/usr/bin/perl$td = time;$value = 48;for ($i = 1;$i <= 100000; $i++) { for ($j = 1;$j <= 100000; $j++) { if ($i * $j == $value) { print "$value est le produit de $i et $j\n"; } }}$t = time - $td;print ("Il a fallu $t secondes pour effectuer le calcul.\n");coruscant% prog.pl48 est le produit de 1 and 4848 est le produit de 2 and 2448 est le produit de 3 and 1648 est le produit de 4 and 1248 est le produit de 6 and 848 est le produit de 8 and 648 est le produit de 12 and 448 est le produit de 16 and 348 est le produit de f 24 and 248 est le produit de 48 and 1Il a fallu 3427 secondes pour effectuer le calcul.coruscant%


Le même optimisé.

coruscant% cat prog.pl#!/usr/bin/perl$td = time;$value = 48;EXTERNE: for ($i = 1;$i <= 100000; $i++) { INTERNE: for ($j = 1;$j <= 100000; $j++) { next EXTERNE if (($i * $j) > $value); if ($i * $j == $value) { print "$value est le produit de $i et $j\n"; next EXTERNE; } last INTERNE if ($j >= $i); }}$t = time - $td;print ("Il a fallu $t seconde(s) pour effectuer le calcul.\n");coruscant% prog.pl48 est le produit de 8 et 648 est le produit de 12 et 448 est le produit de 16 et 348 est le produit de 24 et 248 est le produit de 48 et 1Il a fallu 1 seconde(s) pour effectuer le calcul.coruscant%


Simuler un "switch".

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi n chiffre : ";chomp($a = <STDIN>);print "Il s'ecrit : ";SWITCH: { if ($a == 0){print "Zero.\n"; last SWITCH} if ($a == 1){print "Un.\n"; last SWITCH} if ($a == 2){print "Deux.\n"; last SWITCH} if ($a == 3){print "Trois.\n"; last SWITCH} if ($a == 4){print "Quatre.\n"; last SWITCH} if ($a == 5){print "Cinq.\n"; last SWITCH} if ($a == 6){print "Six.\n"; last SWITCH} if ($a == 7){print "Sept.\n"; last SWITCH} if ($a == 8){print "Huit.\n"; last SWITCH} if ($a == 9){print "Neuf.\n"; last SWITCH}}coruscant% prog.plDonnez moi un chiffre : 5Il s'ecrit : Cinq.coruscant%


La fonction eval ().

La fonction eval () exécute le paramètre qui lui est passé et le traitecomme un programme Perl.

coruscant% cat prog.pl#!/usr/bin/perl$x = 'print "Bonjour tout le monde.\n"';eval ($x);coruscant% perl prog.plBonjour tout le monde.coruscant%


Utilisation de la fonction eval ().

coruscant% cat prog.pl#!/usr/bin/perl$x = 'print "Bonjour tout le monde.\n';

print "Evaluation de la variable \$x.\n";eval ($x);print "Evaluation de la variable \$x terminee.\n";print "Il n'y a pas eu de message d'erreur.\n";print "Impression de la variable \$@.\n";print "$@\n";coruscant% perl prog.plEvaluation de la variable \$x.Evaluation de la variable \$x terminee.Il n'y a pas eu de message d'erreur.Impression de la variable \[email protected]'t find string terminator '"' anywhere before EOF at (eval 1) line 1.coruscant%

Si il y a une erreur, elle est stockée dans la variablestandard $@.


La plus simple des calculettes.

coruscant% cat prog.pl#!/usr/bin/perlprint eval(<STDIN>),"\n";coruscant% perl prog.pl(10+3)*sqrt(16)52coruscant%


Les opérations logiques.

Perl va toujours tenter d'optimiser la résolution d'équations.

Ainsi par exemple, si nous considérons le calcul suivant :

$result = $a and $b

$a $b $a and $bFaux Faux FauxFaux Vrai FauxVrai Faux FauxVrai Vrai Vrai

Si $a est "faux", il n'est pasnécessaire d'évaluer $b poursavoir que $result sera "faux".Au contraire, si $a est "vrai"il est indispensable d'évaluer$b pour pouvoir donner lavaleur finale de $result.

Ce mécanisme est appelé "Evaluation en court circuit".


Evaluation d'une instruction.

coruscant% cat prog.pl#!/usr/bin/perl$a = print "Hello Monde.\n";print "Valeur de \$a : $a.\n";coruscant% prog.plHello Monde.Valeur de \$a : 1.coruscant%

En perl, tout est évaluable.

Habituellement le résultat est :Vrai (1), Pas de problèmes.Faux (0), Erreur générée.

Il faut bien noter que le seul moyen de récupérer le résultat del'évaluation d'une instruction, c'est de l'exécuter.


Expressions logiques et instructions.

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi un nombre : ";chomp ($a = <STDIN>);$r = sqrt($a) unless ($a < 0);print "La racine carree de $a est $r.\n" if (defined $r);print " La racine carree de $a n'est pas definie.\n" if !(defined $r);coruscant%

Soit le programme que nous avons vu précédemment

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi un nombre : ";chomp ($a = <STDIN>);($a < 0) or $r = sqrt($a);defined $r and print "La racine carree de $a est $r.\n"defined $r or print " La racine carree de $a n'est pas definie.\n"coruscant%

Il peut être réécrit comme suit :


Explication.

coruscant% cat prog.pl#!/usr/bin/perlprint "Donnez moi un nombre : ";chomp ($a = <STDIN>);($a < 0) or $r = sqrt($a);defined $r and print "La racine carree de $a est $r.\n"defined $r or print " La racine carree de $a n'est pas definie.\n"coruscant% prog.plDonnez moi un nombre : 9La racine carree de 9 est 3.coruscant% prog.plDonnez moi un nombre : -9La racine carree de -9 n'est pas definie.coruscant%

$a < 0 $r = sqtr($a)Faux Il faut évaluerTrue Ce n'est pas nécessaire

Et pour obtenir l'évaluation de $r = sqtr($a),il est indispensable de l'exécuter.


L'utilisation des conditions.

coruscant% cat prog.pl#!/usr/bin/perlprint "De combien d'objets avez vous besoin ? ";chomp ($n = <STDIN>);print " Vous avez besoin de $n objet";if ($n == 1) { print ".\n"} else { print "s.\n"}coruscant% prog.plDe combien d'objets avez vous besoin ? 1 Vous avez besoin de 1 objet.coruscant% prog.plDe combien d'objets avez vous besoin ? 5 Vous avez besoin de 5 objets.coruscant%


L'opérateur conditionnel ?:.

Il existe en perl un opérateur spécifique capable de retournerune valeur choisie parmi deux.

coruscant% cat prog.pl#!/usr/bin/perlprint "De combien d'objets avez vous besoin ? ";chomp ($n = <STDIN>);print " Vous avez besoin de $n objet";print $n==1?"":"s".".\n";coruscant% prog.plDe combien d'objets avez vous besoin ? 1 Vous avez besoin de 1 objet.coruscant% prog.plDe combien d'objets avez vous besoin ? 5 Vous avez besoin de 5 objets.coruscant%


Les options de la ligne de commande.L'option -eCette option va permettre l'écriture d'un programme qui seraentièrement contenu dans la ligne de commande.

coruscant% perl -e "print 'Bonjour tout le monde.'"Bonjour tout le monde.coruscant% perl -e "$a = 10;print ++$a"11coruscant%

On a coutume d'appeler de tels programmes des "One liners".

Attention sous Unix au problème des doubles quotes (")et des simples quotes (').


Les filtres sur les fichiers.

Les deux options spécifiques -n-p

Sont les plus utilisées lors de l'écriture de programme uniligne.

L'options -n encadre leprogramme entre leslignes suivantes .

LINE :while (<>) { # Votre code.}

L'options -p encadre leprogramme entre leslignes suivantes .

LINE :while (<>) { # Votre code.}continue { print or die "-p destination: $!\n";}


Exemple de programme.

coruscant% cat ess.pl#!/usr/bin/perl -nprint;coruscant% ess.pl#!/usr/bin/perlprint ("Donnez moi une adresse ethernet :\n");$adresse_de_la_machine = <STDIN>;$adresse_de_la_machine =~ s/^\s+|\s+$//g;@bytes = split (/\./, $adresse_de_la_machine);$adresse = pack ("C4", @bytes);if (!(($nom, $alias, $type_adressage, $longueur,@liste_d_adresses) = gethostbyaddr ($adresse, 2))) { die ("Address $adresse_de_la_machine notfound.\n");}print ("Le nom principal de la machine est $nom\n");if ($alias ne "") { print ("Les alias de la machine sont :\n"); @liste_d_alias = split (/\s+/, $alias); for ($i = 0; $i < @liste_d_alias; $i++) { print ("\t$liste_d_alias[$i]\n"); }}coruscant%

Imprimerun fichier.


Exemple.

coruscant% perl -ne "print" get.pl#!/usr/bin/perlprint ("Donnez moi une adresse ethernet :\n");$adresse_de_la_machine = <STDIN>;$adresse_de_la_machine =~ s/^\s+|\s+$//g;@bytes = split (/\./, $adresse_de_la_machine);$adresse = pack ("C4", @bytes);if (!(($nom, $alias, $type_adressage, $longueur,@liste_d_adresses) = gethostbyaddr ($adresse, 2))) { die ("Address $adresse_de_la_machine notfound.\n");}print ("Le nom principal de la machine est $nom\n");if ($alias ne "") { print ("Les alias de la machine sont :\n"); @liste_d_alias = split (/\s+/, $alias); for ($i = 0; $i < @liste_d_alias; $i++) { print ("\t$liste_d_alias[$i]\n"); }}coruscant%

Imprimer un fichier.


Autre exemple.

coruscant% perl -pe "" get.pl#!/usr/bin/perlprint ("Donnez moi une adresse ethernet :\n");$adresse_de_la_machine = <STDIN>;$adresse_de_la_machine =~ s/^\s+|\s+$//g;@bytes = split (/\./, $adresse_de_la_machine);$adresse = pack ("C4", @bytes);if (!(($nom, $alias, $type_adressage, $longueur,@liste_d_adresses) = gethostbyaddr ($adresse, 2))) { die ("Address $adresse_de_la_machine notfound.\n");}print ("Le nom principal de la machine est $nom\n");if ($alias ne "") { print ("Les alias de la machine sont :\n"); @liste_d_alias = split (/\s+/, $alias); for ($i = 0; $i < @liste_d_alias; $i++) { print ("\t$liste_d_alias[$i]\n"); }}coruscant%

Imprimer un fichier.


Les expressions régulières.

But Perl has often been tagged as a language in which it's easyto write programs that are difficult to read, and it's no secret thatregular expression syntax that has been the chief culprit.

Funny that other languages have been borrowing Perl's regularexpressions as fast as they can…

Larry Wall.Apocalypse 5.


Définition.

Une expression régulière va chercherl'occurrence d'un modèle sur une cible.

Trois opérations sont disponibles :Recherche.Substitution.Traduction.

L'opération de recherche est symbolisée par l'opérateur m//.L'évaluation est une valeur "vrai" ou "faux"..

La substitution est symbolisée par l'opérateur s///.Elle substitue un modèle à un autre.

La traduction est symbolisée par l'opérateur tr///. Elle traduit un jeu de caractères en un autre.


La substitution.

Permet de changer un modèle en un autre.L'opération de substitution (s) en est la forme la plus élémentaire.

s/ancien/nouveau/

L'extension g force la substitution à être générale.L'extension i permet de ne pas tenir compte de la case.L'extension e évalue la partie droite comme une instruction.


L'opération de recherche.

L'opération de recherche (m//) permet de determiner la présence d'unmodèle sur une cible.

Par exemple, trouver un modèle spécifique sur l'ensemble des lignesd'un fichier.

Les options principales sont :

g pour trouver toutes les occurrences du modèle sur la cible.

i pour ne pas tenir compte des majuscules/minuscules.


L'opération de traduction.

L'opération de traduction (tr///) permet de changer les caractèresde manière individuelle dans une chaîne

tr/ensemble_1/ ensemble_2/;

La traduction se fait caractère par caractère, chaque élément del'ensemble 1 étant traduit en l'élément correspondant del'ensemble 2.

Les options sont :

c Pour complémenter l'ensemble de caractères.La traduction se fera pour les caractères qui ne figurent pas dans l'ensemble spécifié.

d pour retirer tout caractère du premier ensemble qui n'apas de caractère correspondant dans la liste deremplacement.

s Pour ne traduire qu'une seule instance du caractère.


La chaîne cible.

Si elle n'est pas spécifiée, ce sera $_ qui sera utilisé.

On spécifie une cible au moyen de l'opérateur de soumission : =~

Les opérateurs de recherche (m//) et de substitution (s///) évaluentles variables présentes, tant en recherche qu'en substitution.

Essentiellement, une expression régulière est un gabarit ou un modèlede recherche dans une chaîne.

Il se présente entre deux slashes: /expression_régulière/

Le contenu est:Du texte ordinaire qui doit s'accorder à un modèle(ou un sous modèle) exact.Des caractères spéciaux pour contrôler comment l'accord doit s'effectuer.


Les caractères spéciaux.

\ Pour supprimer l'évaluation du caractère spécial qui suit.^ Pour ancrer l'évaluation en début de ligne.. Pour évaluer tout caractère (sauf \n).$ Pour ancrer l'évaluation en fin de ligne.() Pour regrouper ou mémoriser.[] Pour définir des ensembles.


Quelques exemples.

Le point (.) est le caractère le plus simple et la forme la pluscommune dans la recherche de modèle.Il force l'évaluation de tout caractère (hormis \n) à l'emplacementou il se trouve.

/b.t/ reconnaît bat, bit, but, bot, bgt ....

Les crochets ([..]) permettent de définir un ensemble de caractères.L'évaluation portera sur n'importe quel des caractères de l'ensembleà l'emplacement spécifié.

/b[aiu]t/ ne reconnaît que bat, bit or but.


Ensembles de caractères.

[012345679] # N'importe quel chiffre.[0-9] # Pareil, n'importe quel chiffre. [a-z] # N'importe quelle lettre minuscule.[a-zA-Z] # N'importe quelle lettre.[0-9+-] # 0-9 et les signes + et -.

L'accent circonflexe (^) complémente l'ensemble. [^0-9] # Tout sauf un chiffre.

[^aeiouAEIOU] # tout sauf une voyelle.

Les caractères de contrôle\d :chiffre.\s : espace.\w : caractère mot.\D : complément de \d \S : complément de \s \W : complément de \w.


Mémorisation de la position courante.

La position courante dans une chaîne après une opération m//est accessible au moyen de la fonction pos().L'argument par défaut est la variable $_.

coruscant% cat text.txt#!/usr/bin/perl$c = "catggtctgcaatcaggacattccagtat";$c =~ m/caat/g;print (pos($c),"\n");coruscant% prog.pl13coruscant%

L'extension c permet de gérer cette valeur.Si elle est activée, la position précédente est conservée en casd'échec d'une nouvelle recherche.Si elle n'est pas activée, un echec dans une nouvelle rechercheretournera la valeur "undef".


Option c.

coruscant% cat text.txt#!/usr/bin/perl$c = "catggtctgcaatcaggacattccagtat";$m = "caat";$c =~ m/$m/g;print ("Cible : $c\n");print ("Modele $m trouve en : ", pos($c),"\n");$m = "bofff";$c =~ m/$m/gc;print ("Option c activee.\n");print (" Modele $m trouve en : ",pos($c),"\n");$c =~ m/$m/g;print ("Option c desactivee.\n");print (" Modele $m trouve en : ",pos($c),"\n");coruscant% prog.plCible : catggtctgcaatcaggacattccagtatModele $m trouve en : 13Option c activee.Modele $m trouve en : 13Option c desactivee.Modele $m trouve en :coruscant%


Les quantifieurs.

Les quantifieurs standards sont : * Evaluation de 0 à n fois.+ Evaluation de 1 à n fois.? Evaluation de 0 ou 1 fois.{n} Evaluation de exactement n fois.{n,} Evaluation de au moins n fois.{n,m} Evaluation de au moins n fois et au plus m fois.

Dans tout autre contexte, les accolades seront traitées commedes caractères standards.

* est équivalent à {0,}+ est équivalent à {1,}? est équivalent à {0,1}.

Les valeurs de n et m sont entières et limitées à 65535.


La "cupidité".

Les expressions régulières sont considérées comme "cupides".Cela signifie qu'elles vont pousser l'évaluation aussi loin que possibleà partir du point de départ.

Pour inverser cette tendance, et brider l'évaluation, le quantificateurdoit être suivi d'un "?".

Seule sera affectée la manière dont sera faite l'évaluation.La signification ne change pas.

* Evaluation de 0 à n fois.+ Evaluation de 1 à n fois.? Evaluation de 0 ou 1 fois.{n} Evaluation de exactement n fois.{n,} Evaluation de au moins n fois.{n,m} Evaluation de au moins n fois et au plus m fois.


Quelques exemples simples.

me*t Evaluation de mt, met, meet, meeet etc (.+) Evaluation "jocker", n'importe quel nombre de caractères. m.*k Evaluation de mk, mak, milk, mandrak, etc. lo+t Evaluation de lot, loot, looot etc.f[ai]+t Evaluation de fat, fit, fait, fiat,faaiit etc. but not fk. bi?t Evaluation de bt or bit only. b.?t Evaluation de bt, bat, bbt, etc.ou{3}t Evaluation de ouuut only. ra{1,4}t Evaluation de rat, raat, raaat and raaaat only.


Parenthèses et mémorisation.

On utilise les parenthèses pour forcer la priorité d'évaluation.

(abc)* Evaluation de " ",abc, abcabc, abcabcabc,..... (a|b)(c|d) Evaluation de ac, ad,bc,bd

Elles sont aussi utilisées pour mémoriser des modèles.

Le nom du modèle mis en mémoire est$1, $2, …, $9 dans le champ substitution.\ 1, \2, …, \9 dans le champ de recherche.

$`, $&, et $' mémorisent de manière automatique :$` La chaîne qui précède le modèle reconnu.$& La chaîne représentative du modèle reconnu.$' La chaîne qui suit le modèle reconnu.


Exemples.

coruscant% cat prog.pl#!/usr/bin/perl$_ = "Food is on the foo table.";if ( /\b(foo)\s+(\w+)/i ) { print "$2 follows $1.\n";}coruscant% prog.pltable follows foocoruscant% cat prog.pl$_ = "The food is under the bar in the barn.";if ( /foo(.*)bar/ ) { #greedy print "got <$1>\n";}coruscant% prog.plgot <d is under the bar in the >coruscant% cat prog.pl$_ = "The food is under the bar in the barn.";if ( /foo(.*?)bar/ ) { #not greedy print "got <$1>\n"}coruscant% prog.plgot <d is under the >coruscant%


Quelques variations autour d'un exemple.coruscant% cat prog.pl#!/usr/bin/perl$_ = "On a 2 nombres: 53147";@pats = qw{ (.*)(\d*) (.*)(\d+) (.*?)(\d*) (.*?)(\d+) (.*)(\d+)$ (.*?)(\d+)$ (.*)\b(\d+)$ (.*\D)(\d+)$};for $pat (@pats) { printf "%-12s ", $pat; if ( /$pat/ ) { print "<$1> <$2>\n"; } else { print "ECHEC\n"; }}coruscant%

coruscant% prog.pl(.*)(\d*) <On a 2 nombres: 53147> <>(.*)(\d+) <On a 2 nombres: 5314> <7>(.*?)(\d*) <> <>(.*?)(\d+) <On a > <2>(.*)(\d+)$ <On a 2 nombres: 5314> <7>(.*?)(\d+)$ <On a 2 nombres: > <53147>(.*)\b(\d+)$ <On a 2 nombres: > <53147>(.*\D)(\d+)$ <On a 2 nombres: > <53147>coruscant%


L'évaluation.

coruscant% cat prog.pl#!/usr/bin/perl$string = "0abc1";print "$string\n";$string =~s/[a-zA-Z]+/$& x 5/e;print "$string\n";coruscant% prog.pl0abc10abcabcabcabcabc1coruscant%


Autre exemple.

coruscant% cat text.txtNombre entier Un : 1.Nombre entier Deux : 2.Nombre entier Quatre : 4.Nombre entier Huit : 8.Grand entier : 100.Ca, c'est vrai : 250 x 3 = 750.La date d'aujourd'hui : 31 Mars 2006coruscant% cat prog.pl#!/usr/bin/perl@ARGV =("text.txt");while ($line = <>) { $line =~s/\d+/$& * 2/eg; print "$line";}coruscant% prog.plNombre entier Un : 2.Nombre entier Deux : 4.Nombre entier Quatre : 8.Nombre entier Huit : 16.Grand entier : 200.Ca, c'est vrai : 500 x 6 = 1500.La date d'aujourd'hui : 62 Mars 4012coruscant%


Gérer les espaces.

$x =~ s/^\s+//;Supprime les espaces en début de chaîne.

$x =~ s/\s+/ /;Remplace tous les espaces multiples en un espace simple..

$x =~ s/\s+$//;Supprime les espaces en fin de chaîne.


A propos des ancrages.

Deux ancrages fixes vus précédemment:^ Pour ancrer l'évaluation en début de ligne.$ Pour ancrer l'évaluation en fin de ligne.

Il est possible de jeter l'ancre quelque part dans la chaîne.L'ancre est alors \G.exemple, soit à compter le nombre de a dans une chaîne donnée.

coruscant% cat text.txt#!/usr/bin/perl$c = "catggtctgcaatcaggacattccagtat";$x = () = ($c =~ m/.*?a/g);print ("Methode 1. Nombre de a : $x\n");$y++ while ($c =~ m/\G.*?a/g);print ("Methode 2. Nombre de a : $y\n");$c =~ s/.*?a/$z++/ge;print ("Methode 3. Nombre de a : $z\n");coruscant% prog.plMethode 1. Nombre de a : 8Methode 2. Nombre de a : 8Methode 3. Nombre de a : 8coruscant%


Changement de délimiteur.

Le délimiteur standard est le slash (/).Si il devient motif de recherche, dans une URL par exemple,il est nécessaire de le faire précéder d'un antislash (\ /).

if( $v =~ m/http:\/\/\w+\/(\w+\/)*\w\.html/ )

Il est alors plus simple de changer le séparateur.

if( $v =~ m=http://\w+/(\w+/)*\w\.html= )

Ici, c'est le signe = qui devient le séparateur.

Séparateur.


Les fonctions.

coruscant% cat prog.pl#!/usr/bin/perl# Function declarationsub say_hello { print ("Hello World.\n");}say_hello;coruscant% prog.plHello World.coruscant% cat prog.pl#!/usr/bin/perl# Function declarationsub say_hello { print ("Hello World.\n");}$a = say_hello;print "Value of a : $a.\n";coruscant% prog.plHello World.Value of a : 1.coruscant%

coruscant% cat prog.pl#!/usr/bin/perl# Function declarationsub square { $x **=2;}$x = 9;print "Value of x : $x.\n";square;print "Value of x : $x.\n";coruscant% prog.plValue of x : 9.Value of x : 81.coruscant%


La valeur de retour.

coruscant% cat prog.pl#!/usr/bin/perl$x=10;$y=2;$a = exp;print "Value of a : $a\n";# function declarationsub exp { $x ** $y;}coruscant% prog.plValue of a : 100.coruscant% cat prog.pl#!/usr/bin/perl$x=10;$y=2;@a = liste;print " Value of a : @a\n";# function declarationsub liste { ($x,$y);}coruscant% prog.plValue of a : 10 2coruscant%

coruscant% cat prog.pl#!/usr/bin/perl$x=10;$y=2;$a = max;print "Maximum of $x and $y is $a.\n";# function declarationsub max { if ($x > $y) { $x; } else { $y };}coruscant% prog.plMaximum of 10 and 2 is 10.coruscant%

La valeur retournée est toujours ladernière valeur évaluée.


Un exemple.

coruscant% cat prog.pl#!/usr/bin/perl$sum = 0;@numbers = read;foreach $nb (@numbers) { $sum += $nb;}$lg = @numbers;$m = $sum / $lg;print ("\nThe sum of the $lg elements of the list is $sum.\n");print ("Average value is $m.\n");sub read { $line = <stdin>; $line =~s/^\s+|\s*\n$//g; #to remove all spaces at head and tail. split(/\s+/,$line);}coruscant% prog.pl1 2 3 4 5 6 7 8 9

The sum of the 9 elements of the list is 45.Average value is 5.coruscant%


L'instruction "return".coruscant% cat prog.pl#!/usr/bin/perl$total = add;if ($total eq "Error") { print ("No data found.\n");} else{ print ("The sum of the elements of the list is $total.\n");}sub add { $sum = 0; $line = <stdin>; $line =~s/^\s+|\s*\n$//g; return ("Error") if (!$line); @numbers = split(/\s+/,$line); $index = 0; while ($numbers[$index]){ $sum += $numbers[$index++]; } return($sum);}coruscant% prog.pl1 2 3 4 5 6 7 8 9The sum of the elements of the list is 45.coruscant%

No data found.coruscant%

return ($value);


La fonction wantarray().

Il est parfois nécessaire de savoir si une procédure doit travaillersur une liste ou sur un scalaire.En fait, connaître le type de la valeur à retourner.La fonction wantarray va permettre d'effectuer ce test.

Syntaxe : $resultat = wantarray();

$resultat est undef si la procédure doit retourner un scalaire.$resultat est différent de undef si la procédure doit retourner une liste.


Exemple.

coruscant% cat prog.pl#!/usr/bin/perlprint ("Affectation du résultat à une liste.\n");@liste = &ma_procedure;print ("Affectation du résultat à un scalaire.\n");$scalaire = &ma_procedure;

sub ma_procedure { if (wantarray()) { print ("La variable de retour doit etre une liste.\n\n"); } else{ print ("La variable de retour doit etre un scalaire.\n\n"); }}coruscant% prog.plAffectation du résultat à une liste.La variable de retour doit etre une liste.

Affectation du résultat à un scalaire.La variable de retour doit etre un scalaire.coruscant%


Les variables "my".

Permettent de déclarer des variables privées.

my $p;my $x = 119;my ($x, $y, $z, @args) = (5, 23, @_);

{ my $x

}

$x est connu dans ce blocet inconnu à l'extérieur de ce bloc.

$x est inconnu dans ce bloc.

$x est inconnu dans ce bloc.


Exemple.

coruscant% cat prog.pl#!/usr/bin/perlsub sp1() { $i = 10;}sub sp2() { my $i; $i = 10;}print ("Without the my \$i\n");$i = 100;print (" Before calling : \$i = $i\n");&sp1;print (" After calling : \$i = $i\n");print ("\n");print ("With the my \$i\n");$i = 100;print (" Before calling : \$i = $i\n");&sp2;print (" After calling : \$i = $i\n");coruscant% prog.pl

coruscant% prog.plWithout the my $i Before calling : $i = 100 After calling : $i = 10

With the my $i Before calling : $i = 100 After calling : $i = 100coruscant%


Propriétés des variables "my".

Soient les programmes suivants :coruscant% cat prog.pl#!/usr/bin/perlfor (1 .. 5) {my $x; $x++; print "x = $x\n";}coruscant% prog.plx = 1x = 1x = 1x = 1x = 1coruscant%

Chaque fois qu'unevariable est déclarée"my", une nouvelleinstance est créée.

Ce type de mécanisme se révèle utile lorsqu'une fonction doitmémoriser une valeur au fur et à mesure de ses appels successifs.

Par exemple, voyons comment on génère une valeur aléatoire.L'algorithme standard part avec une valeur initiale (la racine) etgénère un premier nombre. C'est ce nombre (étape i) qui sera utiliséà l'étape suivante (i+1) pour générer la nouvelle valeur.

coruscant% cat prog.pl#!/usr/bin/perlmy $x;for (1 .. 5) { $x++; print "x = $x\n";}coruscant% prog.plx = 1x = 2x = 3x = 4x = 5coruscant%


Application.

Soit le programme suivant :

coruscant% cat prog.pl#!/usr/bin/perl$x = 1;sub rand { $x = int(($x * 1103515245 + 12345) / 65536) % 32768; return $x;}for (1..9){ print ("Step $_, New number : ",&rand,"\n");}coruscant% prog.plStep 1, New number : 16838Step 2, New number : 14666Step 3, New number : 10953Step 4, New number : 11665Step 5, New number : 7451Step 6, New number : 26316Step 7, New number : 27974Step 8, New number : 27550Step 9, New number : 31532coruscant%

Le problème provient dufait que $x est unevariable globale.

N'importe qui peut enmodifier la valeur etaltérer la génération desnombres de la suite.


Mauvaise solution.

coruscant% cat prog.pl#!/usr/bin/perl$x = 1;sub rand { my $x; $x = int(($x * 1103515245 + 12345) / 65536) % 32768; return $x;}for (1..9){ print ("Step $_, New number : ",&rand,"\n");}coruscant% prog.plStep 1, New number : 0Step 2, New number : 0Step 3, New number : 0Step 4, New number : 0Step 5, New number : 0Step 6, New number : 0Step 7, New number : 0Step 8, New number : 0Step 9, New number : 0coruscant%

$x est déclaré"my" àl'intérieur dubloc de lafonction.$x est bienprotégé, mais àchaque appelde la fonctionune nouvelleinstance de lavariable estcréée, etcomme aucunevaleur lui a étéaffectée, elleprendra "undef"(0).


Bonne solution.

coruscant% cat prog.pl#!/usr/bin/perl{ my $x = 1; sub rand { $x = int(($x * 1103515245 + 12345) / 65536) % 32768; return $x; }}for (1..10){print ("Step $_, New number : ",&rand,"\n");}coruscant% prog.plStep 1, New number : 16838Step 2, New number : 14666Step 3, New number : 10953Step 4, New number : 11665Step 5, New number : 7451Step 6, New number : 26316Step 7, New number : 27974Step 8, New number : 27550Step 9, New number : 31532coruscant%

Déclarer lavariablecomme "my"dans un blocexterne à lafonction maisqui la contient.Les deuxobjets fontpartie d'unmême bloc,etcomme $xn'est vu que àl'intérieur dubloc enquestion,seule lafonction peutle modifier.


Les fonctions récursives.

coruscant% cat prog.pl#!/usr/bin/perlsub x { my ($y) = @_[0]; return ($y == 1)?1:$y + &x($y - 1);}

$r = &x(5);print ("Result : $r.\n");coruscant% prog.plResult : 15.coruscant%

Une nouvelle instance de $y estcréée à chaque appel de lafonction.

Ainsi, une pile de variablesprivées se constitue.


La fonction d'Ackerman.

coruscant% cat prog.pl#!/usr/bin/perlsub ack { my ($m,$n) = @_; return ($m == 0)?$n+1:($n == 0)?&ack($m-1, 1):ack($m-1, ack($m, $n-1));}$td = time;$r = &ack(3,8);$t = time - $td;print ("Result : $r.\n");print ("Execution time : $t seconds.\n");coruscant% prog.plResult : 2045.Execution time : 15 seconds.coruscant%

C'est une fonction définie sur N * N.Sa valeur est :

ack(m, n) ack(m, n)Si m = 0, ack(0, n) = n+1,Sinon, si n=0, ack(m, 0) = ack(m-1, 1)Sinon ack(m, n) = ack(m-1, ack(m, n-1))


Les références.

Une référence est ce que l'on appelle généralement un pointeur.

Il est ainsi possible de référencerun scalaire.une liste.un hash.une fonction.

coruscant% cat prog.pl#!/usr/bin/perl$valeur = 100;$pointeur = \$valeur;print ("\nLe pointeur d'adresse $pointeur,\n");print ("désigne la variable $valeur.\n");print ("\nLa référence *($pointeur),\n");print ("pointe sur la variable $$pointeur.\n");coruscant% prog.plLe pointeur d'adresse SCALAR(0xa463be4),désigne la variable 100.

La référence *(SCALAR(0xa463be4)),pointe sur la variable 100.coruscant%

En résumé, unpointeur $pointeurréfère à unevariable \$valeur.

$pointeur contientalors la référence(l'adresse de lavariable) qui peutalors être atteintepar l'intermédiairedu pointeur$$pointeur.


Les diverses références

Il y a 5 types de références qui sont :Référence à un scalaire.Référence à une liste.Référence à un hash.Référence à une fonction.Référence à une autre référence.

Il existe une cinquième référence, la référence à un global.Le "typeglob" (type global) est un type interne qui permet dereprésenter toute une table de symboles.Le préfixe d'un typeglob est * car il représente tous les types.C'est une bonne manière de passer des listes et des hash parréférence à une fonction. Toutefois, comme il est possibled'utiliser les vraies références, ce mécanisme n'est pas trèsutile.


Le type "global".

Passer ou stocker les noms de fichiers.La sauvegarde d'un descripteur de fichier peut se faire par :

$fichier = *ENTREE;Ou comme une vraie référence :

$fichier =\*ENTREE;

Moyen facile pour créer un descripteur de fichier local :Sub ouvrir { my $chemin = shift; local *DESC; open (DESC, $chemin); return \*DESC;}

$desc = ouvrir ('/usr/bin/perl');


Alias par un type "global".

Déclarer un alias entre deux entrées symboliques.*objet = *outil;

Etablit une relation entre tout ce qui s'appelle objet et tout ce quis'appelle outil. Les deux noms deviennent synonymes.

Il est aussi possible de limiter l'alias à un seul type de variable.

*objet = #$outil;

Synonymie entre $objet et $outil

@objet et %objet sont respectivement différents de @outil et %outil.


Les variables spéciales

$_ Variable scalaire standard prédéfinie.$. Numéro de la ligne courante d'un fichier.$/ Séparateur standard d'un fichier en entrée. (\n).$, Séparateur standard des éléments de la fonction print(). ("").$# Format d'impression par défaut des nombres. (%.20g)$~ Nom du format actif.$| Contrôle de la purge des buffers.$$ Numéro du processus père de l'interpreteur.$& Dernier modèle trouvé dans une expression régulière.$` Chaîne qui précède le modèle dans une expression régulière.$' Chaîne qui suit le modèle dans une expression régulière.$0 Nom du programme Perl.$] Version de l'interpréteur Perl.$@ Erreur de syntaxe de la dernière fonction eval().


Le module "english.pm".C'est un module qui va permettre de rendre les scripts pluslisibles en donnant des noms compréhensibles aux variablesprédéfinis.

$_ $ARG$. $INPUT_LINE_NUMBER ou $NR$/ $INPUT_RECORD_SEPARATOR ou $RS$, $OUTPUT_FIELD_SEPARATOR ou $OFS$" $LIST_SEPARATOR$~ $FORMAT_TOP_NAME$| $OUTPUT_AUTOFLUSH$$ $PROCESS_ID or $PID$& $MATCH$` $PREMATCH$' $POSTMATCH$0 $PROGRAM_NAME$] $PERL_VERSION$@ $EVAL_ERROR


Les références.

Perl propose deux mécanismes pour procéder au référencementd'un objet (scalaire, liste, hash ou procédure.

Dans le cas d'une référence symbolique, la référence qui est unevaleur scalaire est prise pour le nom d'une variable et non commeun lien vers cette variable.

La référence en dur par contre, ne se réfère pas au nom d'une autrevariable qui ce serait que le conteneur du nom, mais à une vraievaleur qui contient un lien permettant d'accéder à son contenu.


Les références symboliques.Une référence qui n'est pas une référence 'en dur' représente uneréférence symbolique.C'est une référence qui a une valeur scalaire et qui est prise pourun nom de variable et non pas pour un lien direct vers une valeur.coruscant% cat prog.pl#!/usr/bin/perl -w$a = 3.14159;$b = "a";print ("La valeur de \$b est : $b\n");print ("La reference symbolique \$\$b contient $$b\n");coruscant% prog.plLa valeur de $b est : aLa reference symbolique $$b contient 3.14159coruscant%

On peut aussi écrire $$b sous la forme ${$b}.coruscant% cat prog.pl#!/usr/bin/perl -w$a = 3.14159;$b = "a";print ("La reference symbolique \${\$b} contient ${$b}\n");coruscant% prog.plLa reference symbolique ${$b} contient 3.14159coruscant%


Exemple de référence symboliques.

coruscant% cat prog.pl#!/usr/bin/perl$un = 1;$deux = 2;$trois = 3;$quatre = 4;$cinq = 5;print ("Nom de la variable à lire : ");chop ($nom = <stdin>);print ("La variable $nom contient la valeur ${$nom}\n");coruscant% prog.plNom de la variable à lire : quatreLa variable quatre contient la valeur 4coruscant%


Les références en dur.

$RefScal = \$scalaire$RefLis = \@liste$RefHash = \%hash$RefGlobl = \*Desc$RefFunc = \&fonct$RefRef = \$$Refer

${RefScal} est une valeur scalaire.${RefLis} est une valeur de liste.${RefHash} est une valeur de hash.Juste pour mémoire…${RefFunc} est l'emplacement d'une fonction.${${RefScal}} est une valeur scalaire.


Référence à une liste.

coruscant% cat prog.pl#!/usr/bin/perl@liste = ("Zero","Un","Deux","Trois","Quatre");$pointeur = \@liste;print ("\nLe pointeur d'adresse $pointeur,\n");$nb_elements = @$pointeur;print ("Pointe sur une liste de $nb_elementséléments.\n");$i = 0;foreach (@$pointeur) { print ("L'élément $i vaut$$pointeur[$i++].\n");}coruscant% prog.plLe pointeur d'adresse ARRAY(0xa461600),Pointe sur une liste de 5 éléments.L'élément 0 vaut Zero.L'élément 1 vaut Un.L'élément 2 vaut Deux.L'élément 3 vaut Trois.L'élément 4 vaut Quatre.coruscant%


Référence à un hash.

coruscant% cat prog.pl#!/usr/bin/perl%mois = ('01'=>'Jan','02'=>'Feb','03'=>'Mar','04'=>'Apr','05'=>'May','06'=>'Jun', '07'=>'Jul','08'=>'Aug','09'=>'Sep','10'=>'Oct','11'=>'Nov','12'=>'Dec' );$pointeur = \%mois;print ("\nLe pointeur $pointeur fait reference à un hash.\n");print ("En voici le contenu trie par rapport aux cles.\n");foreach $i (sort keys %$pointeur) { printf ("$i est $$pointeur{$i} \n");}coruscant% prog.plLe pointeur HASH(0xa46151c)fait reference à un hash.En voici le contenu trie par rapport aux cles.01 est Jan02 est Feb03 est Mar04 est Apr05 est May06 est Jun07 est Jul08 est Aug09 est Sep10 est Oct11 est Nov12 est Deccoruscant%


Accolades.Nous avons vu dans les références symboliques l'équivalencede $$x et ${$x}.En fait, pour un identificateur, il est équivalent d'écrire $x et ${x}.coruscant% cat prog.pl#!/usr/bin/perl$x = 10;print "$x\n";print "${x}\n";coruscant% prog.pl1010coruscant%

On peut même utiliserdes mots réservés !coruscant% cat prog.pl#!/usr/bin/perl$until = "Mot reserve.";print "$until\n";print "${until}\n";coruscant% prog.plMot reserve.Mot reserve.coruscant%

Historiquement, cette utilisation des accolades est celle des shellsUnix qui délimitent de cette manière le nom d'une variable du texte.


En résumé.

coruscant% cat prog.pl#!/usr/bin/perl$a = 10;$b="a";$c = \$b;print ("Dereferencement symbolique : $$b.\n");print ("Dereferencement en dur : $$c.\n");print ("Dereferencement en dur puis symbolique : $$$c.\n");coruscant% prog.plDereferencement symbolique : 10.Dereferencement en dur : a.Dereferencement en dur puis symbolique : 10.coruscant%


Les structures anonymes.

Les crochets et le accolades permettent la création de référencesanonymes vers des listes ou des hash.

$refliste = [1,2,3,4,5];

$refhash = {"Adam" => "Eve", "Cyrano" => "Roxanne", "Protis" => "Gyptis"};


La liste anonyme.

coruscant% cat prog.pl#!/usr/bin/perl$refliste = [0,1,2,3,["a","b","c"],5];print "Valeur du scalaire : $refliste\n";foreach $r (@$refliste){ print ("$r\n")}coruscant% prog.plValeur du scalaire : ARRAY(0x224fd0)0123ARRAY(0x224ec8)5coruscant%


Accès à la liste.coruscant% cat prog.pl#!/usr/bin/perl$refl = [0,1,2,3,["A","B","C"],5];print "Valaur du scalaire : $refliste\n";for (;$i<@$refl;$i++) { if ($$refl[$i] =~ /ARRAY/) { print (" Niveau 2.\n"); for ($j=0;$$refl[$i][$j];$j++){ print (" $$refl[$i][$j]\n") } next; } print (" $$refl[$i]\n");}

coruscant% prog.plValeur du scalaire : ARRAY(0x224fd0)0123 Niveau 2. A B C5coruscant%


Le hash anonyme.

coruscant% cat prog.pl#!/usr/bin/perl$refh = {"Adam" => "Eve", "Cyrano" => "Roxanne", "Protis" => "Gyptis"};

#@k = sort(keys(%$refh));

foreach $a(sort(keys(%$refh))) { print "$a est avec $$refh{$a}\n";}coruscant% prog.plAdam est avec EveCyrano est avec RoxanneProtis est avec Gyptiscoruscant%


L'opérateur ->.Opérateur flèche.Méthode de déréférencement pour

les hashs.les tables de référence.

Facilite l'accès aux éléments individuels de tableaux.D'autant plus vrai que l'expression de référence est plus compliquée.

$$semaine[3] = "Mercredi";${$semaine}[3] = "Mercredi";$semaine->[3] = "Mercredi";

$$nb_jours{"Aout"} = 31;${$nb_jours}{"Aout"} = 31;$ nb_jours->{"Aout"} = 31;

Dans la dernière notation, le premier $ manque.Il est implicite, ce qui interdit d'utiliser cette notation pour référencerautre chose que des valeurs scalaires.Toutefois, comme pour la seconde notation, il est possible d'utiliser,à gauche de l'opérateur flèche (->) n'importe quelle expression, ycompris un autre déréférencement.Dans ce cas, les opérateurs flèche associent de gauche à droite.

exemple : print ("$table[5]->{"matiere"}->[2]");


Exemple.coruscant% cat prog.pl#!/usr/bin/perl@semaine = qw(lundi mardi mercredi jeudi vendredi samedi dimanche);$x = \@semaine;print "$x\n";print " $$x[3]\n";print " ${$x}[2]\n";print " $x->[6]\n";%semaine = (1=>"lundi",2=>"mardi",3=>"mercredi",4=>"jeudi", 5=>"vendredi",6=>"samedi",7=>"dimanche");$y = \%semaine;print "$y\n";print " $$y{3}\n";print " ${$y}{2}\n";print " $y->{6}\n";coruscant% prog.plARRAY(0x1824270) jeudi mercredi dimancheHASH(0x182c6b0) mercredi mardi samedicoruscant%


L'opérateur ->.

Il ne revient pas au même d'écrire $table[5] et $table->[5].

$table[5]représente le sixième élément (0 .. 5)de la liste @table

$table->[5]est le sixième élément (0 .. 5)d'une liste dont la référencese trouve dans le scalaire$table

$table[0]$table[1]$table[2]$table[3]$table[4]$table[5]

$vecteur[0]$vecteur[1]$vecteur[2]$vecteur[3]$vecteur[4]$vecteur[5]

ARRAY(0xa461600)$table

@table


Application.coruscant% cat prog.pl#!/usr/bin/perl@liste = qw(lundi mardi mercredi jeudi vendredi samedi dimanche);@mois = qw(Jan Fev Mar Avr Mai Jui Jul Aou Sep Oct Nov Dec);$liste = \@mois;print "\$liste[3] represente $liste[3].\n";print "\$liste->[3] represente $liste->[3].\n";coruscant% prog.plARRAY(0x1824270)$liste[3] represente jeudi.$liste->[3] represente Avr.coruscant%


L'opérateur ->.La référence $table[5]->{"matiere"}->[2]est légale même si $table[5] n'existe pas.

@table est une liste de références dans laquelle chaque élément$table[$i] est une référence à un hash dans lequel la clé "matière"est l'entrée d'une référence à une table.

Il s'agit d'un contexte spécial ou la référence n'en est pas vraimentune. Elle ne se mettra à exister que si on la déréférence dansun contexte qui suppose son existence.

On appelle cette méthode "Ce à quoi on s'attend"

$table[5] -> {"matiere"}->[2]

Peut aussi s'écrire $table[5] {"matiere"} -> [2]

L'opérateur flèche etant optionnel entre les indices délimitéspar des accolades ou des crochets.


L'opérateur ->.$table[5]->{"matiere"}->[2]

Si $table[5] n'existe pas, il sera automatiquement défini par uneréférence de hach afin de pouvoir y chercher "matiere".

$table[5]->{"matiere"} sera automatiquement défini par une référencevers une liste afin de pouvoir aller rechercher le troisième élément (2).Tout ceci ne se produit que lorsqu'on tente de créer l'élément.

Si on se contente d'y faire référence, on trouvera la valeur "undef".

HASH(0xa461600)

@table

ARRAY(0xa461600)

"matiere"


Matrices.

Dans une liste, chacun des éléments de la liste peut être un scalaireou une liste.

C'est ainsi que l'on peut créer des tables à plus d'une dimension.La référence à chacun des éléments de la table s'écrit :

$Nom_de_la_table -> [$Index]$Nom_de_la_table -> [$Index1] [$Index2]$Nom_de_la_table -> [$Index1] [$Index2] [Index3]

. . . . .


Matrices.coruscant% cat prog.pl#!/usr/bin/perl$table = ['Initiale',['1','2','3'] , ['4', '5', '6'], 'Finale'];print ("\n========== Début du test ==========\n");print "\$table->[0] = $table->[0] \n";print "\$table->[1][0] = $table->[1][0] \n";print "\$table->[1][1] = $table->[1][1] \n";print "\$table->[1][2] = $table->[1][2] \n";print "\$table->[2][0] = $table->[2][0] \n";print "\$table->[2][1] = $table->[2][1] \n";print "\$table->[2][2] = $table->[2][2] \n";print "\$table->[3] = $table->[3] \n";print ("=========== Fin du test ===========\n");coruscant% prog.pl========== Début du test ==========$table->[0] = Initiale$table->[1][0] = 1$table->[1][1] = 2$table->[1][2] = 3$table->[2][0] = 4$table->[2][1] = 5$table->[2][2] = 6$table->[3] = Finale=========== Fin du test ===========coruscant%


Autre exemple.coruscant% cat prog.pl#!/usr/bin/perl$table = ['Initiale',['1','2','3',['4', '5', '6']], 'Finale'];print ("\n========== Début du test ==========\n");print "\$table->[0] = $table->[0] \n";print "\$table->[1][0] = $table->[1][0] \n";print "\$table->[1][1] = $table->[1][1] \n";print "\$table->[1][2] = $table->[1][2] \n";print "\$table->[1][3][0] = $table->[1][3][0] \n";print "\$table->[1][3][1] = $table->[1][3][1] \n";print "\$table->[1][3][2] = $table->[1][3][2] \n";print "\$table->[2] = $table->[2] \n";print ("=========== Fin du test ===========\n");coruscant% prog.pl========== Début du test ==========$table->[0] = Initiale$table->[1][0] = 1$table->[1][1] = 2$table->[1][2] = 3$table->[1][3][0] = 4$table->[1][3][1] = 5$table->[1][3][2] = 6$table->[2] = Finale=========== Fin du test ===========coruscant%


Mauvaise solution.

coruscant% cat prog.pl#!/usr/bin/perl#Une solution qui ne marche pas.@a = (1..9);@b = ("A" .. "J");sub fonc {my (@chiffres,@lettres) = @_;print ("Les chiffres sont @chiffres. \n");print ("Les lettres sont @lettres. \n");}Fonc (@a, @b);coruscant% prog.plLes chiffres sont 1 2 3 4 5 6 7 8 9 A B C D E F G H I J.Les lettres sont .

coruscant%


Bonne solution.

coruscant% cat prog.pl#!/usr/bin/perl#la bonne manière d'opérer.@a = (1..9);@b = ("A" .. "J");sub fonc {my ($RefCh,$RefLe) = @_;print ("Les chiffres sont @{$RefCh}. \n");print ("Les lettres sont @{$RefLe}. \n");}fonc (\@a, \@b);coruscant% prog.plLes chiffres sont 1 2 3 4 5 6 7 8 9.Les lettres sont A B C D E F G H I J .

coruscant%


Le déréférencement.

Le passage de références peut être une source d'erreurs.Contrairement à d'autres langages moins regardants, perln'accepte pas de substituer un type à un autre lors d'undéréférencement.

Ca provoqueune erreur…

coruscant% cat prog.pl#!/usr/bin/perl#la bonne manière d'opérer.@a = (1..9);@b = ("A" .. "J");sub fonc {my ($RefCh,$RefLe) = @_;# On tente de déréférencer en scalaire ce qui a ete référencé en liste.print ("Les chiffres sont ${$RefCh}. \n");print ("Les lettres sont @{$RefLe}. \n");}fonc (\@a, \@b);coruscant% prog.plNot a SCALAR reference at ./test.txt line 8.coruscant%


Référence à une procédure.

On crée un pointeur sous la forme :$Pointeur_procedure = \&Nom_de_la_procedure;

coruscant% cat prog.pl#!/usr/bin/perl#Déclaration de la procédure.sub dire_bonjour { print ("Bonjour tout le monde.\n");}#Définition du pointeur vers la procédure.$rs = \&dire_bonjour;Appel de la procédure par l'intermédiaire dupointeur.&$rs;coruscant% prog.plBonjour tout le monde.coruscant%


Test de la référence.

coruscant% cat prog.pl#!/usr/bin/perl$a = 10;@b = ("A" .. "J");%c = (A,1,B,2,C,3,D,4,E,5);sub d {my ($RefCh,$RefLe) = @_; print ("Hello \n");}$A=\$a;$B=\@b;$C=\%c;$D=\&d;print ("Reference a un scalaire : $A.\n");print ("Reference a une liste : $B.\n");print ("Reference a un hash : $C.\n");print ("Reference a une fonction : $D.\n");coruscant% prog.plReference a un scalaire : SCALAR(0xd944).Reference a une liste : ARRAY(0xd974).Reference a un hash : HASH(0x11a5c).Reference a une fonction : CODE(0x11b04).coruscant%


Avec une expression régulière.

coruscant% cat prog.pl#!/usr/bin/perl$a = 10;@b = ("A" .. "J");%c = (A,1,B,2,C,3,D,4,E,5);sub d {my ($RefCh,$RefLe) = @_; print ("Hello \n");}$A = \$a;$A=~ s/$.*$//;$B = \@b;$B=~ s/$.*$//;$C = \%c;$C=~ s/$.*$//;$D = \&d;$D=~ s/$.*$//;print ("Reference a un scalaire : $A.\n");print ("Reference a une liste : $B.\n");print ("Reference a un hash : $C.\n");print ("Reference a une fonction : $D.\n");coruscant% prog.plReference a un scalaire : SCALAR.Reference a une liste : ARRAY.Reference a un hash : HASH.Reference a une fonction : CODE.coruscant%


La fonction ref().

La fonction ref() permet de tester le type de l'objet qui a étéréférence et, de ce fait, de le déréférencer sans problèmes.

coruscant% cat prog.pl#!/usr/bin/perl$a = 10;@b = ("A" .. "J");%c = (A,1,B,2,C,3,D,4,E,5);sub d {my ($RefCh,$RefLe) = @_; print ("Hello \n");}$A=\$a; print (ref($A),"\n");$B=\@b; print (ref($B),"\n");$C=\%c; print (ref($C),"\n");$D=\&d; print (ref($D),"\n");coruscant% prog.plSCALAR.ARRAY.HASH.CODE.coruscant%


Forcer l'interpolation de fonctions.

coruscant% cat prog.pl#!/usr/bin/perl

sub imp { return ("World.\n")}

print "Hello imp()\n";print "Hello ${\imp}\n"coruscant% prog.plHello imp()Hello World.coruscant%

Contraindre l'interpréteur à interpoler la valeur de retour d'une fonctionlorsque celle ci se trouve dans une chaîne de caractères.Condition impérative : que la substitution soit active (" " et pas ' ').


Forcer l'interpolation de fonctions.

coruscant% cat prog.pl#!/usr/bin/perlsub aster { return ("*" x $_[0])}@a = (1..9);print ("Voici un triangle d'asterisques :\n");foreach (@a) {print ("$_ ${\aster($_)}\n");}coruscant% prog.plVoici un triangle d'asterisques :1 *2 **3 ***4 ****5 *****6 ******7 *******8 ********9 *********coruscant%

Astuce :l'antislashtransforme lavaleur de retour enune référence.Le dollar et lesaccoladesdéréférencent enun scalaire que leprint interprète sansdifficulté.


Le sous programme anonyme.

On appelle sous programme anonyme un sous programme quine peut être appelé que par l'intermédiaire de la variable à partirde laquelle il a été construit.

Attention aupoint virgule.

coruscant% cat prog.pl#!/usr/bin/perl#Déclaration de la procédure.$reference = sub { print ("Bonjour tout le monde.\n");};#Appel de la procédure.&$reference;coruscant% prog.plBonjour tout le monde.coruscant%


Déréférencement de fonctions.On peur aussi déréférencer une fonction au moyen de l'opérateur ->

coruscant% cat prog.pl#!/usr/bin/perl#Déclaration de la procédure.$reference = sub { print ("Bonjour tout le monde.\n");};#Appel de la procédure.print ("Appel par &\$reference :\n");&$reference;print ("Appel par \$reference->() :\n");$reference->();coruscant% prog.plAppel par &$reference :Bonjour tout le monde.Appel par $reference->() :Bonjour tout le monde.coruscant%


Le sous programme anonyme.

Un sous programme anonyme agit comme une fermeture (closure)sur une variable déclarée my.

C'est à dire, en fait, sur des variables lexicalement visiblesdans la portée courante.

(revoir les propriétés de la déclaration my par rapport àcelles de la déclaration local).

La fermeture spécifie que si on définit une fonction anonymedans un contexte lexical donné, elle tournera dans ce contexteet dans ce contexte seulement, même si elle est appelée en dehorsde celui ci.

On est donc certain de conserver la même copie d'une variablelexicale, alors que d'autres instances de cette variable auront étécréées préalablement ou postérieurement.


Passage de paramètres.

Nous avons vu qu'il n'était pas possible de passer plus d'uneliste en paramètre, car la fonction n'est capable de se référerqu'à la liste standard @_ pour récupérer ses valeurs de travail.

Il est bien entendu possible au moyen des références de s'affranchirde cette contrainte.


Les fermetures.

Ceci permet de passer des arguments à un sous programme, au moment de la définition ou au moment de l'appel.De plus, nous pourrons déclarer des petits bouts de code dontl'exécution sera reportée à une date ultérieure.

coruscant% cat prog.pl#!/usr/bin/perl -wsub affiche {my $x = shift;return sub {my $y = shift; print "$x$y !\n";};}$h = affiche ("Ligne 1 du premier message,\n");$g = affiche ("Ligne 1 du second message\n");&$h ("Ligne 2 du premier message");&$g ("Ligne 2 du second message..");coruscant% prog.plLigne 1 du premier message,Ligne 2 du premier message !Ligne 1 du second messageLigne 2 du second message.. !coruscant%


Définition.

Si on définit une fonction anonyme dans un contexte particulier elles’exécutera toujours dans le contexte en question même si on lui faitréférence à partir d’un contexte différent.Ce comportement est indispensable pour mettre en place quelqueslignes de code qui seront appelées ultérieurement.coruscant% cat prog.pl#!/usr/bin/perlsub imp {

my $x = shift;return sub { my $y = shift; print "$x, $y!\n"; };

}$h = imp("Salut");$g = imp("Salutations");&$h("Monde");&$g("Terriens");coruscant% prog.plSalut, Monde!Salutations, Terriens!coruscant%


Comparaison.

Codeclassique.

coruscant% cat prog.pl#!/usr/bin/perlmy $bonjour = sub { print "Bonjour tout le monde.\n"; };$bonjour->(); # Impression du message.&$bonjour; # Autre impression du message.coruscant% prog.plBonjour tout le monde.Bonjour tout le monde.coruscant%

coruscant% cat prog.pl#!/usr/bin/perlsub bonjour {return sub { print "Bonjour tout le monde.";}}my $imp = bonjour();$imp->()coruscant% prog.plBonjour tout le monde.coruscant%

coruscant% cat prog.pl#!/usr/bin/perlsub bonjour { my $message = "Bonjour tout le monde";

return sub { print $message; }}my $imp = bonjour();$imp->()coruscant% prog.plBonjour tout le monde.coruscant%

Fermeture.


Explication.

Dans l'exemple qui vient d'être vu, la variable $x continue à faireréférence à la valeur qui a été passée à la fonction imp() en dépitdu fait que, ayant été déclarée privée (my $x), elle soit sortie ducontexte dans lequel elle est sensée exister.

C’est la définition de la fermeture.

Ainsi, lorsqu’on fait référence à la fonction anonyme à l’extérieurde son espace de définition (le bloc bonjour) elle continue a faireréférence à la valeur correcte de la variable $message.

La fonction anonyme crée une fermeture qui clôture la variablelexicale à laquelle elle fait référence.


Création de compteurs.

Voyons comment on peut créer un modèle de compteurs qui seraappelé simultanément dans plusieurs contextes.

coruscant% cat prog.pl#!/usr/bin/perlsub compte {

my $nb = shift;return sub { $nb++ }

}my $dix = compte(10);my $trois = compte(3);print $dix->(),"\n"; # Affiche 10print $dix->(),"\n"; # Affiche 11print $trois->(),"\n"; # affiche 3print $dix->(),"\n"; # affiche 12print $trois->(),"\n"; # affiche 4coruscant% prog.pl10113124coruscant%


Explication.

On créée deux fonctions de comptage.La première réalise un comptage à partir de 10,La seconde réalise un comptage à partir de 3.Elles sont totalement indépendantes et ont chacune leur valeurpropre car à chaque appel de la fonction compte(), Perl créée unenouvelle instance de la variable $nb qui se trouve enveloppéedans la fermeture qui est retournée.

$dix enveloppe la variable $nb initialisée à 10.$trois enveloppe une variable totalement différente initialisée à 3.


Autre problème intéressant.Gérer des intervalles de temps.

coruscant% cat prog.pl#!/usr/bin/perlfor (0..5) { # Recuperation d'une nouvelle heure a chaque appel. my $heure = time; # Creation de fonctions annonymes. push @heure, sub { $heure }; # Attente afin que chaque fonction ait une heure differente sleep 5;}foreach (0..5) { ($ss,$mm,$hh,$jj,$mo,$aa,$js,$ja,$st) = localtime($heure[$_]->()); print ("Appel numero $_, Il est $hh heures, $mm minutes, $sssecondes\n");}coruscant% prog.plAppel numero 0, Il est 15 heures, 21 minutes, 52 secondesAppel numero 1, Il est 15 heures, 21 minutes, 57 secondesAppel numero 2, Il est 15 heures, 22 minutes, 2 secondesAppel numero 3, Il est 15 heures, 22 minutes, 7 secondesAppel numero 4, Il est 15 heures, 22 minutes, 12 secondesAppel numero 5, Il est 15 heures, 22 minutes, 17 secondescoruscant%


Explication.

Ici, la première boucle créée cinq références à une copie de lafonction anonyme.

Chacune de ces références possède sa propre copie de lavariable privée $heure créée au moment ou on entre dansla boucle.

Chaque copie de cette variable est accessible par l’intermédiairede la copie de la fonction qui l’a créée et à laquelle elle est liée,Et ceci apparaît plus tard, lorsque dans le courant de l’exécutiondu programme, la variable en question est hors de vue.


Variables communes.

Les fermetures peuvent se partager un ensemble commun devariables.

On obtient ainsi un style de programmation qui ressemble à laprogrammation orientée objet.

Il est aussi possible de générer des fonctions dans le courantde l’exécution.


eval()

coruscant% cat prog.pl#!/usr/bin/perlsub genere { eval "sub { $_[0] }"; # Evaluation de la chaine.}while (<DATA>) { # Separation nom, operation

my ($name, $code) = split (/\s+/, $_, 2);$op{$name} = genere $code;

}for (sort keys %op) {

print "2 $_ 3 = ", $op{$_}->(2,3),"\n"; # arguments (2,3).}__DATA__add $_[0] + $_[1]sub $_[0] - $_[1]mul $_[0] * $_[1]div $_[0] / $_[1]max $_[0] > $_[1] ? $_[0] : $_[1]coruscant% prog.pl2 add 3 = 52 div 3 = 0.6666666666666672 max 3 = 32 mul 3 = 62 sub 3 = -1coruscant%

Utilisation de la fonction eval() pour créer desréférences à du code dont les instructionssont lues sur un fichier.


Expressions régulières.Soit une expression régulière pour laquelle le modèle à rechercherna sera spécifié qu'au moment de l’exécution.

On désire effectuer un tri parmi nos mails en déterminant parl'intermédiaire d'un fichier spécifique “ spam ” les entrées indésirables.

Il est possible de spécifier les modères au moment de l’exécution parinterpolation de variables dans les expressions régulières.Toutefois, ces expressions régulières seront recompilées à chaqueappel, ce qui est coûteux en temps.

Il existe une option /o qui permet de ne compiler qu’une fois uneexpression régulière qui contient une variable d’interpolation.

Mais, si on doit gérer plusieurs reconnaissances, on se trouve face àautre un problème, lors du changement de modèle.


Expression régulière verrouillée.

En utilisant une fermeture en combinaison avec la fonctiond’évaluation on pourra générer des sous programmes quiverrouilleront les expressions régulières avec un efficacitéet une flexibilité comparable avec celle obtenue pour lesexpressions spécifiées au moment de la compilation.


Exemple.

coruscant% cat prog.pl#!/usr/bin/perlsub const { my $pat = shift; eval 'sub { grep (/$pat/io, @_) }';}$cerche = const q(aaa|xxx$);@detect = $cherche->(<DATA>);print "Lignes detectees.\n";for (@detect) { print;}__DATA__Premiere ligne : aaaSeconde ligne : bbbTroisième ligne : cccQuatrieme ligne : XXXCinquieme ligne : fffSixieme ligne : xxxSeptieme ligne : iiiHuitieme ligne : AAANeuvieme ligne : ssscoruscant%

coruscant% prog.plLignes detectees.Premiere ligne : aaaQuatrieme ligne : XXXSixieme ligne : xxxHuitieme ligne : AAAcoruscant%


Explication.

La fonction const() est chargée de construire la fermeture à partirdu modèle qui lui est passé en paramètre et qui est récupérée dansla variable $pat.

La variable $cherche contient la référence de la fermeture qui vavérifier si le modèle est contenu ou non dans la cible.

En fin de compte, les lignes du fichier qui ont été sélectionnéesse retrouvent dans la liste @detect.

La clé de cette construction est l’utilisation de la fonctiond’évaluation de la chaîne dans le constructeur.

L’extension “ o ” dans l’expression régulière demande à ce quel'expression ne soit compilée qu’une fois et non pas à chaqueévaluation.


Les aliases.

Le passage d'arguments se fait par l'intermédiaire de la liste @_&Ma_Procedure (@La_liste_effective); . . . .sub Ma_Procedure {

my (@Liste_locale) = @_;. . . . .

}Problème si la liste à transmettre est très grande.La copie est coûteuse.La liste peut être passée en donnant la référence de son nom.

@La_liste_effective = (1 .. 1000000)&Ma_Procedure (*La_liste_effective);. . . . .sub Ma_Procedure {

my (*Liste_locale) = @_;. . . . .$longueur = @Liste_locale;

}


Explication.

Spécifier*La_liste_effective

au lieu de@La_liste_effective

Indique que c'est bien le contenu actuel de @La_liste_effective quidoit être utilisé et au besoin modifié dans la procédure.

Pendant l'exécution de la procédure, le nom @Liste_locale s'identifieau nom @La_liste_effective.

Cette création d'un nouveau nom pour référencer un élément déjàexistant s'appelle l'aliasing.

@Liste_locale est maintenant un alias de @La_liste_effective.

A la fin de l'exécution de la procédure, @Liste_locale cesse d'êtreun alias de @La_liste_effective, mais deviendra l'alias d'un nouvelélément lors d'un appel ultérieur.


Attention DANGER.coruscant% cat prog.pl #!/usr/bin/perl$variable = 0;@variable = ("Voici","une","longue","liste");&ma_procedure (*variable);print ("Ici, la valeur de \$variable est $variable.\n");sub ma_procedure { local (*ligne) = @_; foreach $element (@ligne) { print ("$element "); } print ("\n"); $ligne = 1000;}coruscant% prog.plVoici une longue liste

Ici, la valeur de $variable est 1000.coruscant%

On a déclaréLe scalaire $variableLa liste @variable (qui est passée par un alias *ligne).

@ligne devient identique à @variable.Mais l'alias affecte TOUTES les variables du même nom.L'alias *ligne agit sur la liste @variable et sur le scalaire $variable.


La procédure AUTOLOAD().

Procédure prédéfini qui sera activée lorsqu'on fait référence àune procédure inexistante.

Le nom de la procédure en question sera passé dans une variablespécifique $AUTOLOAD et la liste d'arguments de cette procédurese trouvera dans la liste standard @_.


Exemple.

coruscant% cat prog.pl#!/usr/bin/perl BEGIN { print ("PERL vous souhaite la bienvenue.\n\n");}END { print ("PERL remercie de votre visite.\n\n");}AUTOLOAD { print ("La procédure $AUTOLOAD\n"); print ("à laquelle ont été passés les arguments @_ "); print ("n'existe pas.\n\n");}print ("Voici le programme qui commence.\n");print ("On va appeler une procédure inexistante :\n");print ("Nulle_Part(\"Ici\",\"et\",\"la\");\n\n");do Nulle_Part("Ici","et","la");coruscant% prog.plPERL vous souhaite la bienvenue.

Voici le programme qui commence.On va appeler une procédure inexistante :Nulle_Part("Ici","et","la");

La procédure main::Nulle_Partà laquelle ont été passés les arguments Ici et lan'existe pas.

PERL remercie de votre visite.coruscant%


La variable @INC.

Liste prédéfinie qui contient les répertoires dans lesquels s'effectueraune recherche lancée par la fonction require().

coruscant% cat prog.pl#!/usr/bin/perl #!/usr/bin/perlforeach $a (@INC) {print ("$a\n");}coruscant% cat prog.pl Home:Christian:Perl:MacPerl:lib:MacPPC:Home:Christian:Perl:MacPerl:lib::Dev:Pseudo:coruscant%


La fonction require ().Permet de découper un programme en fichiersdisjoints et de créer des bibliothèques de fonctions.

Par exemple, on suppose que le programme ci contre a été écrit etstocké sous le nom chchain.pl à un emplacement dont le cheminapparaît parmi ceux listés dans la variable @INC.

$c = "l";$nl = 0;$e = 0;$n = 0;$ligne = <>;while ($ligne ne "") { $nl++; while (1) { $e = index($ligne, $c, $e); last if ($em == -1); $n++; $e++; } print ("Ligne $nl, la chaine '$c' est presente $n fois.\n") if($n != 0); print ("La ligne $nl, la chaine $c n'est pas présente.\n")if ($n == 0); $ligne = <>; $e = 0; $n = 0;}"vrai";


Utilisation.Le programme suivant va permettre d'aller chercher et d'exécuterle code qui a été mémorisé dans le fichier vu auparavant.coruscant% cat prog.pl#!/usr/bin/perl@ARGV =("Poeme.txt");require ("chchain.pl");coruscant% prog.plLigne 1, la chaine 'l' est presente 1 fois.Ligne 2, la chaine l n'est pas présente.Ligne 3, la chaine l n'est pas présente.Ligne 4, la chaine 'l' est presente 3 fois.Ligne 5, la chaine l n'est pas présente.Ligne 6, la chaine 'l' est presente 1 fois.Ligne 7, la chaine l n'est pas présente.Ligne 8, la chaine 'l' est presente 2 fois.Ligne 9, la chaine 'l' est presente 1 fois.Ligne 10, la chaine l n'est pas présente.Ligne 11, la chaine 'l' est presente 1 fois.Ligne 12, la chaine 'l' est presente 2 fois.Ligne 13, la chaine 'l' est presente 1 fois.Ligne 14, la chaine l n'est pas présente.Ligne 15, la chaine 'l' est presente 3 fois.Ligne 16, la chaine 'l' est presente 2 fois.Ligne 17, la chaine 'l' est presente 1 fois.coruscant%


Finir un require ().

Si le retour n'avait pas été positionné à "vrai",le message suivant aurait été imprimé :

# chchain.pl did not return a true value, <> chunk 17.File 'Home:Christian:Perl:MacPerl:CAT:req'; Line 3


AUTOLOAD () et require ().

L'utilisation simultanée de AUTOLOAD et de require va permettrede gérer dynamiquement les appels de procédures.

coruscant% cat prog.pl #!/usr/bin/perlAUTOLOAD {require ($sous_programme.".pl");}

print ("Quelle procédure désirez vous exécuter 1 ou 2 ? ");chop($n = <stdin>);$sous_programme = "sp".$n;print ("On appelle $sous_programme.\n\n");$retour = &{$sous_programme} ("P1","P2","P3");print ("La procédure me renvoie le message : $retour\n");coruscant% cat sp1.plprint ("On entre dans le sous programme sp1.\n");print ("La liste d'appel de cette procédure est :\n");print ("@_\n");"procedure1";coruscant% cat sp2.plprint ("On entre dans le sous programme sp2.\n");print ("La liste d'appel de cette procédure est :\n");print ("@_\n");"procedure2";coruscant% cat sp2.pl

Mais, attention, la fonction require va chercher du code àexécuter.Le code considéré ne doit donc pas être représentatifd'un sous programme, bien que, afin d'activer le blocAUTOLOAD l'appel soit un appel de sous programme....


Exécution.

coruscant% prog.pl Quelle procédure désirez vous exécuter 1 ou 2 ? 1On appelle sp1.

On entre dans le sous programme sp1.La liste d'appel de cette procédure est :P1 P2 P3La procédure me renvoie le message : procedure1coruscant%