Perl

2005-10-24T10:44:20Z

Rv : /* Sur Internet */

[[Category:Développer sous Linux]]
= Perl =

<div class="leatitre">Perl</div><div class="leapar">par Jice et [mailto:jonesy_at_wanadoo_point_fr Jonesy]</div><div class="leadesc">Installation et introduction à Perl.</div>
----

== Avant propos ==

Ceci n'est qu'une introduction au Perl, car nous pourrions écrire 4 ou 5 livres, voir plus, sur ce sujet ! ;-) Donc ne vous attendez pas à faire le tour de la question... Et je précise aussi, que ce n'est pas non plus un cours de programmation : cet article s'adresse à des personnes possédant des bases de programmation et voulant se mettre à Perl.

== Présentation ==

Perl est un langage de programmation extrêmement efficace pour traiter les fichiers et les chaînes de caractères. Venant du monde Unix, il intègre toutes les fonctions que l'on peut retrouver en shell avec des commandes comme grep, sed, awk, ... Sa syntaxe générale ressemble beaucoup à celle du C et du shell. De plus, il est très apprécié des administrateurs système afin de gérer les fichiers de log.

Note de Jice : Perl est un langage très polyvalent. LE jeu, j'ai nommé [http://www.frozen-bubble.org Frozen Bubble], est même programmé en Perl !

=== Les particularités de Perl ===

* C'est un langage compilé et interprété. C'est à dire que l'on écrit le script, un simple fichier texte, puis à chaque fois que nous exécutons le script, l'interpréteur compile le code à la volée sous une forme intermédiaire et exécute les commandes. On pourrait ainsi croire qu'un script Perl est moins performant qu'un programme C compilé, mais il s'avère souvent plus performant et plus facile de faire un programme en Perl qu'en C.
* Ce langage est disponible sur quasiment toutes les plates-formes et tous les systèmes possibles, Linux, Unices, Mac OS... Donc nos scripts Perl fonctionneront sur toutes ces machines sans aucune adaptation (à moins d'utilisation de spécificités d'un système d'exploitation). Ce qui rend Perl disponible sur autant de systèmes, c'est ses licences. Perl est Libre et est sous la licence GPL ou Artistic au choix.
* Perl est un langage qui permet la programmation ''orientée objet''. Cet aspect du langage dépasse largement le cadre de cet article.

----

== L'installation ==

Dans cette partie, je n'aborde que l'installation de Perl sur un système Linux, et ce quelque soit la distribution. Enfin, j'espère... ;-) 

=== Vérifions si Perl est présent ===

Il y a des chances pour que Perl soit déjà installé avec notre distribution ou que celle-ci fournisse un package Perl. Pour vérifier si Perl est déjà sur notre système faisons, en console : <tt>perl -v</tt> Ceci doit nous retourner un message du genre: <tt>This is perl, v5.6.1 built for i386-linux</tt>

<tt>Copyright 1987-2001, Larry Wall</tt>

<tt>Perl may be copied only under the terms of either the Artistic licence or the GNU General Public licence, which may be found in the Perl 5 source kit.</tt>

<tt>Complete documentation for Perl, including FAQ lists, should be found on this system using `man perl' or `perldoc perl'. If you have access to the Internet, point your browser at http://www.perl.com/, the Perl Home Page.</tt>

Si c'est le cas, nous pouvons sauter le paragraphe suivant.

=== Installation de Perl ===

Pas de chance... Donc allons voir si notre distribution fournit un package et si oui, installons-le. Sinon... Les binaires sont accessibles ici : <tt>[http://www.activestate.com/Products/Download/Get.plex?id=ActivePerl&_x=1 http://www.activestate.com/Products/Download/Get.plex?id=ActivePerl&_x=1]</tt> Note : je viens de remarquer que maintenant il demande e-mail, prénom et nom pour télécharger Perl. Les sources sont accessibles ici : <tt>http://www.perl.com/pub/a/langage/info/software.html#sourcecode</tt>

Maintenant détarons le package <tt>tar -xvzf <votre package></tt> Allons sous le répertoire créé.

Si nous souhaitons choisir nos paramètres en répondant à des questions : <tt>./Configure -Dprefix=/usr</tt> <tt>make</tt> En root (<tt>su</tt>) <tt>make install</tt>

Sinon, pour une installation par défaut : <tt>./Configure -Dprefix=/usr -d -e</tt> <tt>make</tt> En root (<tt>su</tt>) <tt>make install</tt>

Vérifions que Perl est bien installé <tt>perl -v</tt> 

----

== Introduction au langage Perl ==

=== Les principales règles du Perl ===

* Les lignes de code se terminent par un point virgule.
* Les noms de variables doivent être précédés par un caractère pour les identifier :
** une variable scalaire (nombre, chaîne de caractères...) est identifié par le symbole '<tt>$</tt>', par exemple <tt>$chaine</tt>,
** un tableau par le symbole '<tt>@</tt>', par exemple <tt>@tableau</tt>, et <tt>$tableau[12]</tt> représente l'élément n° 12. Un tableau est toujours unidimensionnel, c'est pourquoi on parle aussi de liste (voir plus bas pour les [#structurescomplexes tableaux multidimensionnels]). Afin de définir un tableau, on écrit : <tt>@tableau = (val1, val2, ... , valn);</tt>
** un ''hachage'' (''hash'' en anglais) est identifié par le symbole '<tt>%</tt>', par exemple <tt>%hash</tt>. Un hachage une structure indexée par des chaînes de caractères. <tt>$hash{'prenom'}</tt> et <tt>$hash{'nom'}</tt> serviront à enregistrer le prénom et le nom de quelqu'un de façon explicite. Un hachage est défini de la manière suivante : <tt>%hash = ( prenom => 'jice', nom => 'cardot' );</tt>
* La déclaration des variables est non typée. C'est à dire que nous n'avons pas besoin de dire si cette variable va contenir une chaîne de caractère ou un entier. D'ailleurs, une même variable pourrait contenir à un moment un entier et à un autre une chaîne, mais ce n'est pas conseillé pour la relecture du code.
* Il y a deux sortes de chaînes de caractères. La chaîne de caractère définie entre simples cotes (') n'est pas interpolée. La chaîne de caractères définie entre guillemets (") est interpolée. Lorsque le Perl interprète une chaîne, il va regardé le contenu de celle-ci pour remplacer les variables qu'il trouvera par leurs valeurs. Notation : <tt>q(chaîne)</tt> est synonyme de <tt>'chaîne'</tt> et <tt>qq(chaîne)</tt> de <tt>"chaîne"</tt>. Remarquons que les parenthèses dans cette notation peuvent être remplacées par tout autre caractère, comme par exemple <tt>qq|chaîne|</tt> ou <tt>qq!chaîne!</tt>.
* La déclaration des variables n'est pas obligatoire. Il y a une commande pour nous obliger à déclarer les variables et d'autres choses. <tt>'''use''' strict;</tt> Je conseille très fortement d'utiliser ceci, afin d'écrire un code source plus propre et lisible. En effet, cette directive impose de déclarer les variables, et interdit certaines constructions dangereuses... Ceci facilite la recherche d'erreurs, et le débutant prend ainsi dès le début de bonnes habitudes de programmation.
* Un '''bloc''' est une suite d'instructions, séparées par des points virgules, et entourée d'accolades. Par exemple : <tt>{</tt> <tt> $toto = 12;</tt> <tt> print $toto;</tt> <tt>}</tt> est un bloc.

=== Définir l'interpréteur ===

Le fait de définir l'interpréteur dans le script permet de l'exécuter directement. Pour ce faire il faut placer la ligne suivante au tout début du script : <tt><nowiki>#!/usr/bin/perl</nowiki></tt> Ce qui permettra d'exécuter le script directement par : <tt>./script.pl</tt> Sans cette ligne il faudrait exécuter le script comme ceci : <tt>'''perl''' script.pl</tt> En ajoutant l'option <tt>-W</tt>, nous obtenons la liste des toutes les erreurs et de tous les avertissements lors de l'interprétation du script. 

=== Les commentaires ===

Un commentaire débute par un caractère dièse (#). Tout ce qui suit ce caractère jusqu'à la fin de la ligne sera considéré comme du commentaire. Par exemple : <tt><nowiki># Ceci est un exemple de commentaire</nowiki></tt> <tt>print "test"; # un 2ème commentaire</tt> 

=== Utiliser une libraire particulière ===

L'extension des fichiers librairies (ou module) est <tt>pm</tt>. <tt>pm</tt> signifie Perl Module. Pour appeler une librairie, on ajoute la directive : <tt>'''use''' la_librairie;</tt> Pour indiquer à perl où chercher nos librairies personnelles, on utilise la directive : <tt>'''use''' '''lib''' "le chemin d'accès";</tt>

Remarque : les chemins de recherche des librairies sont définit dans le tableau <tt>@INC</tt> 

=== Déclarer une variable ===

==== Variable globale : ====

Cela se fait automatiquement lors de la première utilisation de la variable. Cependant, lorsqu'on utilise <tt>use strict</tt>, il faut déclarer les variables globales par la directive suivante : <tt>'''use vars qw('''$var1 $var2 @tab1 %hash1''');'''</tt>

Remarque : le mot clef <tt>local</tt> s'applique à une variable globale (<tt>'''local '''$variable;</tt>). Il permet à l'intérieur d'un bloc de cacher une variable globale par une autre valeur. La variable reste globale, c'est à dire que dans les procédures appelées dans le bloc, la nouvelle valeur est utilisée ; à la fin du bloc, l'ancienne valeur est restaurée.

==== Variable lexicale : ====

Une variable lexicale n'existe qu'à l'intérieur d'un bloc. On parle aussi de variable locale. On la déclare par <tt>'''my''' $variable</tt> ou <tt>'''my''' @tableau</tt>...

Pour déclarer plusieurs variables et un tableau en une seule commande, faire : <tt>'''my '''($var1, $var2, @tab);</tt> 

=== Les opérateurs ===

Voici les opérateurs les plus couramment utilisés. Pour plus d'info sur les opérateurs : <tt>man perlop</tt>

==== Opérateurs unaires ====

{|
|- valign="TOP"
| <tt>!</tt>
| <nowiki>: négation logique. Si </nowiki><tt>$a</tt> vaut vrai, <tt>!$a</tt> vaudra faux.
|- valign="TOP"
| <tt>-</tt>
| <nowiki>: négation arithmétique. Si </nowiki><tt>$a</tt> vaut 2, <tt>-$a</tt> vaudra -2.
|- valign="TOP"
| <tt>~</tt>
| <nowiki>: négation binaire ou complément à 1.</nowiki>
|- valign="TOP"
| <tt>++</tt>
| <nowiki>: incrémentation ; si ++ est placé avant la variable, il la décrémente avant de retourner la valeur, s'il est placé après, il retourne la valeur puis l'incrémente. Exemple : </nowiki><tt>[http://paris.mongueurs.net/aplusplus.html $A++]</tt>
|- valign="TOP"
| <tt>--</tt>
| <nowiki>: décrémentation ; idem.</nowiki>
|}

==== Opérateurs binaires ====

{|
|- valign="TOP"
| <tt>+ - * / % **</tt>
| <nowiki>: opérations arithmétiques (% est le modulo, ** est l'exponentiation).</nowiki>
|- valign="TOP"
| <tt>.</tt>
| <nowiki>: concatène deux chaînes : </nowiki><tt>"aze"."rty"</tt> vaut <tt>"azerty"</tt>.
|-
| <tt>x</tt>
| <nowiki>: "multiplie" une chaîne : </nowiki><tt>"to" x 2</tt> vaut <tt>"toto"</tt>.
|- valign="TOP"
| <tt>& | ^ << >></tt>
| <nowiki>: opérations sur les bits : et, ou, ou exclusif (</nowiki>''xor''), décalage à gauche, à droite.
|-
| <tt>&& <nowiki>||</nowiki></tt>
| <nowiki>: et logique, ou logique.</nowiki>
|}

==== Opérateur ternaire ====

{|
|- valign="TOP"
| <tt>?: </tt>
| <nowiki>: cet opérateur particulier est nommé "opérateur conditionnel". Il fonctionne à la manière d'un </nowiki>''si alors sinon''. Si l'expression à gauche du ? est vraie, l'argument avant le : est retourné, sinon l'argument après le : est retourné. Mieux vaut un exemple : <tt><nowiki>print ($n>1)?'s':'';</nowiki></tt> affichera <tt>'s'</tt> si <tt>$n</tt> est plus grand que 1, et n'affichera rien (<tt><nowiki>''</nowiki></tt>) sinon.
|}

==== Opérateurs de comparaison numériques ====

{|
|- valign="TOP"
| < <= > >=
| <nowiki>: plus petit, plus petit ou égal, plus grand, plus grand ou égal</nowiki>
|- valign="TOP"
| <tt>== !=</tt>
| <nowiki>: égal, différent</nowiki>
|}

==== Opérateurs de comparaison pour les chaînes de caractères ====

{|
|- valign="TOP"
| <tt>lt gt le ge</tt>
| <nowiki>: plus petit, plus petit ou égal, plus grand, plus grand ou égal</nowiki>
|- valign="TOP"
| <tt>eq ne</tt>
| <nowiki>: égal, différent</nowiki>
|-
| <tt>=~ !~</tt>
|
<nowiki>: teste si une chaîne de caractères correspond à une expression régulière. Voir le paragraphe </nowiki>[#expressions_regulieres expressions régulières].
|}

=== L'affectation d'une variable ===

L'opérateur d'affectation "normal" est '<tt>=</tt>'. Par exemple : <tt>$variable '''=''' mavaleur;</tt> affecte la valeur <tt>mavaleur</tt> à la variable <tt>$variable</tt>.

D'autres opérateurs d'affectation sont un raccourci pour les opérations binaires. Par exemple <tt>$a '''+=''' 2</tt> est un raccourci pour <tt>$a = $a '''+''' 2</tt>.

Les opérateurs d'affectation les plus couramment utilisés sont :

{|
|- valign="TOP"
| <tt> =</tt>
| <nowiki>: affectation "standard"</nowiki>
|- valign="TOP"
| <tt> += -= *= /= %=</tt>
| <nowiki>: pour les opérations arithmétiques (+, -, *, / et modulo)</nowiki>
|-
| <tt><nowiki>&&= ||= !=</nowiki></tt>
| <nowiki>: pour les opérations logiques (et logique, ou logique, non logique)</nowiki>
|-
| <tt><nowiki> &= |= ^= ~= <<= >>=</nowiki></tt>
| <nowiki>: pour les opérations logiques sur les bits (et, ou, ou exclusif, complément à 1, décalages gauche et droite)</nowiki>
|-
| <tt> .=</tt>
| <nowiki>: pour les opérations sur les chaînes de caractères (concaténation)</nowiki>
|-
| <tt> =~ !~</tt>
|
<nowiki>: pour les expressions régulières (voir </nowiki>[[#Les expressions régulières, ou regex|plus bas]]).
|}

=== Quelques variables particulières prédéfinies ===

<tt>use English;</tt> permet d'utiliser les noms des variables au lieu des noms standards des variables spéciales (ex : <tt>$ARG</tt> au lieu de <tt>$_</tt>).

<tt>@_</tt> ou <tt>@ARG</tt> : Tableau d'arguments. Sert pour le passage de paramètres. <tt>$_</tt> ou <tt>$ARG</tt> : Variable par défaut des fonctions unaires entrées/sorties, recherche... <tt>$/</tt> ou <tt>$RS</tt> ou <tt>$INPUT_RECORD_SEPARATOR</tt> : fin de ligne lorsqu'on lit un fichier, <tt>\n</tt> par défaut sous unix et <tt>\r\n</tt> sous windows. <tt>$!</tt> ou <tt>$ERRNO</tt> : suivant le contexte d'utilisation, retourne le numéro de la dernière erreur système, ou le message d'erreur système. <tt>$0</tt> ou <tt>$PROGRAM_NAME</tt> : Nom du fichier qui contient le script Perl. <tt>$^0</tt> ou <tt>$OSNAME</tt> : Nom du système d'exploitation. Utiliser une variable d'environnement <tt>$variable = $ENV{"nom de la variable d'environnement"};</tt> Remarque, ce n'est que l'utilisation du ''hachage'' <tt>%ENV</tt>.

Pour plus d'information sur ces variables : <tt>man perlvar</tt> 

=== Branchements conditionnels ===

Ce test classique peut s'écrire de la manière suivante : <tt>'''if''' (test) {bloc}</tt> <tt>'''if''' (test) {bloc} '''else''' {bloc}</tt> <tt>'''if''' (test) {bloc} '''elsif''' (test) {bloc} ... '''else''' {bloc}</tt>

<tt>test</tt> étant toute expression qui retourne une valeur. exemple : <tt>if (!open(F,$FICHIER)) { die "impossible d'ouvrir $FICHIER: $!"; }</tt>

Il y a d'autres manières de faire la même chose, vous pouvez utiliser par exemple : 

{|
|- valign="TOP"
| <tt>instruction '''if''' test;</tt>
| exécute l'instruction si le test est vrai. exemple : <tt>die "impossible d'ouvrir $FICHIER: $!" '''if''' !open(F,$FICHIER);</tt>
|- valign="TOP"
| <tt>instruction '''unless''' test;</tt>
| exécute l'instruction si le test est faux. exemple : <tt>die "impossible d'ouvrir $FICHIER: $!" '''unless''' open(F,$FICHIER);</tt>
|-
| <tt>commande1 '''or''' commande2;</tt>
| exécute la commande1 ; si elle retourne faux, alors la commande2 sera exécutée. Sinon on passe à la suite. exemple : <tt>open(F,$FICHIER) '''or''' die "impossible d'ouvrir $FICHIER: $!";</tt>
|-
| <tt>test'''?'''commande1'''<nowiki>:</nowiki>'''commande2;</tt>
| exécute la commande1 si la condition du test est remplie, sinon il exécute la commande2.
|}

Note : Pour ceux qui connaissent, il n'y a pas d'équivalent au '<tt>case</tt>' ou '<tt>switch</tt>'. Il y a plusieurs façons de faire, notamment utiliser <tt>if elsif ... else</tt>. <tt>man perlsyn</tt> vous donnera plus d'informations. 

=== Les boucles ===

==== For et foreach ====

Il y a deux types de boucles for, le for 'style C', et le for/foreach Perl.

===== for/foreach Perl =====

Dans ce cas, for et foreach sont synonymes. On peut utiliser l'un ou l'autre pour améliorer la lecture, par habitude, etc.

Pour aller de 1 à 9 : <tt>'''for''' $cpt (1 .. 9) {bloc} </tt>ou<tt> '''foreach''' $cpt (1 .. 9) {bloc}</tt> (dans <tt>{bloc}</tt>, <tt>$cpt</tt> prend successivement les valeurs de 1 à 9) ou <tt>'''for''' (1 .. 9) {bloc}</tt> ici, à chaque itération, la variable par défaut <tt>$_</tt> prend la valeur suivante.

Pour parcourir chaque éléments d'un tableau : <tt>'''foreach''' $variable (@tableau) {bloc}</tt> A chaque itération, <tt>$variable</tt> prendra la valeur suivante de <tt>@tableau</tt>. Si on omet <tt>$variable</tt>, alors la valeur de l'élément sera stocké dans la variable <tt>$_</tt> : <tt>'''foreach''' (@tableau) {bloc}</tt>

Remarque : l'écriture <tt>1..9</tt> définit en réalité un tableau de 9 éléments (1,2,3,4,5,6,7,8,9).

===== for 'style C' =====

La construction 'classique' à la C est possible, mais tellement moins Perl... <tt>'''for''' ($cpt=1 ; $cpt < 10 ; $cpt++) {bloc}</tt> Cette construction est néanmoins très puissante, et permet de faire beaucoup plus de choses que de simples itérations... A vous de voir !

A noter que dans les exemples ci-dessus, les variables $cpt ou $variable sont locales à la boucle. Si elles doivent être déclarées, vous pouvez les faire précéder du mot clef <tt>my</tt> : <tt>for '''my''' $cpt (1 .. 9) {bloc}</tt> <tt>for ('''my''' $cpt=1 ; $cpt < 10 ; $cpt++) {bloc}</tt>

==== While ====

Les boucles while se construisent comme suit : <tt>'''while''' (test) {bloc1}</tt> <tt>'''while''' (test) {bloc1} '''continue''' {bloc2}</tt>

Le bloc1 puis le bloc2 sera exécuté tant que le test est vrai.

L'exécution des boucles peut être pilotée à l'intérieur des blocs par les commandes <tt>next</tt>, <tt>last</tt> et <tt>redo</tt>.

* <tt>next</tt> lance l'itération suivante de la boucle. Le bloc continue est exécuté puis la boucle redémarre.
* <tt>last</tt> sort de la boucle, sans exécuter le bloc continue.
* <tt>redo</tt> relance l'itération de la boucle, sans exécuter le bloc continue ni le test.

Par exemple, le code suivant lit l'entrée standard, et ignore les commentaires (lignes commençant par #)

<blockquote><tt>'''while''' (<STDIN>) {</tt> <tt> '''next''' if /^#/;</tt> <tt> ...</tt> <tt>}</tt></blockquote>

Autre exemple, une itération de 1 à 9

<blockquote><tt>$cpt = 1;</tt> <tt>'''while''' ($cpt < 10) {</tt> <tt> ...</tt> <tt> $cpt++;</tt> <tt>}</tt></blockquote>

ou bien :

<blockquote><tt>$cpt = 1;</tt> <tt>'''while''' ($cpt < 10) {</tt> <tt> ...</tt> <tt>}</tt> <tt>'''continue''' {</tt> <tt> $cpt++;</tt> <tt>}</tt></blockquote>

Pour plus d'information sur ces constructions : <tt>man perlsyn</tt>. 

=== Les fonctions et procédures ===

==== Déclaration des fonctions ====

Une fonction peut être déclarée n'importe où dans le script Perl, mais pour des questions de lisibilité, il est préférable de déclarer les fonctions regroupées soit en début, soit en fin de script. On peut pré-déclarer les fonctions par : <tt>'''sub''' mafonction;</tt> ou les déclarer directement par : <tt>'''sub''' mafonction {bloc}</tt>

==== Passage de paramètres ====

Les paramètres sont passés comme une liste de valeurs scalaires (nombre, chaîne...) à plat. Par exemple : <tt>ma_fonction($variable, "chaîne");</tt>

Pour lire valeur des paramètres passés dans la fonction, il suffit de lire la variable <tt>@_ </tt>qui est le tableau contenant les paramètres. Une façon simple de les lire est d'écrire en début de fonction : <tt>'''my '''($variable, $chaine) = @_;</tt> On peut aussi récupérer les arguments en dépilant les éléments du tableau <tt>@_</tt> avec la commande <tt>shift</tt>. <tt>my $variable = shift @_;</tt> qui peut s'abréger en <tt>my $variable = shift;</tt> car le tableau <tt>@_</tt> est l'argument par défaut de shift.

Les paramètres sont passés '''par valeur'''. Pour pouvoir modifier le contenu d'une variable passée en paramètre à une fonction, il faut passer à cette fonction une ''référence'' sur la variable (on parle de passage '''par référence'''). Une référence est un type scalaire particulier qui permet de se ''référer'' à une variable. La notation consiste à faire précéder la variable par un caractère '<tt>\</tt>'. Pour récupérer la variable cachée derrière la référence (ou ''déréférencer''), il faut faire précéder la référence du caractère de type correspondant, et optionnellement entourer la référence d'accolades. Exemple : <tt>$a = 1;</tt> <tt>$b = \$a; # $b</tt> est une référence à <tt>$a</tt> <tt>$c = $$b + 1; # $c = 2</tt> <tt>$c = ${$b} + 1; # </tt>synonyme

Démonstration : <tt>sub test'''1''' {</tt> <tt> my $a=shift; </tt><nowiki># récupération du paramètre </nowiki> <tt> $a += 1; </tt><nowiki># on ajoute un </nowiki> <tt>}</tt> <tt>sub test'''2''' {</tt> <tt> my $ref_a=shift;</tt> <tt>''' $'''$ref_a += 1; </tt><nowiki># le premier $ déréférence la référence </nowiki> <tt>}</tt> <tt>$a = 1;</tt> <tt>print $a; </tt><nowiki># affiche 1 </nowiki> <tt>test'''1'''($a);</tt> <tt>print $a; </tt><nowiki># affiche 1 </nowiki> <tt>test'''2'''('''\'''$a); </tt><nowiki># </nowiki><tt>'''\'''$a</tt> est une référence sur <tt>$a</tt> <tt>print $a; </tt><nowiki># affiche 2 </nowiki>

Le passage par référence a aussi pour d'intérêt de pouvoir passer des tableaux ou des hachages en paramètres à une fonction. En effet, on a vu que les paramètres d'une fonction sont passés comme une '''liste de valeurs scalaires''' à plat. Si on désire passer 2 tableaux <tt>@tab1=(1,1,1)</tt> et <tt>@tab2=(2,2)</tt> à une fonction, et que l'on écrit : <tt>mafonction (@tab1, @tab2);</tt> alors perl traduira cela comme : <tt>mafonction (1,1,1,2,2);</tt> car il met toutes les valeurs à plat dans une liste. Une fois dans la fonction on sera bien embêté pour savoir distinguer les éléments du premier tableau de ceux du deuxième. On va donc passer une référence sur chaque tableau : <tt>mafonction ('''\'''@tab1, '''\'''@tab2);</tt>

Exemple : <tt>sub liste_gt {</tt> <tt> my ($l1ref, $l2ref) = @_;</tt> <tt> $n1 = '''@'''$l1ref; #</tt> <tt>@$l1ref</tt> représente le tableau référencé par <tt>$l1ref</tt> <tt> $n2 = '''@'''$l2ref;</tt> <tt> #</tt> (affecter un tableau dans un scalaire retourne le nombre d'éléments) <tt> if ($n1 > $n2) { return 1; }</tt> <tt> else { return 0; }</tt> <tt>}</tt> <tt>@tab1 = (1,2,3);</tt> <tt>@tab2 = ("a",2,"r",5);</tt> <tt>if (liste_gt('''\'''@tab1, '''\'''@tab2)) {</tt> <tt> print "tab1 a plus d'éléments que tab2\n";</tt> <tt>} else {</tt> <tt> print "tab2 a plus d'éléments que tab1\n";</tt> <tt>}</tt>

Tout cela s'applique de la même façon aux hachages. Pour plus d'informations sur les références, voir <tt>man perlreftut</tt> (tutoriel) et <tt>man perlref</tt> (références).

==== Retour de valeurs ====

Une fonction peut renvoyer une ou des valeurs, grâce à la commande <tt>return</tt> : <tt>'''sub''' ecrire</tt> <tt>{</tt> <tt> ...</tt> <tt> '''return''' $valeur;</tt> <tt> ... </tt><nowiki># renvoie une valeur unique </nowiki> <tt> '''return''' $valeur1, $valeur2;</tt> <tt> ... </tt><nowiki># renvoie une liste de valeurs </nowiki> <tt>}</tt> Cette commande provoque la sortie immédiate du sous-programme pour retourner dans le programme appelant.

'''<tt>return</tt>''' permet de renvoyer une valeur ou une liste de valeurs. Cela permet donc à une fonction de retourner soit un tableau : <tt>@resultat = ma_fonction;</tt> soit plusieurs valeurs : <tt>($a, $b) = ma_fonction;</tt>

De même que pour le passage de paramètres, la liste de valeur est une liste "à plat", ce qui signifie que pour retourner plusieurs tableaux, il faut également passer par les références : <tt>($ref_a, $ref_b) = ma_fonction;</tt> où <tt>$ref_a</tt> est une référence sur le tableau <tt>@$ref_a</tt> et où ma_fonction retourne une liste de deux références. 

Pour plus d'information sur les fonctions de Perl, voir <tt>man perlsub</tt>. 

=== Les expressions régulières, ou regex ===

Perl est un langage très pratique pour manipuler du texte. Un des éléments qui le rend si adapté à cet usage est la présence des ''expressions régulières'', qui permettent de déterminer si une chaîne de caractère correspond à un masque prédéfini, d'extraire des éléments d'une chaîne de caractères suivant un masque, de remplacer des parties d'une chaîne suivant un masque, etc. C'est ce masque, défini sous forme d'une chaîne de caractères, que l'on appelle ''expression régulière''.

Par exemple, <tt>$a =~ /lea/</tt> teste si la chaîne "lea" est dans la chaîne $a, <tt>$a =~ /^lea/</tt> si $a commence par "lea", <tt>$a =~ /l[eé]a/</tt> si la chaîne $a contient "lea" ou "léa"...

De prime abord, ce sont des sortes de formules qui semblent ne rien vouloir dire, mais une fois que nous les maîtrisons, elles se révèlent extrêmement pratiques et puissantes.

==== Les éléments composant une expression régulière ====

Les éléments les plus utilisés sont :

* les caractères standards : majuscules, minuscules, chiffres, etc.
* les méta-caractères :
** <tt>. </tt> : représente un caractère quelconque
** <tt>^ </tt> : début de la chaîne
** <tt>$ </tt> : fin de la chaîne
** <tt>()</tt> : groupement et capture (la chaîne qui correspond au masque présent entre les parenthèses est affectée à la variable $1 pour la première parenthèse, $2 pour la seconde, etc. On peut ensuite utiliser ces variables normalement, notamment dans la substitution, voir plus bas)
** <tt>(?:)</tt> : groupement sans capture (pas d'affectation aux variables $1, $2...)
** <tt>[]</tt> : classe de caractères (c'est à dire l'un des caractères présent entre les crochets ; on peut de plus spécifier des plages de caractères, par exemple <tt>[a-e]</tt> correspond à tous les caractères entre a et e ; <tt>[aeiou]</tt> aux voyelles ; <tt>[aeiou0-9]</tt> aux voyelles plus aux chiffres...)
** <tt>| </tt> : alternance (sorte de ou logique)
** <tt>\ </tt> : permet de protéger un caractère réservé (voir ci-dessus) lorsqu'on veut l'utiliser comme caractère standard dans la regex.
* les caractères spéciaux :
** <tt>\s</tt> : représente un espace
** <tt>\S</tt> : caractère autre que espace
** <tt>\n</tt> : saut de ligne
** <tt>\r</tt> : retour chariot (les lignes des fichiers Windows se terminent par \r\n, et par \n sous Unix). Pour faire du code portable, il vaut mieux utiliser <tt>$/</tt> qui représente la fin de ligne (voir [#var_particulieres variables spéciales]).
** <tt>\t</tt> : tabulation
** <tt>\d</tt> : un chiffre (=<tt>[0-9]</tt>)
** <tt>\w</tt> : alphanumérique (=<tt>[0-9a-zA-Z_]</tt> plus les accents, etc. si on précise <tt>use locale;</tt>)
** plus de nombreux autres...
* les quantifieurs (ils suivent un caractère ou un méta-caractère afin d'en représenter le nombre que l'on cherche) :
** <tt><nowiki>*</nowiki></tt> : de 0 à n
** + : de 1 à n
** ? : 0 ou 1
** {n} : exactement n
** {n,} : au moins n
** {n,m} : entre n et m par défaut, les quantifieurs sont "gourmands", c'est à dire qu'ils recherchent un maximum de caractères tant que le reste du masque correspond. Afin de rechercher un minimum de caractère, il faut faire suivre le quantifieur de '?', par exemple <tt><nowiki>*?</nowiki></tt>, <tt>{n,}?</tt>, etc.
* les assertions de largeur nulle (i.e. ne représentant pas un caractère)
** \b : correspond à une limite de mot
** \B : correspond à une non limite de mot (i.e. intérieur !)
** (?!pattern) : assertion négative en avant. Par exemple, /toto(?!titi)/ teste si la chaîne contient "toto", non suivi de "titi".
** (?<!pattern) : assertion négative en arrière. Par exemple, /(?<!titi)toto/ teste si la chaîne contient "toto", non précédé de "titi". La largeur de "titi" doit être fixe (i.e. toujours le même nombre de caractères).
** ...

==== Les différentes utilisations des expressions régulières ====

<tt>'''m'''/regex/</tt> ou <tt>/regex/</tt> (sans le '''m''') '''teste''' si une chaîne correspond (''match'') à une regex donnée. <tt>'''s'''/regex/substitution/</tt> '''remplace''' la partie de la chaîne correspondant à la regex par la substitution.

Pour appliquer un test m// ou une substitution s/// à une chaîne de caractères, on utilise l'opérateur =~ ou !~. Par exemple : <tt>if ($s '''=~''' /win(dows)?/) { kickban(); }</tt> teste si la chaîne $s contient "win" ou "windows". Si on ne précise pas de chaîne, le test se fait sur la variable par défaut $_ : <tt>if (/win(dows)?/) { kickban(); }</tt> teste si $_ contient "win" ou "windows". L'opérateur <tt>!~</tt> correspond quant à lui à la négation : <tt>$s !~ /coin/</tt> teste si la chaîne $s ne contient pas "coin".

===== options =====

Les expressions régulières peuvent de plus être suivies de modifieurs ou options, qui en modifient le comportement, notamment :

* g : recherche globalement, i.e. ne s'arrête pas à la première occurrence.
* i : recherche insensible à la casse des caractères (i.e. majuscules/minuscules)
* m : traite la chaîne comme des lignes multiples (lorsqu'elle contient des retours à la ligne). ^ et $ correspondent dans ce cas à un début de ligne et une fin de ligne.
* s : traite la chaîne comme une seule ligne. Dans ce cas, le méta-caractère "." peut correspondre à "\n" ce qui n'est pas le cas normalement.
* x : permet d'insérer des espaces voire des commentaires dans un masque.
* e : uniquement pour s///, traite la substitution comme du code perl : elle est interprétée par perl avant d'être substituée.

Par exemple : <tt>"Bonjour Léa" =~ m/jour/; # correspond</tt> <tt>"Bonjour Léa" =~ m/Jour/; # ne correspond pas</tt> <tt>"Bonjour Léa" =~ m/Jour/i; # correspond</tt>

===== groupement et capture =====

Si une partie d'une regex est entre parenthèses, alors la partie de la chaîne qui correspond à cette parenthèse sera affectée à la variable $1 (on dit "capturée"). Si une deuxième parenthèse est présente dans la regex, la variable $2 sera utilisée, et ainsi de suite. Si la parenthèse commence par ?: alors il n'y aura pas d'affectation à une variable $1, $2, etc. Ainsi : <tt>if (/win'''(?:'''dows''')'''?\s'''('''..''')'''/i) {</tt> <tt> if ('''$1''' eq "xp") { kickban(); }</tt> <tt> else { kick(); }</tt> <tt>}</tt> teste si $_ contient "win" ou "windows", suivi d'un espace, puis de 2 caractères, que l'on va capturer dans <tt>$1</tt>. La première parenthèse <tt>(?:dows)</tt> permet de regrouper les quatre caractères "dows" afin de leur appliquer le quantifieur '?' (0 ou 1).

Les captures $1, $2... peuvent être utilisées lors d'une substitution : <tt>$s =~ /win'''(?:'''dows''')'''?\s'''('''..''')'''/winblows $1/</tt> 

==== Tester si une chaîne correspond à un masque donné : m// ou // ====

Par exemple, pour tester si une chaîne contient le mot "lea" (le <tt>i</tt> de la fin permet de ne pas différencier majuscules et minuscules) : <tt>if (/lea/i) ...</tt>

Pour tester si une chaîne commence par la lettre 'a', on peut faire : <tt>if (/'''^'''a/) ...</tt>

Pour tester si une chaîne se termine par 'z' : <tt>if (/z'''$'''/) ...</tt>

Enfin pour tester si une chaîne contient un quadruplet héxadécimal (i.e. 4 chiffres de 0 à 9 ou A à F) : <tt>if (/[0-9A-F]{4}/) ...</tt>

Ici, par défaut, c'est la valeur contenu dans <tt>$_</tt> qui est utilisée pour le test. Et bien entendu, nous pouvons compliquer à loisir l'expression régulière, et utiliser le groupement (voir plus haut) afin de récupérer les valeurs trouvées dans les chaînes pour s'en servir par la suite. 

==== Substituer une partie d'une chaîne à une autre : s/// ====

Rappel : la syntaxe est <tt>s/regex décrivant l'élément à remplacer/élément remplaçant/options</tt>

Exemples : <tt>$variable '''=~''' '''s'''/a/b/;</tt> Cette commande va remplacer le premier 'a' de la ligne par 'b'. Pour remplacer tous les 'a' faire : <tt>$variable '''=~''' '''s'''/a/b/'''g'''<nowiki>;</nowiki></tt> Si en plus nous voulons que cela ne fasse pas la différence entre les majuscules et les minuscules (''case sensitive''), faire <tt>$variable '''=~''' '''s'''/a/b/'''gi'''<nowiki>;</nowiki></tt> Pour remplacer tous les ensembles de caractères commençant par 'a', finissant par 'e' et avec au moins un caractère au milieu sans être sensitif par 'toto', faire : <tt>$variable '''=~''' '''s'''/a'''.*'''e/toto/'''gi'''<nowiki>;</nowiki></tt> 

==== La traduction : tr/// ====

Cette construction "à la regex" permet de remplacer des caractères par d'autres dans une chaîne, à la manière de la commande unix 'tr'. La syntaxe est <tt>'''tr'''/éléments à traduire/éléments traduits/</tt> Ou <tt>'''y'''/éléments à traduire/éléments traduits/</tt>

Exemple : <tt>$variable '''=~''' '''tr'''/a-b/A-B/;</tt> Cela va transformer tous les 'a' et 'b' minuscules en majuscules.

Plus d'info sur : <tt>man perlre</tt> <tt>man perlretut</tt> (le tutoriel sur les regex, une bonne lecture !) 

=== Structures de données complexes ===

==== Tableaux et tables de hachage multidimensionnels ====

On a vu plus haut que les tableaux Perl ne possèdent qu'une seule dimension (il ne peuvent contenir que des éléments de type scalaire). On a aussi vu [[#Passage de paramètres|plus haut]] l'existence de références, type scalaire particulier qui permet de se ''référer'' à une variable, donc en l'occurence à un tableau. Ainsi pour représenter la matrice <tt> 0 1 2</tt> <tt> 3 4 5</tt> <tt> 6 7 8</tt> Nous allons pouvoir faire : <tt>@ligne1 = (0, 1, 2);</tt> <tt>@ligne2 = (3, 4, 5);</tt> <tt>@ligne3 = (6, 7, 8);</tt> <tt>@matrice = ('''\'''@ligne1, '''\'''@ligne2, '''\'''@ligne3);</tt> Perl introduit une nouvelle notation pour ce faire : au lieu d'entourer la liste avec des parenthèses, nous allons le faire avec des crochets, ce qui aura pour effet de retourner une référence : <tt>$ligne1_ref = [0, 1, 2];</tt> <tt>etc...</tt> ou plus simplement : <tt>@matrice = (</tt> <tt> [0, 1, 2],</tt> <tt> [3, 4, 5],</tt> <tt> [6, 7, 8],</tt> <tt>);</tt> Dans tous ces cas, @matrice est un tableau de trois éléments, qui sont chacun une référence vers un autre tableau. <tt>$matrice[1]</tt> est une référence sur la 2ème ligne de la matrice.

Afin d'accéder aux éléments de la matrice, nous pouvons utiliser une nouvelle notation : la flèche '<tt>-></tt>'. En effet, afin d'accéder au 3ème élément de <tt>$ligne1_ref</tt> définie plus haut, nous utiliserons <tt>$ligne1_ref'''->'''[2]</tt> (ce qui est synonyme de <tt>${$ligne1_ref}[2]</tt>.) Ainsi, afin d'accéder au '5' dans notre matrice, nous ferons : <tt>$matrice[1]'''->'''[2]</tt>. Mais... Perl est gentil avec nous, car entre deux indices de tableau, la flèche est optionnelle ! Donc nous pouvons écrire : <tt>$matrice[1][2]</tt>, ce qui ressemble maintenant à un tableau bi-dimensionnel.

De même, si $hash_ref est une référence vers un hachage, <tt>$hash_ref->{'nom'}</tt> renverra l'élément du hachage indexé par 'nom'.

L'ensemble tableaux, hachages et références peut bien sûr être mixé dans l'ordre qui vous plaira. Par exemple, pour réaliser un tableau de personnes, nous écrirons : <tt>@staff = (</tt> <tt> [ prenom => "jice", nom => "cardot" ],</tt> <tt> [ prenom => "fred", nom => "bonnaud" ],</tt> <tt> [ prenom => "serge", nom => "tchesmeli" ],</tt> <tt>);</tt> et pour accéder au prénom de la première personne, nous ferons : <tt>$staff[0]'''->'''{'prenom'}</tt>(meuh non je ne suis pas mégalo ;) ou <tt>$staff[0]{'prenom'}</tt> car ici aussi la flèche est optionnelle.

Notes :

* pour manipuler les tableaux, les fonctions intéressantes sont notamment : <tt>push</tt> pour ajouter un élément en fin de tableau, <tt>pop</tt> pour récupérer le dernier élément et <tt>shift</tt> pour récupérer le premier élément. <tt>pop</tt> et <tt>shift</tt> retournent cet élément, et le suppriment du tableau.
* en contexte scalaire, évaluer un tableau ou un hachage retourne son nombre d'éléments. Ainsi <tt>$nb_elem = @tableau</tt> mettra dans <tt>$nb_elem</tt> le nombre d'éléments de <tt>@tableau</tt>.

=== Les références symboliques ===

On a vu [[#Passage de paramètres|ci-dessus]] une utilisation des références, pour le passage et le retour de valeurs dans les fonctions. On [[#Structures de données complexes|vient de voir]] également leur utilité pour travailler avec des structures de données complexes.

Les références peuvent aussi servir dans un autre contexte : si vous déréférencez une variable contenant une valeur scalaire plutôt qu'un référence vers une autre variable, elle sera considérée comme une référence symbolique, c'est à dire que la valeur scalaire sera utilisée en tant que nom de la variable. Exemple : <tt>$test = "toto";</tt> <tt>$$test = 144; #</tt> affecte 144 à $toto <tt>${$test} = 12; #</tt> affecte 12 à $toto <tt>$test->[1] = 12; #</tt> affecte 12 à $toto[1] <tt>@$test = (1,2,3); #</tt> affecte le tableau @toto

Cela peut aller beaucoup plus loin, car vous pouvez mettre une chaîne de caractères entre les accolades : <tt>${$test x 2} = 12; #</tt> affecte 12 à $totototo $titi = 2; <tt>${"$toto$titi"} = 2; #</tt> affecte 2 à $toto2 etc.

Remarque : l'utilisation des références symboliques avec <tt>use strict;</tt> (tel que préconisé au début de l'article) n'est pas possible. Pour contourner ce problème, il faut appeler l'instruction <tt>no strict 'refs';</tt> dans le bloc où on veut utiliser les références symboliques.

Autre exemple d'utilisation : <tt>$min = 12;</tt> <tt>$max = 144;</tt> <tt>while (<FICHIER>) {</tt> <tt> if (/^([A-Z]+)\ (\d+)\ (\d+)\ (\d+)$/) {</tt> <tt> #</tt> les masques ont affecté $1, $2, $3 et $4 (voir [#regex_capture groupement/capture]) <tt> print "$1: ";</tt> <tt> #</tt> on va effectuer une même opération sur $2, $3 et $4 : <tt> for $i (2 .. 4) {</tt> <tt> no strict 'refs';</tt> <tt> #</tt> on utilise les références symboliques : si $i = 2, alors $$i est $2 <tt> if ('''$$i''' > $max) print "sup ";</tt> <tt> elseif ('''$$i''' < $min) print "inf ";</tt> <tt> else print "ok ";</tt> <tt> }</tt> <tt> }</tt> <tt>}</tt>

=== Manipulation de fichiers ===

Comme toujours en Perl, il y a plusieurs moyens de faire une même opération.

==== Ouverture "à la shell" : ====

Cette façon de faire offrant un moyen simple d'ouvrir un fichier en lecture / écriture est empruntée du shell. <tt>'''open'''(FILE, "< nom du fichier"); </tt><nowiki># ouvre en lecture </nowiki> <tt>'''open'''(FILE, " nom du fichier"); </tt><nowiki># idem </nowiki> <tt>'''open'''(FILE, "> nom du fichier'); </tt><nowiki># ouvre en écriture </nowiki> <tt>'''open'''(FILE, ">>nom du fichier'); </tt><nowiki># ouvre en ajout </nowiki>

Remarque : le fichier "moins" correspond à l'entrée standard ''stdin'' en lecture et à la sortie standard ''stdout'' en écriture. Par exemple <tt>open(SORTIE,">-")</tt> ouvre la sortie standard.

==== Ouverture "à la C" : ====

La fonction '''<tt>sysopen</tt>''' de Perl correspond à l'appel système open(2) du C. Cela permet une plus grande maîtrise sur l'ouverture des fichiers, au prix d'une plus grande complexité. Synoptique : <tt>sysopen DESCRIPTEUR, CHEMIN, FLAGS, [MASQUE]</tt> <tt>MASQUE</tt> correspond au masque octal des permissions du fichier (utile pour la création d'un fichier), combiné avec l'umask du processus perl. voir [../admin/permissions.php3 l'article sur les permissions]. Je vous renvoie vers un cours de C pour la signification des exemples suivants, et vous donne la correspondance avec l'open "à la shell". 

<center>

{| width="80%" border="BORDER"
! à la Shell
! à la C
|-
| <tt>open(F, "< $chemin");</tt>
| <tt>sysopen(F, $chemin, O_RDONLY);</tt>
|-
| <tt>open(F, "> $chemin");</tt>
| <tt>sysopen(F, $chemin, O_WRONLY | O_TRUNC | O_CREAT);</tt>
|-
| <tt>open(F, ">> $chemin");</tt>
| <tt>sysopen(F, $chemin, O_WRONLY | O_APPEND | O_CREAT);</tt>
|}

</center>

Bien sûr, sysopen permet de faire plus de choses que le simple open(), en jouant sur les flags ci-dessus et O_RDWR, O_RDONLY, O_EXCL, O_NONBLOCK, O_BINARY. Pour plus d'informations, voir <tt>man perlopentut</tt> ou <tt>man 2 open</tt>.

==== Fermer un fichier ====

<tt>'''close'''(FILE);</tt> <tt>FILE</tt> étant le descripteur du fichier ouvert.

==== Descripteurs de fichier spéciaux ====

<tt>STDIN</tt> et <tt>STDOUT</tt> sont définis dès le lancement de votre programme. Ils correspondent respectivement à l'entrée et à la sortie standard. Rien ne vous empêche de les redéfinir, en les ouvrant sur un autre fichier, par exemple : <tt>open(STDIN, "mon_fichier");</tt>

==== Lire dans un fichier (l'opérateur diamant) ====

À chaque appel, <tt>'''<'''DESCRIPTEUR DE FICHIER'''>'''</tt> (on appelle '''<tt><></tt>''' l'opérateur "diamant") retourne la ligne suivante du fichier (en fait jusqu'à la fin de ligne définie par $/, voir le paragraphe sur les [#var_particulieres variables prédéfinies].), ou renvoie ''faux'' en fin de fichier. exemple : <tt>open (F, "mon_fichier");</tt> <tt>$premiere_ligne = '''<'''F'''>'''<nowiki>;</nowiki></tt> <tt>while ('''<'''F'''>''') {</tt> <tt> ... </tt>traitement en fonction de $_<tt> ...</tt> <tt>}</tt> <tt>close(F);</tt>

exemple : pour lire tout un fichier dans une variable : <tt>open (F, "mon_fichier");</tt> <tt>undef $/;</tt> <tt>$contenu_fichier = '''<'''F'''>'''<nowiki>;</nowiki></tt> <tt>close(F);</tt>

La lecture sur l'entrée standard est extrêmement simplifiée, car <tt>STDIN</tt> est déjà ouvert, et <tt><STDIN></tt> et <tt><></tt> sont synonymes. Ainsi, il suffit de faire : <tt>while ('''<>''') {</tt> <tt> ... traitement de la ligne en cours ...</tt> <tt>}</tt>

==== Écrire dans un fichier ====

Il suffit de spécifier à la commande <tt>print</tt> ou <tt>printf</tt> le descripteur de fichier à utiliser. Exemple : <tt>open(FLOG, ">> fichier.log");</tt> <tt>print '''FLOG''' "nouveau log\n";</tt> <tt>close(FLOG);</tt> 

== Quelques autres commandes utiles ==

voir <tt>man perlfunc</tt> pour la liste exhaustive des commandes intégrées de Perl.

=== split ===

<tt>split</tt> correspond en partie à la fonction <tt>cut</tt> en shell. Elle permet de découper une chaîne de caractères. Exemple : <tt>($variable, @tableau) = '''split''' (":", "prenom:nom:age:adresse:ville:telephone");</tt> Renvoie "prenom" dans <tt>$variable</tt> et le reste dans des cases distinctes du tableau <tt>@tableau</tt>.

=== systeme ou exec ===

<tt>exec</tt> permet de lancer un programme extérieur. <tt>system</tt> de même que <tt>exec</tt>, mais produit un ''fork'', processus fils. Exemple : <tt>@args = ("ls", "-lrt", "toto*");</tt> <tt>'''system'''(@args);</tt> Cela va lancer la commande : <tt>ls -lrt toto*</tt> Attention, l'utilisation de ces commandes rend votre script beaucoup moins portable ! En général, il y a moyen de tout faire en Perl, il faut éviter de recourir à ces fonctions.

=== chomp ===

<tt>chomp</tt> supprime tous les caractères de fin de ligne d'une chaîne de caractères et renvoie le nombre de caractères supprimés. Exemple : <tt>$nb_car = chomp($chaine);</tt> Contrairement à <tt>chop</tt> qui enlève seulement le dernier caractère de fin de ligne. 

== Exemple d'un script Perl ==

Le [perl_script.pl script] va se lire lui-même et sortir à l'écran son contenu modifié : <tt><nowiki>#!/usr/bin/perl -W</nowiki></tt> <tt><nowiki># Fichier script.pl</nowiki></tt> <tt>'''use''' strict '''qw'''(subs vars refs);</tt>

<tt>'''my '''$file = "$0";</tt>

<tt>'''open'''(FILE, "<$file");</tt>

<tt><nowiki>#Lecture du fichier ligne par ligne jusqu'à la fin du fichier.</nowiki></tt> <tt>'''while''' (<FILE>) {</tt> <tt> #Remplace tous les mots 'file' par 'fichier'.</tt> <tt> $_ '''=~''' '''s'''/file/fichier/'''ig'''<nowiki>;</nowiki></tt> <tt> #Transforme les lettres minuscules de 'a' à 'e' en majuscules.</tt> <tt> $_ '''=~''' '''tr'''/a-e/A-E/;</tt> <tt> #Affiche le résultat des transformations à l'écran.</tt> <tt> '''print''' $_;</tt> <tt>}</tt>

<tt>'''close'''(FILE);</tt> <tt><nowiki>#Fin script.pl</nowiki></tt> Ce script est totalement inutile mais je crois que cela montre la facilité d'utilisation. Oui, j'en conviens, en shell cela tiens en une ligne : <tt>'''cat''' script.pl | '''sed''' -e 's/file/fichier/ig' | '''sed''' y/a-e/A-E/</tt>. Bizarre, cela ressemble au Perl !? ;-)

----

== Obtenir de l'aide ou en savoir plus ==

=== Sur notre machine ===

Et oui ! Sur notre propre machine il y a plein de sources de documentation sans même le savoir. La première qui viens à l'esprit ''naturellement'' c'est LE <tt>man</tt>. <tt>man perl</tt> vous donne quelques généralités, ainsi que la liste de toutes les sections du manuel de perl (<tt>perlsyn</tt>, <tt>perlre</tt>, <tt>perlvar</tt>, <tt>perlop</tt>, <tt>perlfun</tt>...).

Ensuite, il y a le <tt>man</tt> propre à Perl, qui est <tt>perldoc</tt>. Le meilleur moyen de voir comment cela marche, c'est d'essayer : <tt>perldoc perldoc</tt>

Bon, l'inconvénient, c'est que tout ceci est en anglais...

=== Sur Internet ===

Sur Internet, nous trouverons plein de sites parlant de Perl. En général, ils parlent des scripts CGI (scripts Perl pour serveur web). Mais néanmoins, il y a

* le [http://www.perl.com site officiel], bien sûr.
* les groupes (français et anglais) marchent bien :
** [http://groups.google.com/groups?hl=en&group=fr.comp.lang.perl fr.comp.lang.perl]
** [http://groups.google.com/groups?hl=en&group=comp.lang.perl comp.lang.perl]
* les sites des ''mongueurs'' Perl, suivez mon regard ! ;-)
** Note de Jice : je me dois de citer les deux sites suivants, vu que le regard de Jonesy est sur moi ;)
** les [http://paris.mongueurs.net Paris Perl Mongueurs],
** et les [http://www.mongueurs.net Mongueurs de Perl] qui fédèrent les groupes locaux (Paris, Lyon, Toulouse...).
* la [http://perl.enstimac.fr/ traduction] de la documentation en français.
* une [http://perl.developpez.com/faq/ faq] sur developpez.com, visiter aussi le [http://www.developpez.net/forums/viewforum.php?f=83 forum] .
* et enfin, l'intarissable source, [http://www.google.com Google] ! ;-)

Sinon, si on a les moyens les livres O'Reilly sur Perl sont très bien écrits et sont la référence en la matière. 

== Le mot de la fin ==

Surtout n'hésitez pas à m'envoyer vos remarques, vos corrections et vos idées, merci.

<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Jonesy, Jice le 03/04/2002.</div>

= Copyright =
Copyright © 03/04/2002, Jonesy, Jice
{{CC-BY-NC-SA}}

Lea Linux - Contributions [fr]

Perl