Programmation en PERL

Une variable n'est qu'un endroit pratique pour conserver quelque chose, un endroit qui a un nom, ce qui fait que vous pouvez retrouver vos petits quand vous y revenez plus tard. Tout comme dans la vie réelle, il existe de nombreux endroits pour ranger des choses, certains privés et certains publics. Certains lieux sont temporaires et d'autres sont permanents. Les informaticiens adorent parler de « portée » des variables, mais c'est à peu près tout ce qu'ils entendent par là. Perl connaît de nombreux moyens de traiter les problèmes de portée, ce que vous serez ravis d'apprendre le moment venu. (Regardez l'emploi des adjectifs local, my et our dans le chapitre 29, si vous êtes curieux, ou bien regardez Déclarations avec portée dans le chapitre 4, Instructions et déclarations.)

Mais on classifie plus efficacement les variables par le type de données qu'elles peuvent représenter. De même qu'en français, la première distinction se fait entre le singulier et le pluriel. Les chaînes et les nombres sont des bouts de données singulières, alors que les listes de chaînes ou de nombres sont plurielles (et quand nous arriverons à la programmation orientée objet, vous verrez qu'un objet peut paraître singulier de l'extérieur, mais pluriel de l'intérieur, de même qu'une classe d'élèves). Nous appelons scalaire une variable singulière, et tableau une variable plurielle. Comme une chaîne peut être stockée dans une variable scalaire, nous pourrons écrire une version un peu plus longue (et mieux commentée) de notre premier exemple comme ceci :

$phrase = "Salut tout le monde !\n"; # Donner une valeur à une variable.
print $phrase;                       # Afficher la variable.

Remarquez que nous n'avons pas eu à prédéfinir le genre de la variable $phrase. Le caractère $ dit à Perl que phrase est une variable scalaire, c'est-à-dire qu'elle contient une valeur singulière. Une variable tableau, en revanche, commencerait par le caractère @ (on peut remarquer que $ est un « S » stylisé, pour scalaire, alors que @ est un « a » stylisé pour « array » , tableau en anglais).

Perl connaît d'autres types de variables aux noms bizarres comme « hachage », « handle » et « typeglob ». Tout comme les scalaires et les tableaux, ces types de variables sont également précédés par des caractères étranges. Dans un souci d'exhaustivité, voici la liste de tous les caractères étranges que vous pourrez rencontrer :

Pour certains « puristes » des langages, ces caractères étranges sont une raison d'abhorrer Perl. Cette raison est superficielle. Ces caractères procurent de nombreux avantages : les variables peuvent être interpolées dans des chaînes sans syntaxe supplémentaire. Les scripts Perl sont faciles à lire (pour ceux qui ont pris la peine d'apprendre Perl !) parce que les noms se distinguent des verbes, et que de nouveaux verbes peuvent être ajoutés au langage sans abîmer d'autres scripts (nous vous avions dit que Perl était conçu pour évoluer). Et l'analogie avec les noms n'a rien de frivole ; il existe de nombreux précédents dans divers langages naturels qui requièrent des marqueurs de noms grammaticaux. Enfin, c'est notre avis !

1-2-a-i. Singularités▲

$reponse = 42;                  # un entier
$pi = 3.14159265;               # un nombre "réel"
$avocats = 6.02e23;             # notation scientifique
$animal = "Chameau";            # chaîne
$signe = "Mon $animal et moi";  # chaîne avec interpolation
$cout = 'Cela coûte $100';      # chaîne sans interpolation
$pourquoi = $parceque;          # une autre variable
$x = $taupes * $avocats;        # une expression
$exit = system("vi $x");        # code de retour d'une commande
$cwd = `pwd`;                   # chaîne générée par une commande

$ary = \@montableau;            # référence à un tableau nommé
$hsh = \%monhachage;            # référence à un hachage nommé
$sub = \&monsousprog;           # référence à un sous-programme

$ary = [1,2,3,4,5];             # référence à un tableau anonyme
$hsh = {Na=>19, Cl=>35};        # référence à un hachage anonyme
$sub = sub { print $pays };     # référence à un sous-programme anonyme

$fido = new Chameau "Amelia";   # référence à un objet

$chameaux = '123';
print $chameaux + 1, "\n";

$fido = new Chameau "Amelia";
if (not $fido) { die "chameau mort"; }
$fido->seller();

1-2-a-ii. Pluralités▲

Certains types de variables contiennent plusieurs valeurs qui sont logiquement liées entre elles. Perl connaît deux types de variables multivaleurs : les tableaux et les hashes, tables de hachage (ou hachages). Ils se comportent comme des scalaires par de nombreux aspects. Ils se mettent à exister quand le besoin s'en fait sentir et ne contiennent alors rien. Quand on leur assigne une valeur, ils fournissent un contexte de liste du côté droit de l'assignation.

On emploie un tableau quand on veut chercher quelque chose par son numéro. On emploie une table de hachage quand on veut chercher quelque chose par son nom. Ces deux concepts sont complémentaires. On voit souvent des gens utiliser un tableau pour traduire les numéros de mois en noms, et un hachage correspondant pour traduire les noms en numéros (les hachages ne se limitent évidemment pas aux seuls nombres. Par exemple, il est possible d'avoir un hachage qui traduise les noms de mois en nom de pierres porte-bonheur).

Tableaux. Un tableau est une liste ordonnée de scalaires, indicée par la position du scalaire dans la liste. Celle-ci peut contenir des nombres, ou des chaînes, ou un mélange des deux (elle peut aussi contenir des références à d'autres listes ou hachages). Pour assigner une liste de valeurs à un tableau, il suffit de regrouper les variables (par des parenthèses) :

 

Sélectionnez

@maison = ("lit", "chaise", "table", "poele");

Inversement, si l'on utilise @maison dans un contexte de liste, comme ce que l'on trouve à droite d'une assignation, on obtient la même liste qui a été entrée. On peut donc assigner quatre variables depuis le tableau comme ceci :

 

Sélectionnez

($Procuste, $porteurs, $multiplication, $gratter) = @maison;

C'est ce que l'on appelle des assignations de liste. Elles se produisent logiquement en parallèle, et il est possible de permuter deux variables en écrivant :

 

Sélectionnez

($alpha,$omega) = ($omega,$alpha);

Tout comme en C, les tableaux démarrent à zéro ; quand on parle des quatre premiers éléments d'un tableau, leur énumération court de 0 à 3.(11) Les indices de tableaux sont entourés de crochets [comme ceci], et si l'on veut sélectionner un seul élément du tableau, on s'y réfère par $maison[n], où n est l'indice (un de moins que le numéro de l'élément) que l'on désire ; voyez l'exemple ci-dessous. Puisque l'élément considéré est un scalaire, il est toujours précédé d'un $.

Si l'on veut valoriser un seul élément de tableau à la fois, on écrit l'assignation précédente comme suit :

 

Sélectionnez

$maison[0] = "lit";
$maison[1] = "chaise";
$maison[2] = "table";
$maison[3] = "poele";

Comme les tableaux sont ordonnés, il existe plusieurs opérations utiles s'y rapportant, comme les opérations de pile, push et pop. Une pile n'est après tout qu'une liste ordonnée, avec un début et une fin. Surtout une fin. Perl considère que la fin de la liste est le haut d'une pile (bien que la plupart des programmeurs Perl pensent qu'une liste est horizontale, le haut de la pile étant à droite).

Hachages. Un hachage (hash en anglais) est un ensemble non ordonné de scalaires indexé par une valeur chaîne associée à chaque scalaire. C'est pourquoi les hachages sont souvent appelés « tableaux associatifs ». La principale raison pour laquelle leur appellation a changé est que « tableau associatif » est long à écrire pour les paresseux, et nous en parlons tellement souvent que nous avons décidé de prendre un nom plus bref.(12) Ensuite, le terme « hachage » souligne le fait qu'il s'agit de tables non ordonnées. Elles sont en fait implémentées grâce à un système de recherche dans une table de hachage, ce qui leur donne leur rapidité, rapidité qui reste inchangée quel que soit le nombre de valeurs présentes. On ne peut pas faire de push ou de pop sur un hachage, parce que cela n'a aucun sens. Un hachage n'a ni début ni fin. Les hachages sont néanmoins très puissants et très utiles. Tant que vous ne penserez pas en terme de hachages, vous ne penserez pas en Perl.

Puisque les clefs d'un tableau associatif ne sont pas ordonnées, vous devez fournir la clef aussi bien que sa valeur lorsque celui-ci est rempli. Vous pouvez aussi bien lui affecter une liste comme pour un tableau ordinaire, mais chaque paire d'éléments sera interprétée comme la paire clef/valeur. Les tableaux associatifs utilisent le symbole % pour s'identifier. (Pour mémoire, si vous regardez attentivement le caractère %, vous pouvez voir la clef et sa valeur avec entre deux le /.)

Supposons que nous voulions traduire les abréviations des noms de jours en leurs correspondants complets. Nous pourrions écrire cette assignation de liste :

 

Sélectionnez

%longjour = ("Dim", "Dimanche", "Lun", "Lundi", "Mar", "Mardi", 
             "Mer", "Mercredi", "Jeu", "Jeudi", "Ven", 
             "Vendredi", "Sam", "Samedi");

Comme il est parfois difficile de lire un hachage ainsi défini, Perl fournit la séquence => (égal, supérieur) comme alternative à la virgule. Cette syntaxe (associée à un formatage créatif) facilite la distinction entre clefs et valeurs.

 

Sélectionnez

%longjour = (
    "Dim" => "Dimanche",
    "Lun" => "Lundi",
    "Mar" => "Mardi",
    "Mer" => "Mercredi",
    "Jeu" => "Jeudi",
    "Ven" => "Vendredi",
    "Sam" => "Samedi",
);

Il est non seulement possible d'assigner une liste à un hachage, comme nous l'avons fait ci-dessus, mais si l'on emploie un hachage dans un contexte de liste, celui-ci convertira le hachage en une liste de paires clef/valeurs dans un ordre quelconque. La plupart du temps, on se contente d'extraire une liste des seules clefs, grâce à la fonction (bien nommée) keys. Elle est également non ordonnée, mais peut être facilement triée au besoin grâce à la fonction (bien nommée) sort. On peut alors utiliser les clefs ordonnées pour accéder aux valeurs dans un ordre déterminé.

Les hachages n'étant qu'une forme évoluée de tableau, il suffit d'en sélectionner un élément individuel en entourant la clef par des accolades. C'est ainsi que pour trouver la valeur associée à Mer dans le hachage ci-dessus, il faut écrire $longjour{"Mer"}. Remarquez encore une fois qu'il s'agit d'une valeur scalaire et qu'il faut donc écrire $ et non %.

D'un point de vue linguistique, la relation codée dans un hachage est génitive ou possessive, comme les mots « de », « du » ou « d' » en français. La femme d'Adam est Eve, et nous pouvons écrire :

 

Sélectionnez

$femme{"Adam"} = "Eve";

1-2-a-iii. Complexités▲

$femme{"Jacob"} = ("Léa", "Rachel", "Bilha", "Zilpa");   # MAUVAIS

$femme{"Jacob"} = ["Léa", "Rachel", "Bilha", "Zilpa"];   # ok

$femme{"Jacob"}[0] = "Léa";
$femme{"Jacob"}[1] = "Rachel";
$femme{"Jacob"}[2] = "Bilha";
$femme{"Jacob"}[3] = "Zilpa";

$filsDesFemmesDe{"Jacob"} = {
    "Léa"    => ["Ruben", "Siméon", "Lévi", "Juda", "Issachar", "Zabulon"],
    "Rachel" => ["Joseph", "Benjamin"],
    "Bilha"  => ["Dan", "Nephtali"],
    "Zilpa"  => ["Gad", "Aser"],
};

$fils_des_femmes_de{"Jacob"}{"Léa"}[0]    = "Ruben";
$fils_des_femmes_de{"Jacob"}{"Léa"}[1]    = "Siméon";
$fils_des_femmes_de{"Jacob"}{"Léa"}[2]    = "Lévi";
$fils_des_femmes_de{"Jacob"}{"Léa"}[3]    = "Juda";
$fils_des_femmes_de{"Jacob"}{"Léa"}[4]    = "Issachar";
$fils_des_femmes_de{"Jacob"}{"Léa"}[5]    = "Zabulon";
$fils_des_femmes_de{"Jacob"}{"Rachel"}[0] = "Joseph";
$fils_des_femmes_de{"Jacob"}{"Rachel"}[1] = "Benjamin";
$fils_des_femmes_de{"Jacob"}{"Bilha"}[0]  = "Dan";
$fils_des_femmes_de{"Jacob"}{"Bilha"}[1]  = "Nephtali";
$fils_des_femmes_de{"Jacob"}{"Zilpa"}[0]  = "Gad";
$fils_des_femmes_de{"Jacob"}{"Zilpa"}[1]  = "Aser";

$fido = new Chameau "Amelia";

1-2-a-iv. Simplicité▲

package Chameau;

package Chameau;
$fido = &fetch();

package Chien;
$fido = &fetch();

$fido = new Chameau "Amelia";

$fido->seller();

use Chameau;

$fido = new Chameau "Amelia";

use Le::Cool::Module;

use strict;

Comme tous les langages informatiques impératifs, de nombreux verbes de Perl correspondent à des commandes : elles disent à l'interpréteur de Perl de faire quelque chose. En revanche, comme dans un langage naturel, les significations des verbes de Perl tendent à s'éparpiller dans plusieurs directions selon le contexte. Une instruction commençant par un verbe est en général purement impérative et évaluée entièrement pour ses effets secondaires. Nous appelons souvent ces verbes procédures, surtout quand ils sont définis par l'utilisateur. Un verbe fréquemment rencontré (que vous avez d'ailleurs déjà vu) est la commande print :

print "La femme d'Adam est ", $femme{'Adam'}, ".\n";

L'effet secondaire produit la sortie désirée.

Mais il existe d'autres « modes » que le mode impératif. Certains verbes permettent d'interroger l'interpréteur sur certaines valeurs comme dans les conditionnelles comme if. D'autres verbes traduisent leurs paramètres d'entrée en valeurs de retour, tout comme une recette vous indique comment transformer des ingrédients de base en un résultat (peut-être) comestible. Nous appelons souvent ces verbes des fonctions, par déférence envers des générations de mathématiciens qui ne savent pas ce que signifie le mot « fonctionnel » en langage naturel.

Un exemple de fonction interne est l'exponentielle :

$e = exp(1); # 2.718281828459, ou à peu près

Mais Perl ne fait pas de distinction entre les procédures et les fonctions. Les termes seront employés de façon interchangeable. Les verbes sont parfois appelés sous-programmes (subroutines) quand ils sont définis par l'utilisateur, ou opérateurs (s'ils sont prédéfinis). Mais appelez-les comme il vous plaira ; ils renvoient tous une valeur, qu'elle soit ou non significative, que vous pouvez ou non choisir d'ignorer.

Au fur et à mesure que nous avançons, nous verrons d'autres exemples du comportement de Perl qui le font ressembler à un langage naturel. Nous avons déjà insidieusement présenté certaines notions de langage mathématique, comme l'addition et les indices, sans parler de la fonction exponentielle. Perl est aussi un langage de contrôle, un langage d'intégration, un langage de traitement de listes et un langage orienté objet. Entre autres.

Mais Perl est aussi un bon vieux langage informatique. Et c'est ce à quoi nous allons maintenant nous intéresser.

Bien. Vous devez être en train de vous demander comment lancer un programme Perl. La réponse la plus courte est que vous le donnez au programme interpréteur de Perl, qui s'appelle justement perl (notez le p minuscule). Une réponse plus complète commence comme ceci : Il Existe Plus D'Une Façon De Faire.(13)

La première manière d'invoquer perl (qui fonctionne sur la plupart des systèmes d'exploitation) est d'appeler explicitement perl depuis la ligne de commande.(14) Si vous vous trouvez sur une version d'UNIX et que ce que vous faites est relativement simple, vous pouvez utiliser l'option -e (le % de l'exemple suivant représentant une invite standard de shell, il ne faut pas le taper) :

% perl -e 'print "Salut tout le monde!\n";'

Sous d'autres systèmes d'exploitation, il faudra peut-être jouer des apostrophes. Mais le principe de base est le même : vous essayez de rentrer tout ce que Perl doit savoir en 80 colonnes.(15)

Pour les scripts plus longs, vous pouvez utiliser votre éditeur favori (ou un autre) pour écrire vos commandes dans un fichier, puis, si le script s'appelle « gradation », vous entrez :

% perl gradation

Vous invoquez toujours explicitement l'interpréteur Perl, mais au moins, vous n'avez pas à tout mettre sur la ligne de commande à chaque fois. Et vous n'avez pas à jouer des apostrophes pour plaire au shell.

La façon la plus commode d'invoquer un script est de simplement l'appeler par son nom (ou de cliquer sur son icône), et de laisser le système d'exploitation trouver l'interpréteur tout seul. Sous certains systèmes, il peut exister un moyen d'associer certaines extensions de fichier ou certains répertoires à une application particulière. Sur les systèmes UNIX qui supportent la notation #! (appelée shebang), la première ligne du script peut être magique et dire au système d'exploitation quel programme lancer. Mettez une ligne ressemblant(16) à la ligne 1 de notre exemple dans votre programme :

#!/usr/bin/perl

Tout ce qu'il vous reste à écrire est maintenant :

% gradation

Ce qui ne fonctionne évidemment pas parce que vous avez oublié de rendre le script exécutable (voir la page de manuel de chmod (1)(17) et qu'il n'est pas dans votre PATH. Dans ce cas, vous devrez fournir un nom de chemin complet pour que votre système d'exploitation sache comment trouver votre script. Quelque chose comme :

% ../bin/gradation

Enfin, si vous avez la malchance de travailler sur un ancien système UNIX qui ne reconnaît pas la ligne magique #!, ou si le chemin vers votre interpréteur est plus long que 32 caractères (une limite interne sur certains systèmes), vous pourrez contourner le problème comme ceci :

#!/bin/sh --# perl, pour arrêter de boucler
eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
    if 0;

Certains systèmes d'exploitation peuvent demander une modification de ce qui précède pour gérer, /bin/sh, DCL, COMMAND.COM, ou tout ce qui vous tient lieu d'interpréteur de commandes. Demandez à votre Expert Local.

Tout au long de ce livre, nous nous contenterons d'employer #!/usr/bin/perl pour représenter toutes ces notions et toutes ces notations, mais vous saurez à quoi vous en tenir.

Une astuce : quand vous écrivez un script de test, ne l'appelez pas test. Les systèmes UNIX ont une commande test interne, qui sera exécutée à la place de votre script. Appelez-le plutôt essai.

Une autre astuce : pendant que vous apprenez Perl, et même quand vous croyez savoir ce que vous faites, nous vous suggérons d'utiliser l'option -w, surtout pendant le développement. Cette option active toutes sortes de messages d'avertissement utiles et intéressants (dans le désordre). L'option -w peut être placée sur la ligne « magique », comme ceci :

#!/usr/bin/perl -w

Maintenant que vous savez lancer votre programme Perl (à ne pas confondre avec le programme perl), revenons à notre exemple.

Les opérateurs arithmétiques font exactement ce que l'on peut attendre d'eux après les avoir étudiés à l'école.

Oui, nous avons bien laissé de côté la soustraction et la division. Mais vous devez pouvoir deviner comment celles-ci fonctionnent. Essayez-les et voyez si vous aviez raison (ou trichez et cherchez dans le chapitre 3, Opérateurs unaires et binaires.) Les opérateurs arithmétiques sont évalués dans l'ordre habituel (c'est-à-dire la puissance avant la multiplication, et la multiplication avant l'addition). Les parenthèses servent à modifier l'ordre.

Il existe également un opérateur d'« addition » pour les chaînes, qui effectue leur concaténation. Contrairement à d'autres langages qui le confondent avec l'addition arithmétique, Perl définit un opérateur distinct (.) pour cette opération.

$a = 123;
$b = 456;
print $a + $b;  # affiche 579
print $a . $b;  # affiche 123456

Il existe aussi un opérateur de « multiplication » pour les chaînes, également appelée répétition. Il s'agit encore d'un opérateur distinct (x) qui le différencie de la multiplication numérique :

$a = 123;
$b = 3;
print $a * $b;  # affiche 369
print $a x $b;  # affiche 123123123

L'opérateur de répétition est un peu inhabituel en ce qu'il prend une chaîne pour son argument de gauche et un nombre pour celui de droite. Remarquez également comment Perl convertit automatiquement les nombres en chaînes. Tous les nombres ci-dessus pourraient être protégés par des apostrophes doubles avec le même résultat. La conversion interne se serait par contre produite dans le sens inverse (c'est-à-dire de chaînes vers des nombres).

Il faut encore penser à quelques détails. La concaténation de chaînes est également implicite dans l'interpolation qui se produit dans des chaînes entre doubles apostrophes. Quand une liste de valeurs est affichée, les chaînes de caractères sont en fait concaténées. Les trois instructions suivantes produisent donc le même résultat :

print $a . ' est égal à ' . $b . "\n";   # opérateur point
print $a, ' est égal à ', $b, "\n";      # liste
print "$a est égal à $b\n";              # interpolation

Le choix de celui qu'il convient d'utiliser ne dépend que de vous.

L'opérateur x peut sembler relativement inutile à première vue, mais il trouve son utilité dans des cas comme celui-ci :

print "-" x $lrgecr, "\n";

Ceci trace une ligne à travers l'écran, à supposer que sa largeur soit $lrgecr.

Bien qu'il ne s'agisse pas vraiment d'un opérateur mathématique, nous avons déjà employé en de nombreuses occasions l'opérateur d'assignation simple, =. Essayez de vous souvenir que = signifie « est mis à » au lieu de « égale » (il existe aussi un opérateur d'égalité mathématique == qui signifie « égale » , et si vous commencez à réfléchir tout de suite à la différence entre les deux, vous aurez beaucoup moins mal à la tête plus tard. L'opérateur == est comme une fonction qui renvoie une valeur booléenne, alors que = est comme une procédure évaluée dont l'effet est de modifier une variable).

De même que les opérateurs précédents, les opérateurs d'assignation sont des opérateurs binaires infixes, ce qui veut dire qu'ils ont un opérande de chaque côté de l'opérateur. L'opérande de droite peut être n'importe quelle expression, mais celui de gauche doit être une lvalue correcte (ce qui, traduit en bon français, signifie un emplacement de stockage valide, comme une variable ou un élément de tableau). L'opérateur d'assignation le plus courant est l'assignation simple. Il détermine la valeur de l'expression à sa droite, puis met la variable à sa gauche à cette valeur :

$a = $b;
$a = $b + 5;
$a = $a * 3;

Remarquez que la dernière assignation se réfère deux fois à la même variable ; une fois pour le calcul et une autre pour l'assignation. Rien d'extraordinaire à cela, mais cette opération est assez commune pour qu'elle connaisse une abréviation (empruntée au C). Si l'on écrit :

lvalue opérateur= expression

cela sera évalué comme si c'était :

lvalue = lvalue opérateur expression

sauf que la lvalue n'est pas calculée deux fois. On ne perçoit de différence que si l'évaluation de la lvalue a un effet secondaire. Mais quand il y a une différence, l'opérateur fait généralement ce que vous vouliez.

On peut, par exemple, écrire :

$a *= 3;

ce qui se lit « multiplier $a par 3 et l'affecter à $a ». Presque tous les opérateurs binaires de Perl le permettent, et même certains de ceux qui ne le peuvent pas en C :

$ligne .= "\n"; # Ajouter un saut de ligne à $ligne.
$fill x= 80;    # Répéter $fill 80 fois sur elle-même.
$val ||= "2";   # Mettre $val à 2 si ce n'est pas déjà le cas.

La ligne 6 de notre exemple(22) de notation contient deux concaténations de chaînes, dont l'une est un opérateur d'affectation. Et la ligne 14 contient un +=.

Quel que soit le type d'opérateur d'affectation utilisé, la valeur finale qui est renvoyée est celle de l'affectation complète(23). Ceci ne surprendra pas les programmeurs C qui le savait déjà en écrivant

$a = $b = $c = 0;

pour initialiser à 0 toutes les variables.

Ce qui par contre les surprendra est que l'affectation Perl retourne en lvalue la variable elle-même, de telle sorte qu'il est possible en une instruction de le modifier deux fois, c'est pourquoi nous pouvons écrire :

($temp -= 32) *= 5/9;

pour faire la conversion en ligne Fahrenheit vers Celsius. C'est aussi pourquoi nous avons pu écrire plus haut dans ce chapitre :

chop($nombre = <STDIN>);

pour que la valeur finale de $nombre soit modifiée par chop. Pour résumer, on peut utiliser cette fonctionnalité chaque fois que l'on veut faire une copie suivie d'une modification de variable.

Ce truc peut être utilisé pour faire deux choses sur la même ligne Perl.

Comme si $variable += 1 n'était pas assez court, Perl emprunte au C un moyen encore plus concis d'incrémenter une variable. Les opérateurs d'autoincrémentation et d'autodécrémentation ajoutent (ou soustraient) un à la valeur de la variable. Ils peuvent être placés avant ou après cette variable, ce qui détermine le moment de leur évaluation.

Si l'on place l'un des opérateurs auto avant la variable, il s'agit d'une variable préincrémentée (ou prédécrémentée). Sa valeur sera modifiée avant son référencement. S'il est placé après la variable, il s'agit d'une variable postincrémentée (ou postdécrémentée) et sa valeur est modifiée après son utilisation. Par exemple :

$a = 5;        # $a prend la valeur 5
$b = ++$a;     # $b prend la valeur incrémentée de $a, soit 6
$c = $a--;     # $c prend la valeur 6, puis $a passe à 5

La ligne 15 de notre exemple de notation incrémente de un le nombre de notes, afin que nous puissions calculer la moyenne. Nous utilisons un opérateur de postincrémentation ($scores++), mais cela n'a pas d'importance dans ce cas puisque l'expression se trouve dans un contexte vide, ce qui n'est qu'une façon particulière de dire que l'expression n'est évaluée que pour l'effet secondaire de l'incrémentation de la variable. La valeur renvoyée est jetée au panier.(24)

Les opérateurs logiques, que l'on connaît également sous le nom d'opérateurs « court-circuit », permettent au programme de prendre des décisions en fonction de critères multiples sans utiliser les conditionnelles imbriquées. On les appelle court-circuit, car ils arrêtent l'évaluation de leur argument de droite si l'argument de gauche suffit à déterminer la valeur globale.

Perl a en fait deux ensembles d'opérateurs logiques : l'un d'eux, plutôt poussiéreux, emprunté au C, et un superbe ensemble tout neuf d'opérateurs à précédence ultra-basse qui analysent plus comme ce qu'on en attend (mais ils se comportent de la même façon une fois analysés). Perl possède deux ensembles d'opérateurs logiques, l'un dit traditionnel emprunté au C, l'autre avec une précédence encore plus faible venant du BASIC. L'un a la précédence la plus forte des opérateurs du langage, l'autre la plus faible. Souvent les expressions sont équivalentes, c'est une question de préférences. (Pour une comparaison, voir la section And, or, not et xor logiques au chapitre 3.) Bien qu'ils ne sont pas interchangeables, à cause de la précédence, une fois parsés ils s'exécutent avec le même code. La précédence précise l'étendue locale de arguments.

Puisque les opérateurs logiques « court-circuitent », ils sont souvent utilisés pour exécuter du code de manière conditionnelle. La ligne suivante (de notre exemple de notation) essaie d'ouvrir le fichier « notes ». Si elle peut ouvrir le fichier, elle saute à la ligne suivante du programme. Dans le cas contraire, elle affiche un message d'erreur et arrête l'exécution.

open(NOTES, "notes") or die "Ouverture du fichier notes impossible: $!\n";

Littéralement, « Ouvrir notes ou mourir ! » est encore un exemple de langage naturel, et les opérateurs de court-circuit préservent le f lux visuel. Les actions importantes sont listées en bas à gauche de l'écran et les actions secondaires sont cachées à droite. (La variable $! contient le message d'erreur renvoyé par le système d'exploitation ; voir le chapitre 28, Noms spéciaux.) Bien sûr, ces opérateurs logiques peuvent aussi être employés dans des constructions plus traditionnelles, comme les instructions if et while.

Les opérateurs de comparaison, ou relationnels, nous indiquent la relation existant entre deux valeurs scalaires (nombres ou chaînes). Il existe deux ensembles d'opérateurs, dont l'un effectue les comparaisons numériques et l'autre des comparaisons de chaînes. (Dans les deux cas, les arguments seront d'abord transtypés, « contraints », pour prendre le bon type.) Le tableau suivant suppose que $a et $b sont respectivement les arguments de gauche et de droite.

On peut penser que les deux derniers opérateurs (<=> et cmp) sont entièrement redondants. Vous avez raison. Cependant, ils sont incroyablement utiles dans les sous-programmes de tri (sort).(25)

Les opérateurs de tests de fichier permettent de tester si certains attributs de fichier sont positionnés avant de faire aveuglément n'importe quoi avec ces fichiers. Par exemple, il vaut mieux s'assurer que le fichier /etc/passwd existe déjà avant de l'ouvrir en création, effaçant ainsi tout ce qui s'y trouvait auparavant.

En voici quelques exemples :

-e "/usr/bin/perl" or warn "Perl est mal installé\n";
-f "/boot" and print "Félicitations, nous devons être sous Unix BSD\n";

Remarquez qu'un fichier régulier n'est pas la même chose qu'un fichier texte. Les fichiers binaires comme /vmunix sont des fichiers réguliers, mais ne sont pas des fichiers texte. Les fichiers texte sont l'inverse des fichiers binaires, alors que les fichiers réguliers sont l'inverse des fichiers « irréguliers » comme les répertoires et les périphériques.

Il existe beaucoup d'opérateurs de test de fichier, dont un grand nombre n'ont pas été cités. La plupart sont des opérateurs booléens unaires : ils ne prennent qu'un seul opérande, un scalaire qui donne un fichier ou un handle de fichier, et ils renvoient une valeur vraie ou fausse. Quelques-uns renvoient une valeur plus complexe comme la taille du fichier ou son âge, mais vous pourrez les rechercher en temps utile dans la section Opérateurs unaires nommés et de test de fichier au chapitre 3.

Nous avons déjà parlé de la vérité(26) et nous avons mentionné que certains opérateurs renvoient une valeur vraie ou fausse. Avant de continuer, nous devons expliquer exactement ce que nous entendons par là. Perl ne traite pas tout à fait la vérité comme les autres langages informatiques, mais son comportement prend tout son sens avec un peu d'habitude. (En fait, nous espérons qu'il prendra tout son sens après avoir lu ce qui suit.)

À la base, Perl estime que la vérité est « évidente en soi ». C'est une façon un peu spécieuse de dire que l'on peut évaluer presque n'importe quoi pour connaître sa valeur de vérité. Perl emploie en pratique des définitions de la vérité qui dépendent du type de ce que l'on est en train d'évaluer. Il se trouve qu'il existe beaucoup plus de types de vérité que de types de non-vérité.

La vérité en Perl est toujours évaluée dans un contexte scalaire (sinon, aucun transtypage n'est effectué). Voici donc les règles des divers types de valeurs qu'un scalaire peut contenir :

1. Toute chaîne est vraie sauf "" et "0".
2. Tout nombre est vrai sauf 0.
3. Toute référence est vraie.
4. Toute valeur indéfinie est fausse.

En fait, les deux dernières règles peuvent être dérivées des deux premières. Toute référence (règle 3) pointe vers quelque chose avec une adresse, et donne un nombre ou une chaîne contenant cette adresse, qui n'est jamais nulle. Et toute valeur indéfinie (règle 4) donne 0 ou la chaîne nulle.

Et d'une certaine manière, il est possible de faire dériver la règle 2 de la règle 1 si l'on pose que tout est une chaîne. Encore une fois, aucun transtypage n'est effectué pour évaluer la vérité, mais même si c'était le cas, une valeur numérique de 0 donnerait simplement la chaîne « 0 » et serait fausse. Tout autre nombre donnerait autre chose et serait vrai. Quelques exemples nous permettront de saisir un peu mieux ce que cela implique :

0          # deviendrait la chaîne "0", donc faux
1          # deviendrait la chaîne "1", donc vrai
10 -10     # 10-10 vaut 0, deviendrait la chaîne "0", donc faux
0.00       # devient 0, et donc la chaîne "0", donc faux
"0"        # la chaîne "0", donc faux
""         # une chaîne nulle, donc faux
"0.00"     # la chaîne "0.00", ni vide, ni vraiment "0", donc vrai 
"0.00" + 0 # le nombre 0 (transtypé par +), donc faux
\$a        # une référence à $a, donc vrai, même si $a est faux 
undef()    # une fonction renvoyant la chaîne indéfinie, donc faux

Comme nous avons déjà dit que la vérité était évaluée dans un contexte scalaire, on peut se demander quelle serait la valeur d'une liste. En fait, il n'existe pas d'opération renvoyant une liste dans un contexte scalaire. Toutes renvoient une valeur scalaire et il suffit d'appliquer les règles de vérité à ce scalaire. Il n'y a donc pas de problème, tant que l'on sait ce qu'un opérateur donné renvoie dans un contexte scalaire.

1-6-a-i. Les instructions if et unless▲

if ($debug_level > 0) {
    # Quelque chose ne va pas. Il faut avertir l'utilisateur.
    print "Debug: Danger, Arthur Accroc, danger!\n";
    print "Debug: La réponse est '54' au lieu de '42'.\n";
}

if ($city eq "Lille") {
    print "Lille est au nord de Paris.\n";
}
elsif ($city eq "Nancy") {
    print "Nancy est à l'est de Paris.\n";
}
elsif ($city eq "Bayonne") {
    print "Bayonne est au sud-ouest de Paris. Et il y fait plus chaud!\n";
}
else {
    print "Je ne sais pas où se trouve $city, désolé.\n";
}

unless ($destination eq $maison) {
    print "Je ne rentre pas à la maison.\n";
}

Perl possède quatre types principaux d'instructions itératives : while, until, for et foreach. Ces instructions permettent à un programme Perl d'exécuter de façon répétitive le même code pour différentes valeurs.

1-6-b-i. Les instructions while et until▲

while ($tickets_vendus < 10000) {
    $dispo = 10000 -$tickets_vendus;
    print "$dispo tickets sont disponibles. Combien en voulez -vous: ";
    $achat = <STDIN>;
    chomp($achat);
    $tickets_vendus += $achat;
}

print "Ce spectacle est complet, revenez plus tard.\n";

while ($ligne = <NOTES>) {

while (@ARGV) {
    process(shift @ARGV);
}

1-6-b-ii. L'instruction for▲

for ($vendu = 0; $vendu < 10000; $vendu += $achat) {
    $dispo = 10000 -$vendu;
    print "$dispo tickets sont disponibles. Combien en voulez-vous: ";
    $achat = <STDIN>;
    chomp($achat);
}

1-6-b-iii. L'instruction foreach▲

foreach $user (@users) {
    if (-f "$home{$user}/.nexrc") {
        print "$user est un type bien... il utilise un vi qui 
               comprend Perl!\n";
    }
}

foreach $clef (sort keys %hash) {

1-6-b-iv. Pour s'en sortir : next et last▲

foreach $user (@users) {
    if ($user eq "root" or $user eq "lp") {
       next;
    }
    if ($user eq "special") {
        print "Compte spécial trouvé.\n";
        # Traitement 
        last;
    }
}

LIGNE: while ($ligne = <ARTICLE>) {
    last LIGNE if $ligne eq "\n";   # arrêt sur la première ligne vide
    next LIGNE if /^#/;             # sauter les lignes de commentaire
    # ici, votre publicité
}

Les caractères et les classes de caractères dont nous avons parlé recherchent des caractères uniques. Nous avons déjà mentionné que l'on pouvait rechercher plusieurs caractères «de mot» avec \w+ pour correspondre à un mot complet. Le + est un de ces quantificateurs, mais il y en a d'autres (tous sont placés après l'élément quantifié).

La forme la plus générale de quantificateur spécifie le nombre minimal et le nombre maximal de fois auquel un élément peut correspondre. Les deux nombres sont mis entre accolades, séparés par une virgule. Par exemple, pour essayer de trouver les numéros de téléphone d'Amérique du Nord, /\d{7,11}/ rechercherait au moins 7 chiffres, mais au plus 11 chiffres. Si un seul chiffre se trouve entre les accolades, il spécifie à la fois le minimum et le maximum ; c'est-à-dire que le nombre spécifie le nombre exact de fois que l'élément peut être répété. (Si l'on y réfléchit, tous les éléments non quantifiés ont un quantificateur implicite {1}.)

Si l'on met le minimum et la virgule en omettant le maximum, ce dernier passe à l'infini. En d'autres termes, le quantificateur indique le nombre minimum de caractères, et tous ceux qu'il trouvera après cela. Par exemple, /\d{7}/ ne trouvera qu'un numéro de téléphone local (d'Amérique du Nord, à sept chiffres), alors que /\d{7,}/ correspondra à tous les numéros de téléphones, même les internationaux (sauf ceux qui comportent moins de 7 chiffres). Il n'existe pas de façon spécifique d'écrire « au plus » un certain nombre de caractères. Il suffit d'écrire, par exemple, /.{0,5}/ pour trouver au plus cinq caractères quelconques.

Certaines combinaisons de minimum et de maximum apparaissant fréquemment, Perl définit des quantificateurs spéciaux. Nous avons déjà vu +, qui est identique à {1,}, c'est-à-dire « au moins une occurrence de l'élément qui précède ». Il existe aussi *, qui est identique à {0,}, ou « zéro occurrence ou plus de l'élément qui précède », et ?, identique à {0,1}, ou « zéro ou une occurrence de l'élément qui précède » (l'élément qui précède est donc optionnel).

Il faut savoir deux ou trois choses concernant la quantification. D'abord, les expressions rationnelles de Perl sont, par défaut, avides. Cela signifie qu'elles essayent de trouver une correspondance tant que l'expression entière correspond toujours. Par exemple, si l'on compare /\d+ à « 1234567890 », cela correspondra à la chaîne entière. Il faut donc spécialement surveiller l'emploi de « . », tout caractère. On trouve souvent une chaîne comme :

larry:JYHtPh0./NJTU:100:10:Larry Wall:/home/larry:/bin/tcsh

où on essaye de trouver « larry » avec /.+:/. Cependant, comme les expressions rationnelles sont avides, ce motif correspond à tout ce qui se trouve jusqu'à « /home/larry » inclus. On peut parfois éviter ce comportement en utilisant une négation de classe de caractères, par exemple avec /[\^:]+:/, qui indique de rechercher un ou plusieurs caractères non-deux-points (autant que possible), jusqu'au premier deux-points. C'est le petit chapeau qui inverse le sens de la classe de caractères.(32) L'autre point à surveiller est que les expressions rationnelles essayent de trouver une correspondance dès que possible. Ce point est même plus important que l'avidité. Le balayage se produisant de gauche à droite, cela veut dire que le motif cherchera la correspondance la plus à gauche possible, même s'il existe un autre endroit permettant une correspondance plus longue (les expressions rationnelles sont avides, mais elles voient à court terme). Par exemple, supposons que l'on utilise la commande de substitution s/// sur la chaîne par défaut (à savoir la variable $_), et que l'on veuille enlever une suite de x du milieu de la chaîne. Si l'on écrit :

$_ = "fred xxxxxxx barney";
s/x*//;

cela n'aura aucun effet. En effet, le x* (voulant dire zéro caractères « x » ou plus) trouvera le « rien » au début de la chaîne, puisque la chaîne nulle est large de zéro caractères et que l'on trouve une chaîne nulle juste avant le « f » de « fred ».(33)

Encore une chose à savoir. Par défaut, les quantificateurs s'appliquent à un caractère unique les précédant, ce qui fait que /bam{2}/ correspond à « bamm », mais pas à « bambam ». Pour appliquer un quantificateur à plus d'un caractère, utilisez les parenthèses. Il faut employer le motif /(bam){2}/ pour trouver « bambam ».

Si l'on ne voulait pas de « correspondances avides » dans les anciennes versions de Perl, il fallait employer la négation d'une classe de caractères (et en fait, on obtenait encore une correspondance avide, bien que restreinte).

Les versions modernes de Perl permettent de forcer une correspondance minimale par l'emploi d'un point d'interrogation après tout quantificateur. Notre recherche de nom d'utilisateur serait alors /.*?:/. Ce .*? essaye alors de correspondre à aussi peu de caractères que possible, au lieu d'autant que possible, et il s'arrête donc au premier deux-points au lieu du dernier.

Chaque fois que l'on cherche à faire correspondre un motif, celui-ci essayera partout jusqu'à ce qu'il trouve une correspondance. Une ancre permet de restreindre l'espace de recherche. Une ancre est d'abord quelque chose qui ne correspond à « rien », mais il s'agit là d'un rien d'un type spécial qui dépend de son environnement. On peut aussi l'appeler une règle, une contrainte ou une assertion. Quelle que soit son appellation, elle essaie de faire correspondre quelque chose de longueur zéro, et réussit ou échoue. (En cas d'échec, cela veut surtout dire que le motif ne trouve pas de correspondance de cette façon. Il essaie alors d'une autre manière, s'il en existe.)

La chaîne de caractères spéciale \b correspond à une limite de mot, qui est définie comme le « rien » entre un caractère de mot (\w) et un caractère de non-mot (\W), dans le désordre. (Les caractères qui n'existent pas de part et d'autre de la chaîne sont appelés des caractères de non-mot). Par exemple,

/\bFred\b/

correspond à « Le Grand Fred » et à « Fred le Grand » , mais ne correspond pas à « Frederic le Grand » parce que le « de » de Frederic ne contient pas de limite de mot.

Dans une veine similaire, il existe également des ancres pour le début et la fin d'une chaîne. S'il s'agit du premier caractère d'un motif, le chapeau (^) correspond au « rien » au début de la chaîne. Le motif /^Fred/ correspondrait donc à « Frederic le Grand» et non à « Le Grand Fred », alors que /Fred^/ ne correspondrait à aucun des deux (et ne correspondrait d'ailleurs pas à grand-chose). Le signe dollar ($) fonctionne comme le chapeau, mais il correspond au « rien » à la fin de la chaîne au lieu du début.(34)

Vous devez maintenant être en mesure de deviner ce que veut dire :

next LIGNE if /^#/;

C'est bien sûr « Aller à la prochaine itération de la boucle LIGNE si cette ligne commence par un caractère # ».

Nous avons dit plus haut que la séquence \d{7,11} coïncide avec un nombre de 7 à 11 chiffres de long ce qui est vrai, mais incomplet : quand cette séquence est utilisée dans une expression comme /\d{7,11}/, ça n'exclue pas d'autres chiffres après les 11 premiers. Donc, le plus souvent, lorsque vous utilisez des quantificateurs, vous utiliserez des ancres de chaque côté.

Nous avons déjà mentionné que l'on pouvait employer des parenthèses pour grouper des caractères devant un quantificateur, mais elles peuvent aussi servir à se souvenir de parties de ce qui a été trouvé. Une paire de parenthèses autour d'une partie d'expression rationnelle permet de se souvenir de ce qui a été trouvé pour une utilisation future. Cela ne change pas le motif de recherche, et /\d+ et /(\d+)/ chercheront toujours autant de chiffres que possible, mais dans le dernier cas, ceux-ci seront mémorisés dans une variable spéciale pour être « référencés en arrière » plus tard.

La façon de référencer la partie mémorisée de la chaîne dépend de l'endroit d'où on opère. Dans la même expression rationnelle, on utilise un antislash suivi d'un entier. Il correspond à une paire de parenthèses donnée, déterminée en comptant les parenthèses gauches depuis la gauche du motif, en commençant par un. Par exemple, pour rechercher quelque chose ressemblant à une balise HTML (comme « <B>Gras</B> »), on peut utiliser /<(.*?)>.*?<\/\1>/. On force alors les deux parties du motif à correspondre exactement à la même chaîne de caractères, comme au « B » ci-dessus.

Hormis l'expression rationnelle elle-même, comme dans la partie de remplacement d'une substitution, la variable spéciale est utilisée comme s'il s'agissait d'une variable scalaire normale nommée par l'entier. Donc, si l'on veut échanger les deux premiers mots d'une chaîne, par exemple, on peut employer :

s/(\S+)\s+(\S+)/$2 $1/

Le côté droit de la substitution équivaut à une sorte de chaîne protégée par des apostrophes doubles, ce qui explique pourquoi l'on peut y interpoler des variables, y compris des références arrière. Ce concept est puissant : l'interpolation (sous contrôle) est une des raisons pour lesquelles Perl est un bon langage de traitement de texte. Entre autres raisons, on trouve bien entendu les motifs de correspondance. Les expressions rationnelles savent parfaitement extraire des éléments et l'interpolation sert à les rassembler. Peut-être existe-t-il enfin un espoir pour Humpty Dumpty.