Programmation en PERL

Le plus petit élément visible du langage est le caractère, celui que l'on peut visualiser dans un éditeur par exemple. Au départ, Perl ne faisait pas la distinction entre octets et caractères ASCII, mais pour des raisons d'internationalisation, il faut bien distinguer les deux.

Le code Perl peut être écrit exclusivement en ASCII, mais autorise aussi l'utilisation d'un codage sur 8 ou 16 bits, qu'il soit celui d'une langue ou bien de tout autre codage défini régulièrement, à condition de le faire dans des chaînes litérales uniquement. Bien sûr, Perl ne vérifiera pas le contenu du texte, mais saura simplement qu'un caractère est codé sur 16 bits.

Comme expliqué au chapitre 15, Unicode, Perl implémente Unicode.(35) C'est transparent pour l'utilisateur du langage qui peut en utiliser aussi bien dans des identificateurs (noms de variables, etc.) que dans des chaînes litérales. Pour Perl, tous les caractères ont la même taille de référence, par exemple 1, quelle que soit la représentation interne qu'il en fait ensuite. En principe, il code les caractères sous forme UTF-8 et donc un caractère peut avoir une forme interne sur 1, 2, 3... octets. (L'Unicode smiley U-263A est une séquence de 3 octets.)

Mais poursuivons l'analogie physique un peu plus avant avec les atomes. Les caractères sont atomiques de la même façon que les atomes codent les différents éléments. Un caractère est composé de bits et d'octets, mais si on le désintègre (dans un accélérateur de caractères, sans doute), il perd toutes ses propriétés propres. De la même manière que les neutrons composent l'atome d'Uranium U-238, les octets qui composent le caractère smiley U-263A sont un détail de son implémentation.

Il faut donc bien distinguer le mot « caractère » du mot « octet ». C'est pourquoi on peut le préciser à l'interpréteur avec la directive use bytes. (Voir le chapitre 31, Modules de pragmas). De toute manière, Perl saura par lui-même faire le codage sur 8 bits quand il le faudra.

Maintenant, passons dans la prochaine dimension.

Perl est un langage informel, ce qui ne veut pas dire qu'il n'a pas de forme, mais plutôt dans le sens usuel du terme, c'est-à-dire un langage qu'on peut écrire avec des espaces, tabulations et caractères de nouvelle ligne partout où vous voulez sauf dans les unités syntaxiques.

Par définition, un symbole ne contient pas d'espace. Un symbole est une unité syntaxique avec un sens pour l'interpréteur, comme pour un mot dans une phrase, mais qui peut contenir d'autres caractères que des lettres tant que cette unité n'est pas rompue. (Ce sont de vraies molécules qui peuvent utiliser toutes sortes d'atomes. Par exemple, les nombres et les opérateurs mathématiques sont des symboles. Un identificateur est un symbole qui débute par une lettre ou un souligné et qui ne contient que des lettres, chiffres ou soulignés. Un symbole ne peut contenir d'espace puisque le caractère espace couperait le symbole en deux nouveaux symboles, tout comme un caractère espace, en français couperait un mot en deux nouveaux mots.(36)

Bien que le caractère espace soit nécessaire entre deux symboles, les espaces ne sont obligatoires qu'entre deux symboles qui, sinon, seraient pris pour un seul. À cet effet, tous les espaces sont équivalents. Un commentaire est compté comme un espace. Les sauts de ligne ne sont différents des espaces qu'entre des délimiteurs, dans certains formats et pour des formes orientées ligne de protection. Plus précisément le caractère de saut de ligne ne délimite pas une instruction comme en FORTRAN ou en Python. Les instructions en Perl se terminent par le caractère « ; » comme en C.

Les caractères d'espace Unicode sont autorisés dans un programme Perl Unicode moyennant certaines précautions. Si vous utilisez les caractères spéciaux Unicode séparateurs de paragraphe et de ligne, d'une manière différente que ne le fait votre éditeur de texte, les messages d'erreur seront plus difficile à interpréter. C'est mieux d'utiliser les caractères de saut de ligne classiques.

Les symboles sont détectés d'une manière large ; l'interpréteur Perl lit le symbole le plus long possible lors de la lecture du code. Si vous voulez qu'il distingue deux symboles, il suffit d'insérer un espace blanc entre eux. (La tendance est d'insérer plusieurs espaces pour rendre le code plus lisible.)

Un commentaire commence par le caractère # et s'étend jusqu'à la fin de la ligne. Un commentaire équivaut à un espace et joue le rôle de séparateur. Perl n'interprète pas une ligne placée en commentaire.(37)

Si une ligne, et c'est une autre originalité lexicale, commence par = à un endroit où une instruction serait légale, Perl ignore tout de cette ligne jusqu'à la prochaine contenant =cut. Le texte ignoré est supposé être du POD, ou Plain Old Documentation (des programmes Perl permettent de convertir ces commentaires au format des pages de manuel, ou en documents , HTML et bientôt XML). D'une manière complémentaire, l'analyseur lexical extrait le code Perl d'un module et ignore les balises pod, ce qui permet de conserver la documentation à l'intérieur des modules. Voir le chapitre 26, POD, pour les détails sur pod et la documentation multiligne.

Mais seul le premier # est nécessaire, les autres ne sont que de la décoration, bien que la plupart des codeurs l'utilisent pour faire des effets visuels comme avec le langage C ou ils font une utilisation abondante du caractère *.

En Perl, comme en chimie ou en linguistique, on construit des structures de plus en complexes à partir d'éléments simples. Par exemple, une instruction est une séquence de symboles sur le mode impératif. On peut combiner une série d'instructions pour former un bloc délimité par des accolades. Les blocs peuvent eux-mêmes constituer d'autres blocs. Certains blocs fonctionnels tels que les sous-programmes peuvent être combinés en modules eux-mêmes combinés en programmes, nous verrons tout ceci dans les prochains chapitres. Mais créons encore des symboles avec nos caractères.

Avant de construire des types plus complexes, nous devons introduire quelques abstractions, plus précisément trois types de données.

Chaque langage dispose de ses propres types de données et à la différence des autres, Perl en possède peu ce qui réduit les confusions possibles. Prenons par exemple le langage C qui dispose des types suivants : char, short, int, long, long long, bool, wchar_t, size_t, off_t, regex_t, uid_t, u_longlong_t, pthread_key_t, fp_exception_field_type, et ainsi de suite. Ce sont juste les types entiers! Il y a ensuite les nombres flottants, les pointeurs et les chaînes.

Tous ces types compliqués n'en font qu'un en Perl : le scalaire. (Les types simples de données sont suffisants pour les besoins usuels, et il est possible de créer ses propres types en utilisant la programmation objet en Perl, voir le chapitre 12, Objets.) Les trois types de base en Perl sont : les scalaires, les tableaux de scalaires et les hachages de scalaires (connus aussi sous le nom de tableaux associatifs). On peut aussi les appeler structures de données.

Les scalaires constituent le type fondamental à partir duquel les structures plus complexes peuvent être construites. Un scalaire peut contenir une seule valeur simple, typiquement une chaîne ou un nombre. Les éléments de ce type simple peuvent être combinés à l'intérieur des deux autres types composés. Un tableau est une liste ordonnée de scalaires accessibles par un indice numérique (les indices démarrent à zéro). Contrairement aux autres langages, Perl traite les indices négatifs en comptant à partir de la fin du type indexé — aussi bien des chaînes que des listes. Un hachage est un ensemble non ordonné de paires clef/valeur accessibles par une clef de type chaîne utilisée pour accéder à la valeur scalaire associée. Les variables ont toujours l'un de ces trois types. (À part les variables, Perl comprend des bidules plus ou moins confidentiels tels que des handles de fichiers et de répertoires, des sous-programmes, des typeglobs, des formats et des tables de symboles.)

Laissons la théorie et passons à la pratique du langage pour en voir les possibilités. Nous allons donc écrire du code et pour cela vous présenter les termes constituant les expressions en Perl régies par des règles syntaxiques. Nous utilisons la terminologie terme quand nous parlerons des unités syntaxiques, un peu comme dans les équations mathématiques.

La fonction des termes en Perl est de fournir des valeurs pour des opérateurs tels l'addition ou la multiplication. Mais à la différence d'une équation, Perl interprète l'expression dans une action logique de la machine. Une des actions les plus courantes est la sauvegarde d'une valeur en mémoire :

$x = $y;

C'est un exemple de l'opérateur d'affectation (non pas l'opérateur de test d'égalité des valeurs numériques, ce qui s'écrit == en Perl). L'affectation prend la valeur de $y et la place dans la variable $x. Notez que le terme $x n'est pas utilisé pour sa valeur, mais pour sa fonction de mémorisation. (L'ancienne valeur de $x disparaît avec l'affectation.) Nous disons que $x est une lvalue, parce qu'elle est cible d'une affectation à gauche d'une expression. Et nous disons que $y est une rvalue car à droite dans ce type d'expression.

Il y a un troisième type de valeur appelée temporaire qu'il est nécessaire de comprendre. Considérons l'expression simple suivante :

$x=$y + 1;

Perl prend la rvalue $y et lui ajoute la rvalue 1, ce qui produit une valeur temporaire qui est ensuite affectée à la lvalue $x. Ces valeurs temporaires sont placées dans une structure interne appelée pile.(38)

Les termes d'une expression empilent des valeurs, alors que ses opérateurs (dont nous parlerons dans le prochain chapitre) dépilent des valeurs et peuvent aussi empiler des résultats pour le prochain opérateur. Dans la pile, une expression produit autant de valeurs qu'elle en consomme. Nous reviendrons sur les valeurs temporaires.

Certains termes sont exclusivement des rvalues comme 1, certains autres peuvent jouer les deux rôles, comme la variable de l'exemple précédent nous l'a montré. C'est ce que nous allons voir dans la prochaine section.

Il y existe trois types de variables correspondant aux trois types abstraits mentionnés plus haut. Chacun d'eux est préfixé par un caractère spécial.(39) Les variables scalaires sont toujours définies avec un caractère $ initial, même si elles font référence à des scalaires à l'intérieur d'un tableau ou d'un hachage. Ce caractère fonctionne un peu comme l'article défini singulier (le ou la). Nous avons donc :

Noter que vous pouvez utiliser le même nom pour $jours, @jours, et %jours, Perl ne les confondra pas.

Il existe d'autres caractères spéciaux qui s'appliquent sur les scalaires et sont utilisés dans des cas précis. Ils ressemblent à ceci :

Les tableaux ou les tranches de tableaux (ainsi que les tranches de hachage) débutent par le caractère @, qui fonctionne un peu comme l'article défini pluriel (les) :

équivaut à ($jours[0], $jours[1],... $jours[n]). équivaut à ($jours[3], $jours[4], $jours[5]). équivaut à @jours[3,4,5]. équivaut à ($jours{'jan'}, $jours{'fev'}).

Les hachages débutent par % :

Chacun de ces neuf exemples peut servir de lvalue, c'est-à-dire qu'ils spécifient une adresse à laquelle on peut, en autres choses, loger une valeur. Avec les tableaux, les hachages et les tranches de tableaux ou de hachages, la lvalue fournit un moyen simple d'affecter plusieurs valeurs d'un seul coup :

@days =1.. 7;

Nous avons parlé de variables pour mémoriser des valeurs, mais il faut aussi mémoriser les noms et définitions de ces variables. En théorie, cela s'appelle des espaces de nommage. Perl dispose de deux sortes d'espaces de nommages : la table des symboles et les portées lexicales.(40) Il peut y avoir un nombre quelconque de tables et de portées lexicales et l'intersection des deux ensembles est nulle, pour chaque instance de l'interpréteur Perl. Nous détaillerons chacun de ces types tout au long de cet ouvrage. Disons simplement pour le moment que les tables de symboles sont des hachages à portée globale qui contiennent la table des symboles des variables globales (y compris les hachages des autres tables de symboles). A contrario, les portées lexicales sont des espaces anonymes non inclus dans une table, mais liés à un bloc de code du programme courant. Ils contiennent des variables accessibles uniquement dans le bloc en cours. (C'est pourquoi on utilise le terme portée.) Le mot lexical veut dire relatif au bloc de texte courant (ce qui n'a rien à voir avec ce qu'un lexicographe entend par là. Ne vous fâchez pas.).

Dans chaque espace de nommage, global ou lexical, chaque type de variable dispose de son propre sous-espace de nommage déterminé par le caractère spécial affecté au type. Il est possible, sans risque de conflit, d'utiliser le même nom pour une variable scalaire, un tableau ou un hachage (ou encore, pour un handle de fichier, un nom de sous-programme, un label ou votre lama familier). Cela signifie que $machin et @machin sont deux variables différentes. Cela veut aussi dire que $machin[1] est un élément de @machin et non une partie de $machin. Bizarre, vous avez dit bizarre ? Mais c'est normal, bizarrement.

Pour l'appel d'un sous-programme le caractère & est facultatif. Généralement un nom de sous-programme n'est pas une lvalue, quoique dans les versions récentes de Perl un sous-programme peut s'évaluer à une lvalue de telle sorte que l'on peut lui affecter une valeur en retour.

Parfois on veut accéder aux variables d'un symbole donné, « sym » par exemple. Il suffit d'utiliser le caractère spécial * où l'astérisque indique tout type de variable (scalaire, tableau, hachage). On les appelle typeglobs ; ils ont plusieurs fonctions. Ils peuvent être utilisés comme lvalues. L'importation des modules se fait par l'affectation des typeglobs. Nous reviendrons sur ce thème plus tard.

Perl, comme tout langage informatique, dispose d'une liste de mots réservés qu'il reconnaît comme termes spéciaux. Cependant, les noms de variables commençant par un caractère spécial, il n'y a pas de confusion possible avec les premiers. D'autres types de noms ne commencent pas par ces caractères : les descripteurs de fichiers et les étiquettes. Avec ceux-ci attention à ne pas entrer en conflit avec des mots réservés. Nous vous recommandons pour ces types, d'utiliser des majuscules pour leurs noms. Par exemple, si vous écrivez open(LOG, logfile) plutôt que le regrettable open(log, "logfile"). Perl comprendra que vous ne parlez pas de la fonction log et des logarithmes,(41) et prévient les futurs conflits avec les nouvelles versions de Perl. Le nom des modules utilisateurs commence avec une majuscule alors que les modules pragmas prédéfinis sont écrits en minuscules. Quand nous aborderons la programmation orientée objet, vous verrez que les noms de classes sont en capitales pour la même raison.

Comme vous pouvez le déduire du précédent paragraphe, la casse est importante dans les identificateurs — TRUC, Truc, et truc sont trois noms différents en Perl. Un identificateur commence avec une lettre ou un souligné, il peut contenir des lettres et des chiffres, y compris les caractères Unicode, et peut avoir une longueur comprise entre 1 et 251 inclus. Les idéogrammes Unicode sont des lettres, mais nous vous déconseillons de les utiliser si vous ne savez pas les lire. Voir le chapitre 15.

Les noms qui suivent ces caractères spéciaux ne sont pas nécessairement des identificateurs. Ils peuvent commencer par un chiffre auquel cas l'identificateur ne peut contenir que des chiffres comme dans $123. Les noms qui commencent par tout autre caractère qu'une lettre, un chiffre ou souligné (comme $? ou $$), sont limités à ce caractère et sont prédéfinis en Perl. Par exemple $$ est l'ID du processus courant et $? est l'indicateur d'état retourné par le dernier processus fils créé.

Dans la version 5.6 de Perl est implémentée une syntaxe extensible pour les noms de variable interne. Toute variable de la forme ${^NAME} est une variable spéciale réservée par Perl. Tous ces noms spéciaux sont dans la table principale de symboles. Voir le chapitre 28, Noms spéciaux, pour les exemples.

On pourrait penser que noms et identificateurs désignent la même chose, mais lorsqu'on parle de nom, c'est du nom absolu qu'il s'agit, c'est-à-dire celui qui indique à quelle table de symboles il appartient. De tels noms sont formés par une série d'identificateurs séparés par le symbole :: :

$Doc::Aide::Perl::Classe::chameau

Ce qui fonctionne comme un nom absolu de fichier :

/Doc/Aide/Perl/Classe/chameau

En Perl, ce chemin absolu indique les tables de symboles imbriquées, et le dernier identificateur est le nom de la variable elle-même, contenu dans la dernière table imbriquée. Par exemple, pour la variable de l'exemple précédent, la table de symboles se nomme Doc::Aide::Perl::Classe, et le nom de la variable dans cette table est $chameau. (la valeur de cette variable est bien entendu « beige ».)

Une table de symboles en Perl se nomme aussi un paquetage. Donc ces variables sont aussi appelées variables de paquetage. Les variables de paquetage sont dites privées relativement à leur paquetage, mais sont globales dans le sens où les paquetages sont eux-mêmes globaux, c'est-à-dire qu'il suffit de nommer le paquetage pour y accéder, ce qui est difficile à faire par inadvertance. Par exemple, un programme qui référence $Doc::categorie demande la variable $categorie dans le paquetage Doc::, qui n'a rien à voir avec la variable $Livre::categorie. Voir le chapitre 10, Paquetages.

Les variables attachées à une portée lexicale ne sont pas contenues dans un paquetage, et ne contiennent pas la séquence ::. (Les variables à portée lexicale sont déclarées avec my.)

2-5-a. Recherche des noms▲

Qu'il soit référencé directement ou indirectement, dans une variable, un tableau ou bien une variable temporaire, un scalaire contient toujours une valeur simple qui peut être un nombre, une chaîne ou une référence à une autre donnée. Il peut aussi n'avoir aucune valeur auquel cas il est dit indéfini. Les scalaires sont sans type, même s'ils peuvent référencer toutes sortes de données : il n'est pas nécessaire de les déclarer.(43)

Perl mémorise les chaînes comme des séquences de caractères sans contrainte de longueur ni de contenu. Nul besoin de déclarer une taille à l'avance et tout caractère peut y être inclus, y compris le caractère nul. Les nombres sont représentés sous forme d'entiers signés si possible, ou bien sous forme de nombres à virgule flottante en double précision dans le format natif de la machine. Les valeurs flottantes ne sont pas infiniment précises, c'est pourquoi certaines comparaisons de la forme (10/3 == 1/3*10) échouent mystérieusement.

Perl convertit les scalaires en différents sous-types suivant les besoins ; le numérique peut être traité comme du caractère et inversement, Perl faisant Ce Qu'il Faut. Pour convertir du caractère en numérique, Perl utilise la fonction C atof(3). Pour passer du numérique à une chaîne de caractères, il fait l'équivalent de sprintf(3) avec le format "%.14g" sur la plupart des machines. La conversion d'une chaîne non numérique comme truc convertit le literal à la valeur 0 ; s'ils sont actifs, les avertissements sont affichés sinon rien. Voir le chapitre 5, pour des exemples permettant d'identifier le contenu d'une chaîne.

Alors que les chaînes de caractères et les numériques sont interchangeables dans à peu près tous les cas, les références sont d'un genre différent. Elles sont fortement typées, ce sont des pointeurs non convertibles (transtypables) comprenant des compteurs de références et des invocations de destructeurs internes. Ils sont utilisables pour créer des types de données complexes, incluant vos propres objets. Ceci dit, les références restent des scalaires, car ce qui importe n'est pas tant la complexité d'une structure que le fait de la considérer comme un simple scalaire.

Par non convertibles, nous voulons dire que l'on ne peut pas, par exemple, convertir une référence de tableau en une référence de hachage. Les références ne sont pas convertibles en un autre type pointeur. Cependant, en utilisant une référence en numérique ou en caractère, on obtient une valeur numérique ou une chaîne de caractères, ce qui permet de se souvenir du caractère unique d'une référence, même si le « référencement » de la valeur est perdu au cours de la copie depuis la vraie référence. On peut comparer différentes références ou tester si elles sont définies. Mais on ne peut en faire beaucoup plus puisqu'il n'existe pas de moyen de convertir du numérique ou du caractère en référence. En principe, si Perl n'oblige pas à faire de l'arithmétique de pointeurs — ou carrément l'interdit —, ce n'est pas un problème. Voir le chapitre 8 pour en connaître plus sur les références.

2-6-a. Littéraux numériques▲

$x = 12345;             # entier
$x = 12345.67;          # virgule flottante
$x = 6.02E23;           # notation scientifique
$x = 4_294_967_296;     # souligné pour la lisibilité
$x = 0377;              # octal
$x = 0xffff;            # hexadécimal
$x = 0b1100_0000;       # binaire

2-6-b. Chaînes littérales▲

$Prix = '$100';                  # non interpolé
print "Le prix est de $Prix.\n"; # interpolé

$jours{'fev'}

$jours{fev}

@jours{'Jan','Fev'}     # Ok.
@jours{"Jan","Fev"}     # Ok aussi.
@jours{ Jan,  Fev }     # erreur si la directive use strict est active

print "\n";             # Ok, imprime un saut de ligne.
print \n ;              # MAUVAIS, pas de contexte d'interpolation.

2-6-c. Choisissez vos délimiteurs▲

$simple = q!Je dis "Tu dis, 'Elle l'a dit.'"!;
$double = qq(On ne peut pas avoir une "bonne" $variable?);
$bout_de_code = q {
    if ($condition) {
        print "Pris!";
    }
};

tr [a-z]
   [A-Z];

s {foo}   # Remplacer foo
  {bar};  #    par bar.

tr [a-f]  # Translittération de minuscule hexa  
   [A-F]; #       vers majuscule hexa

2-6-d. Ou n'en mettez pas du tout▲

@jours = (Lun,Mar,Mer,Jeu,Ven);
print STDOUT Salut, ' ', monde, "\n";

@jours = qw(Lun Mar Mer Jeu Ven);
print STDOUT "Salut, tout le monde\n";

use strict 'subs';

no strict 'subs';

"${verb}able"
$jours{Fév}

2-6-e. Interpolation des tableaux▲

$temp = join($",@ARGV);
print $temp;

print "@ARGV";

2-6-f. Documents « ici même »▲

print <<EOF;        # même exemple que précédemment
Le prix est $Prix.
EOF

print <<"EOF";      # même exemple qu'au-dessus avec des apostrophes
                    # doubles explicites
Le prix est $Prix.
EOF

print <<'EOF';      # avec des apostrophes simples
Tout est possible (par exemple le passage d'un chameau par le chas
d'une aiguille), c'est vrai. Mais imaginez l'état du chameau,
déformé en un long fil sanglant de la tête aux pieds.
--C.S. Lewis
EOF

print << x 10;      # affiche la ligne suivante 10 fois
Les chameaux débarquent! Ho u rra! Hourra!

print <<"" x 10;    # La même chose, en mieux
Les chameaux débarquent! Ho u rra! Hourra!

print <<`EOC`;  # exécute les commandes
echo comment vas-tu
echo yau de poêle?
EOC

print <<"dromadaire", <<"camelide";     # on peut les empiler
Je dis bactriane.
dromadaire
Elle dit lama.
camelide

print <<ABC
179231
ABC
+ 20;  # affiche 179251

($quote = <<'QUOTE') =~ s/^\s+//gm;
    The Road goes ever on and on,
    down from the door where it began.
QUOTE

@sauces = <<fin_lignes =~ m/(\S.*\S)/g;
    tomate normale
    tomate épicée
    chili vert
    pesto
    vin blanc
fin_lignes

2-6-g. Litéral V-chaîne▲

$crlf = v13.10;    # valeur ASCII: retour chariot, saut de ligne

"\x{1}\x{14}\x{12c}\x{fa0}"
pack("U*", 1, 20, 300, 4000)
chr(1) . chr(20) . chr(300) . chr(4000)

print v9786;              # affiche le caractère UTF-8 SMILEY, "\x{263a}"
print v102.111.111;       # affiche "foo"
print 102.111.111;        # idem

use 5.6.0;                # nécessite au moins cette version de Perl

$ipaddr = 204.148.40.9;   # l'addresse IP de oreilly.com

2-6-h. Autres symboles littéraux▲

Jusqu'à présent, nous avons vu un certain nombre de termes pouvant produire des valeurs scalaires. Avant d'en voir davantage, nous devons aborder la notion de contexte.

2-7-a. Contexte scalaire et contexte de liste▲

$x        = fonction();  # contexte scalaire
$x[1]     = fonction();  # contexte scalaire
$x{"ray"} = fonction();  # contexte scalaire

@x        = fonction();  # contexte de liste
@x[1]     = fonction();  # id
@x{"ray"} = fonction();  # id
%x        = fonction();  # id

($x,$y,$z) = fonction(); # contexte de liste
($x)       = fonction(); # id

my $x     = fonction();  # contexte scalaire
my @x     = fonction();  # contexte de liste
my %x     = fonction();  # id
my ($x)   = fonction();  # id

2-7-b. Contexte booléen▲

unlink @liste_fichiers;  # détruit chaque fichier de la liste.

while (@liste_fichiers) {
    my $fichier = shift @liste_fichiers;
    unlink $fichier or warn "Ne peut pas supprimer $fichier: $!\n";
}

2-7-c. Contexte vide▲

"Camel Lot";

Useless use of a constant in void context in monprog line 123;

2-7-d. Contexte interpolatif▲

Maintenant que nous avons parlé des contextes, nous pouvons parler des listes de valeurs et de leur comportement dans les différents contextes. Nous avons déjà vu les listes de littéraux, définies en séparant chaque valeur par une virgule (et en encadrant la liste par une paire de parenthèses). Comme il n'est pas gênant (presque jamais) d'ajouter des parenthèses supplémentaires, la forme syntaxique d'une liste s'écrit :

(LISTE)

Nous venons de voir que la forme LISTE indique un terme qui retourne une liste à son argument, mais une liste littérale simple est l'exception à cette règle en ce qu'elle fournit un contexte de liste uniquement quand la liste elle-même est dans un contexte de liste. La valeur d'une liste litérale dans un contexte de liste est simplement les valeurs de chaque élément séparées par une virgule dans l'ordre spécifié. Comme un terme dans une expression, une liste litérale empile simplement des valeurs temporaires sur la pile Perl, elles seront utilisées ensuite par l'opérateur qui attend cette liste.

Dans un contexte scalaire, la valeur d'une liste est la valeur de son dernier élément, comme avec l'opérateur virgule du C qui ignore toujours la valeur à gauche et renvoie celle de droite (en faisant référence à ce que nous disions plus haut, la partie à gauche de la virgule fournit un contexte vide). L'opérateur virgule étant associatif à gauche, une liste de valeurs séparées par des virgules fournit toujours le dernier élément, car la virgule oublie chaque valeur précédente. Par exemple :

@truc = ("un", "deux", "trois");

affecte toute la liste de valeurs au tableau @truc, mais :

$truc = ("un", "deux", "trois");

n'affecte que la valeur « trois » à la variable $truc. Comme pour le tableau @liste_fichiers, l'opérateur virgule sait s'il est dans un contexte scalaire ou de liste et adapte son comportement en conséquence.

C'est important de souligner qu'une liste est différente d'un tableau. Une variable tableau connaît aussi son contexte, et dans un contexte de liste retourne la liste de ses valeurs internes comme une liste littérale. Mais dans un contexte scalaire elle retourne simplement sa longueur. Le code suivant affecte la valeur 3 à la variable $truc :

@truc = ("un", "deux", "trois");
$truc = @truc;

Si vous pensiez obtenir la valeur « trois », vous avez généralisé un peu vite, car en fait Perl a détecté le contexte scalaire et n'a empilé que la longueur du tableau. Aucun terme ou opérateur n'empilera des valeurs de liste dans un contexte scalaire. Il empilera une valeur scalaire, qui ne sera certainement pas la dernière valeur de la liste qu'il retournerait dans un contexte de liste, valeur scalaire qui est ici la longueur du tableau. Il faut bien comprendre cet exemple (sinon, relisez le paragraphe, car c'est important).

Retournons aux vraies LISTE, celles qui induisent un contexte de liste. Jusqu'à présent nous avons soutenu que le contexte LISTE ne contient que des littéraux. Mais en fait, toute expression qui retourne une valeur peut être utilisée à l'intérieur d'une liste. Les valeurs ainsi utilisées peuvent être des valeurs scalaires ou des listes de valeurs. Le contexte LISTE fait automatiquement une interpolation des sous-listes. C'est pourquoi, lorsqu'un contexte LISTE est évalué, chaque élément de la liste est évalué dans ce contexte et la valeur de la liste résultante est interpolée dans LISTE comme si chaque élément individuel était un membre de LISTE. Les tableaux perdent ainsi leur identité dans LISTE. La liste :

(@machin,@chose,&sousProgramme)

contient tous les éléments de @machin, suivis de tous les éléments de @chose, suivis de tous les éléments renvoyés par le sous-programme sousProgramme lorsqu'il est appelé dans un contexte de liste. Notez que si l'un quelconque des éléments est nul, son interpolation ne compte pas. La liste nulle est représentée par (). Son interpolation dans une liste n'a pas d'effet. Ainsi ((),(),()) est équivalent à (). De même, l'interpolation d'un tableau sans élément donne, à ce stade, la même chose que s'il n'avait pas été interpolé.

Une conséquence est que l'on peut mettre une virgule optionnelle à la fin de toute liste. Ceci facilitera ultérieurement les ajouts d'éléments.

@nombres = (
    1,
    2,
    3,
);

Le mot qw, que nous avons mentionné plus tôt, permet aussi d'entrer une liste littérale. Il construit quelque chose d'équivalent à une chaîne entre apostrophes éclatée sur plusieurs lignes. Par exemple :

@machin = qw(
    pomme       banane      carambole
    orange      goyave      kumquat
    mandarine   nectarine   pêche
    poire       persimmon   prune
);

Remarquez que ces parenthèses ne sont pas ordinaires et fonctionnent comme des apostrophes. On aurait pu aussi mettre des signes inférieur-supérieur, des accolades ou des slashs (mais les parenthèses c'est joli).

Une liste de valeurs peut aussi être indicée comme un tableau standard. Vous devez alors mettre la liste entre parenthèses (des vraies) pour éviter toute ambiguïté. Si cela sert souvent pour obtenir une valeur du tableau, c'est aussi une tranche de la liste et la forme syntaxique s'écrit :

(LISTE)[LISTE]

Exemples :

# Stat renvoie une valeur liste.
$modification_time = (stat($fichier))[8];

# ERREUR DE SYNTAXE ICI.
$modification_time = stat($fichier)[8]; # OUPS, PAS DE PARENTHESES

# Trouver un chiffre hexa.
$chiffrehexa = ('a','b','c','d','e','f')[$chiffre-10];

# Un "opérateur virgule inverse".
return (pop(@machin),pop(@machin))[0];

# Affectation de plusieurs valeurs à l'aide d'une tranche.
($jour, $mois, $annee) = (localtime)[3,4,5];

2-8-a. Affectation de liste▲

($a, $b, $c) = (1, 2, 3);
($map{rouge}, $map{vert}, $map{bleu}) = (0xff0000, 0x00ff00, 0x0000ff);

($dev, $ino, undef, undef, $uid, $gid) = stat($fichier);

($a, $b, @reste) = split;
my ($a, $b, %reste) = @arg_list;

() = fonction_bidon();

$x = ( ($machin,$truc) = (7,7,7) ); # $x contient 3, pas 2
$x = ( ($machin,$truc) = f() );     # $x contient le nombre d'éléments de f()
$x = ( () = f() );                  # idem

while (($login, $password) = getpwent) {
    if (crypt($login, $password) eq $password) {
        print "$login a un mot de passe non sécurisé!\n";
    }
}

2-8-b. Longueur d'un tableau▲

@jours + 0;     # force implicitement @jours dans un contexte scalaire
scalar(@jours)  # force explicitement @jours dans un contexte scalaire

@nimportequoi = ();
$#nimportequoi = -1;

scalar(@nimportequoi) == $#nimportequoi + 1;

Comme nous l'avons déjà dit, un hachage n'est qu'un type spécial de tableau dans lequel on retrouve les valeurs par une chaîne-clef au lieu d'un indice numérique. En fait, on définit des associations entre les clefs et les valeurs, et c'est pourquoi les hachages sont souvent appelés tableaux associatifs par les personnes assez courageuses pour taper sur un clavier.

Il n'existe pas vraiment de syntaxe particulière aux hachages en Perl, mais si une liste ordinaire est affectée à un hachage, chaque paire de valeurs de la liste sera prise comme une association clef/valeur.

%map = ('rouge',0xff000,'vert',0x00ff00,'bleu',0x0000ff);

Ce qui a le même effet que :

%map = ();               # d'abord initialiser le hachage
$map{rouge} = 0xff0000;
$map{vert}  = 0x00ff00;
$map{bleu}  = 0x0000ff;

Il est souvent plus lisible d'utiliser l'opérateur => entre la clef et sa valeur. L'opérateur => est synonyme de la virgule, mais il est plus clair visuellement et permet aussi une séparation d' identifiant à gauche (comme les identifiants entre accolades ci-dessus) ; l'initialisation des variables hachages devient plus simple :

%map = (
    rouge => 0xff0000,
    vert => 0x00fff0,
    bleu => 0x0000ff,
);

ou pour initialiser des références banalisées de hachage utilisées comme des enregistrements :

$rec = {
    NOM => 'John Smith'
    GRADE => 'Captain'
    MATRICULE => '951413',
};

ou pour utiliser des appels complexes de fonctions par un nom :

$field = $query->radio_group(
                    NOM => 'group_name',
                    VALEURS => ['eenie','meenie','minie'],
                    DEFAUT => 'meenie',
                    SAUTDELIGNE => 'true',
                    LABELS => %labels,
                );

Mais n'allons pas trop vite. Revenons à nos hachages.

Une variable hachage (%hachage) peut être utilisée dans un contexte de liste, toutes ses paires clef/valeurs étant interpolées dans la liste. Mais ce n'est pas parce que le hachage a été initialisé dans un certain ordre que les valeurs sont retournées dans le même. Les hachages sont implémentés au niveau interne en utilisant des tables de hachage pour une recherche rapide, ce qui signifie que l'ordre dans lequel les données sont stockées dépend du type de fonction de hachage utilisée pour déterminer la place de la paire clef/valeur. Ainsi, les entrées sont apparemment retournées dans un ordre quelconque (au niveau d'une paire clef/valeur, les deux éléments sont bien sûr rendus dans le bon ordre). Pour des exemples de réordonnancement en sortie, voir la fonction keys au chapitre 29.

Si un hachage est évalué dans un contexte scalaire, une valeur vraie est renvoyée si et seulement si le hachage contient des paires clef/valeur. (S'il existe plusieurs paires, la valeur renvoyée est une chaîne contenant le nombre de cellules utilisées (buckets) et le nombre de cellules allouées, séparés par un slash. Ceci n'est utile que pour savoir si l'algorithme résident de Perl traite correctement ou non l'ensemble de données. Par exemple, on entre 10 000 éléments dans un hachage, mais l'évaluation de %HASH dans un contexte scalaire révèle « 1/8 », cela signifie que seulement une des 8 cellules a été touchée, et qu'elle contient probablement les 10 000 éléments. Ce n'est pas censé se produire.

Pour trouver le nombre de clefs dans un hachage, utilisez la fonction keys dans un contexte scalaire : scalar(keys(%HASH)).

Il est possible d'émuler un tableau multidimensionnel en spécifiant plus d'une clef dans les accolades séparées par une virgule. Les clefs listées sont concaténées ensemble séparées par le caractère $; ($SUBSCRIPT_SEPARATOR) qui a la valeur chr(28) par défaut. La clef résultante devient une clef du hachage. Ces deux lignes font la même chose :

$habitants{ $pays, $département } = $résultat_recensement;
$habitants{ join $; =>; $pays, $département } = $résultat_recensement;

Cette fonctionnalité fut à l'origine implémentée pour le traducteur a2p (awk vers perl). Aujourd'hui, vous utiliseriez plus justement un tableau multidimensionnel comme il est décrit au chapitre 9, Structures de données. Un usage encore pratique de cet ancien style est la liaison des hachages aux fichiers DBM (voir DB_File au chapitre 32, Modules standards), qui n'implémentent pas les clefs multidimensionnelles.

Ne confondez pas l'émulation multidimensionnelle des hachages avec les tranches de tableaux. L'un est une valeur scalaire, l'autre représente une liste :

$hachage{ $x, $y, $z }      # une valeur simple
@hachage{ $x, $y, $z }      # une tranche de trois valeurs

Perl utilise un type spécial appelé typeglob qui contient la table des types Perl pour ce symbole. (La table des symboles *foo contient les valeurs de $foo, @foo, %foo, &foo et d'autres interprétations de foo.) Le préfixe de typage d'un typeglob est *, car il représente tous les types.

Les typeglobs (ou leurs références) sont toujours utilisés pour passer ou stocker des handles de fichier. Pour sauvegarder un handle de fichier il faut taper :

$fh = *STDOUT;

ou comme une vraie référence, de cette manière :

$fh = \*STDOUT;

C'est aussi le moyen de créer un handle de fichier local. Par exemple :

sub newopen {
    my $path = shift;
    local *FH;      # et non my ou our!
    open (FH, $path) || return undef;
    return *FH;     # et non \*FH!
}
$fh = newopen('/etc./passwd');

Voir la fonction open pour générer d'autres handles de fichiers.

Cependant, la principale utilisation des typeglobs est actuellement de servir d'alias entre deux entrées symboliques. C'est comme un surnom. Si on écrit

*machin = $truc; tout ce qui s'appelle « machin », est synonyme de tout ce qui s'appelle « truc ». L'alias peut porter sur un seul type des variables du nom en affectant une référence :

*machin = $truc;

$machin devient alias de $truc, mais @machin n'est pas synonyme de @truc, ni %machin de %truc. Tout ceci ne concerne que les variables globales, c'est-à-dire définies dans un paquetage ; les variables lexicales ne peuvent être accédées à travers la table des symboles. Le mécanisme d'import/export est entièrement basé sur ce principe, l'alias ne présuppose en effet aucune appartenance à un module spécifique. Cette instruction :

local *Ici::bleu = \$Ailleurs::vert;

fait de $Ici::bleu un alias pour $Ailleurs::vert, mais ne fait pas de @Ici::bleu un alias pour @Ailleurs::vert, ni %Ici::bleu un alias pour %Ailleurs;::vert. Heureusement, toutes ces manipulations compliquées de typeglobs sont transparentes la plupart du temps. Voir le chapitre 8, et Tables de symboles au chapitre 10 et le chapitre 11, Modules, pour un développement sur ces sujets.

Nous allons maintenant présenter plusieurs opérateurs d'entrée qui sont analysés comme des termes. En fait, on les appelle parfois des pseudo-littéraux, car ils agissent, dans bien des cas, comme des chaînes protégées (les opérateurs de sortie comme print fonctionnent comme des opérateurs de liste et sont traités au chapitre 29.)

2-11-a. Opérateur d'exécution de commande (Backtick)▲

$info = `finger $user`;

$perl_info = qx(ps $$);         # Variable $$ de Perl
$shell_info = qx'ps $$';        # Variable $$ du shell

2-11-b. Opérateur de lecture de ligne (Angle)▲

while (defined($_ = <STDIN>)) { print $_; }     # méthode longue
while ($_ = <STDIN>) { print; }                 # utilise $_ explicitement
while (<STDIN>) { print; }                      # méthode courte
for (;<STDIN>;) { print; }                      # boucle while déguisée
print $_ while defined($_ = <STDIN>);           # instruction modifiée longue
print while $_ = <STDIN>;                       # utilise $_
print while <STDIN>;                            # instruction modifiée courte

while (<FH1> && <FH2>) {...}            # mauvais : perd les deux entrées
if (<STDIN>) { print; }                 # mauvais, affiche l'ancienne
                                        # valeur de $_
if ($_ = <STDIN>) { print; }            # ne teste pas si $_ est défini
if (defined($_ = <STDIN>)) { print; }   # meilleur

while (local $_ = <STDIN>) { print; }   # utilise local $_

while (my $ligne = <STDIN>) { print $ligne; } # variable privée

$une_ligne = <MYFILE>;      # Donne la première ligne.
@toutes_lignes = <MYFILE>;  # Donne le reste des lignes.

while (<>) {
    ...          # code pour chacune des lignes
}

while (@ARGV and $ARGV[0] =~ /^-/) {
    $_=shift;
    last if /^--$/;
    if (/^-D(.*)/) { $debug = $1 }
    if (/^-V/) { $verbose++ }
    ...          # autres alternatives
}
while (<>) {
    ...          # du code dans chaque ligne
}

# par défaut: le fichier README si aucun argument n'est donné
@ARGV = ("README") unless @ARGV;

while ($_ = $ARGV[0], /^-/) {
    shift;
    last if /^--$/;
    if (/^-D(.*)/) { $debug = $1 }
    if (/^-v/) { $verbose++ }
    ...         # autres options
}
while (<>) {
    ...         # code pour chacune des lignes
}

$fh = \*STDIN;
$ligne = <$fh>;

open($fh, "<donnees.txt>");
$line = "<$fh>";

2-11-c. Opérateur de globalisation des noms de fichier▲

my @fichiers = <*.xml>;

@fichiers = glob("*.xml");

while (glob "*.c") {
    chmod 0644, $_;
}

while (<*.c>) {
    chmod 0644, $_;
}

chmod 0644, <*.c>;

($fichier) = <blurch*>; # contexte de liste

$fichier = <blurch*>;   # contexte scalaire

@files = <$dir/*.[ch]>;         # à éviter
@files = glob("$dir/*.[ch]");   # appelle glob en tant que fonction
@files = glob $un_motif;        # appelle glob en tant qu'opérateur

En Perl, tout terme est de précédence maximale. Les termes comprennent les variables, les apostrophes et les opérateurs de type quote, la plupart des expressions entre parenthèses, crochets ou accolades, et toute fonction dont les arguments sont entre parenthèses. En fait, si on regarde les choses ainsi, il n'y a pas vraiment de fonctions, mais seulement des opérateurs de liste et des opérateurs unaires qui se comportent comme des fonctions parce que vous avez mis des parenthèses autour de leurs arguments. Tout cela n'empêche pas le chapitre 29 de s'appeler Fonctions.

Maintenant, lisez attentivement. Voici quelques règles très importantes qui simplifient grandement les choses, mais qui peuvent à l'occasion produire des résultats contraires à l'intuition pour les imprudents. Si un opérateur de liste (comme print) ou un opérateur unaire nommé (comme chdir) est suivi d'une parenthèse ouvrante comme token suivant (sans tenir compte des blancs), l'opérateur et ses arguments entre parenthèses ont la précédence la plus haute, comme s'il s'agissait d'un appel de fonction normal. La règle est la suivante : si cela ressemble à un appel de fonction, alors c'est un appel de fonction. Vous pouvez le faire ressembler à une non-fonction en préfixant les parenthèses avec un plus unaire, qui ne fait absolument rien sémantiquement parlant ; il ne convertit même pas les arguments en numérique.

Par exemple, puisque || a une précédence plus faible que chdir, nous aurons :

chdir $toto || die;         # (chdir $toto) || die
chdir($toto) || die;        # (chdir $toto) || die
chdir ($toto) || die;       # (chdir $toto) || die
chdir +($toto) || die;      # (chdir $toto) || die

mais comme * a une précédence plus grande que chdir, nous aurons :

chdir $toto * 20;           # chdir ($toto * 20)
chdir($toto) * 20;          # (chdir $toto) * 20
chdir ($toto) * 20;         # (chdir $toto) * 20
chdir +($toto) * 20;        # chdir ($toto * 20)

De même pour n'importe quel opérateur numérique qui est également un opérateur unaire nommé, comme rand :

rand 10 * 20;               # rand (10 * 20)
rand(10) * 20;              # (rand 10) * 20
rand (10) * 20;             # (rand 10) * 20
rand +(10) * 20;            # rand (10 * 20)

En l'absence de parenthèses, la précédence d'opérateurs de liste comme print, sort, ou chmod est soit très haute soit très basse selon que vous regardez à gauche ou à droite de l'opérateur (c'est le sens du « vers la gauche » dans le titre de cette section). Par exemple, dans :

@tab = (1, 3, sort 4, 2);
print @tab;         # imprime 1324

Les virgules à droite de sort sont évaluées avant le sort, mais les virgules à sa gauche sont évaluées après. En d'autres termes, un opérateur de liste tend à avaler tous les arguments qui le suivent, puis à se comporter comme un simple terme pour l'expression qui le précède. Il vous faut encore être prudent avec les parenthèses :

# Ces arguments sont évalués avant de faire le print :
print($toto, exit);     # Évidemment pas ce que vous voulez.
print $toto, exit;      # Ici non plus.

# Ces lignes font le print avant d'évaluer l'exit :
(print $toto), exit;    # C'est ce que vous voulez.
print($toto), exit;     # Ici aussi.
print ($toto), exit;    # Et même ceci

Le cas le plus simple pour se faire piéger, c'est quand vous utilisez des parenthèses pour grouper des arguments mathématiques, en oubliant que les parenthèses servent aussi à regrouper les arguments de fonctions :

print ($toto & 255) + 1, "\n";   # affiche ($toto & 255)

Cela ne fait probablement pas ce à quoi vous vous attendiez au premier coup d'œil. Heureusement, les erreurs de cette nature provoquent des avertissements comme « Useless use of addition in a void context » quand les avertissements sont activés (avec l'option de ligne de commande -w).

Les constructions do {} et eval {} sont aussi analysées comme des termes, de même que les appels de sous-programmes et de méthodes, les créateurs de tableaux et de hachages anonymes, [] et {}, et le créateur de sous-programme anonymes sub {}.

Tout comme en C et en C++, l'opérateur binaire -> est un opérateur infixe de déréférencement. Si à droite on trouve un indice de tableau entre [...], un indice de hachage entre {...} ou une liste d'arguments de sous-programme entre (...), alors la partie à gauche de la f lèche doit être respectivement une référence (symbolique ou en dur) de tableau, de hachage ou de sous-programme. Dans un contexte de lvalue (où l'on peut affecter une valeur), si la partie à gauche n'est pas une référence, elle doit être capable de contenir une référence, auquel cas cette référence sera autovivifiée pour vous. Pour en savoir plus à ce sujet (et pour quelques avertissements sur l'autovivification accidentelle), voir le chapitre 8, Références.

$aref->[42]               # un déréférencement de tableau
$href->{"corned beef"}    # un déréférencement de hachage
$sref->(1,2,3)            # un déréférencement de sous-programme

Sinon, c'est une sorte d'appel de méthode. La partie à droite doit être un nom de méthode (ou une simple variable scalaire contenant le nom de la méthode) et la partie à gauche doit s'évaluer soit comme un objet (une référence consacrée), soit comme un nom de classe (c'est-à-dire un nom de paquetage) :

$yogi = Ours->new("Yogi");    # un appel de méthode de classe
$yogi->pique($piquenique);    # un appel de méthode sur une instance

Le nom de méthode peut être qualifié avec un nom de paquetage pour indiquer dans quelle classe commencer à chercher la méthode, ou avec le nom de paquetage spécial SUPER::, pour indiquer que la recherche doit commencer dans la classe parente. Voir le chapitre 12, Objets.

Les opérateurs ++ et -- fonctionnent comme en C. C'est-à-dire que, placés avant une variable, ils l'incrémentent ou la décrémentent avant d'en renvoyer la valeur. Quand ils sont placés après, ils l'incrémentent ou la décrémentent après en avoir renvoyé la valeur. Par exemple, $A++(55) incrémente la valeur de la variable $A et en retourne la valeur avant de réaliser l'incrémentation. De même, --$b{(/(\w+)/)[0]} décrémente l'élément du hachage %b indexé par le premier « mot » de la variable de recherche par défaut ($_) et renvoie la valeur après la décrémentation.(56)

L'opérateur d'auto-incrémentation comporte en plus un peu de magie. Si vous incrémentez une variable qui est numérique, ou qui a été utilisée à un moment donné dans un contexte numérique, vous avez une incrémentation normale. Si au contraire la variable n'a été utilisée que dans des contextes de chaîne depuis qu'elle a été affectée, que sa valeur est non nulle et correspond au motif /^[a-zA-Z]*[0-9]*$/, l'incrémentation est faite sur la chaîne, en préservant chaque caractère dans son domaine, avec une retenue :

print ++($toto = '99');     # prints '100'
print ++($toto = 'a9');     # prints 'b0'
print ++($toto = 'Az');     # prints 'Ba'
print ++($toto = 'zz');     # prints 'aaa'

À l'heure où nous écrivons ces lignes, l'auto-incrémentation magique n'a pas été étendue aux lettres et chiffres Unicode, mais pourrait l'être dans le futur.

L'opérateur d'autodécrémentation n'est, lui, pas magique, et il n'est pas prévu que cela change.

L'opérateur ** binaire est l'opérateur d'exponentiation. Notez qu'il lie encore plus fortement que le moins unaire ; c'est pourquoi -2**4 vaut -(2**4), et non (-2)**4. L'opérateur est implémenté grâce à la fonction pow(3) de C, qui fonctionne en interne avec des nombres en virgule flottante. Les calculs sont faits grâce à des logarithmes, ce qui signifie qu'il fonctionne avec des puissances fractionnaires, mais que vous obtiendrez parfois des résultats moins précis qu'avec une simple multiplication.

La plupart des opérateurs portent simplement des noms (voir Opérateurs unaires nommés et de test de fichier plus loin dans ce chapitre), mais certains opérateurs sont jugés suffisamment importants pour mériter leur propre représentation symbolique spéciale. Ces opérateurs semblent tous avoir un rapport avec la négation. Plaignez-vous auprès des mathématiciens.

Le ! unaire réalise une négation logique, c'est-à-dire un « non ». Voyez not pour une version de moindre précédence du non logique. La valeur d'un opérande nié est vraie (1) si l'opérande est faux (0 numérique, chaîne "0", chaîne vide ou valeur indéfinie) et fausse ("") si l'opérande est vrai.

Le - unaire effectue une négation arithmétique si son opérande est numérique. Si l'opérande est un identificateur, une chaîne composée d'un signe moins concaténé à l'identificateur est renvoyée. Sinon, si la chaîne commence avec un plus ou un moins, une chaîne commençant avec le signe opposé est renvoyée. Un des effets de ces règles est que -motsimple est équivalent à "-motsimple". C'est particulièrement utile aux programmeurs Tk.

Le ~ unaire réalise une négation sur les bits, c'est-à-dire un complément à 1. Par définition, ce n'est pas vraiment portable quand c'est limité par la taille du mot-machine de votre ordinateur. Par exemple, sur une machine 32 bits ~123 vaut 4294967172, tandis que sur une machine 64 bits, cela vaut 18446744073709551492. Mais vous le saviez déjà.

Ce que vous ne saviez peut-être pas, c'est que si l'argument de ~ est une chaîne au lieu d'un nombre, une chaîne de même longueur est renvoyée avec tous ses bits complémentés. C'est une manière rapide de basculer un grand nombre de bits d'un coup, et de façon portable puisque cela ne dépend pas de la taille de votre mot-machine. Plus tard nous verrons aussi les opérateurs logiques sur les bits, qui ont eux des variantes pour les chaînes.

Le + n'a aucun effet sémantique, même sur les chaînes. Son utilité est surtout syntaxique, pour séparer le nom d'une fonction d'une expression entre parenthèses qui serait sinon interprétée comme la liste complète des arguments de la fonction. (Voir les exemples dans la section Termes et opérateurs de listes (vers la gauche).) Si vous y réfléchissez d'une manière un peu détournée, le + inverse l'effet qu'ont les parenthèses de changer les opérateurs préfixes en fonctions.

Le \ crée une référence sur ce qui le suit. Utilisé sur une liste, il crée une liste de références. Voir la section L'opérateur antislash au chapitre 8 pour plus de détails. Attention à ne pas confondre ce comportement avec celui de l'antislash dans une chaîne, bien que les deux formes comportent la notion vaguement négative de protection de leurs arguments contre l'interprétation. Cette ressemblance n'est pas purement fortuite.

Le =~ binaire lie une expression scalaire à un opérateur de recherche de motif, de substitution ou de translittération (négligemment appelée traduction). Ces opérations chercheraient ou modifieraient sinon la chaîne contenue dans $_ (la variable par défaut). La chaîne à lier est placée à gauche, tandis que l'opérateur lui-même est placé à droite. La valeur de retour indique le succès ou l'échec de l'opération effectuée à droite, puisque l'opérateur de lien ne fait rien par lui-même.

Si l'argument de droite est une expression plutôt qu'une recherche de motif, une substitution ou une translittération, il sera interprété comme une recherche de motif à l'exécution. C'est-à-dire que $_ =~ $pat est équivalent à $_ =~ /$pat/. C'est moins efficace qu'une recherche explicite, puisque le motif doit être vérifié et potentiellement recompilé à chaque fois que l'expression est évaluée. Vous pouvez éviter cette recompilation en précompilant le motif original avec l'opérateur qr// de citation d'expression régulière (« quote regex » en anglais).

Le !~ binaire est identique à =~ sauf que la valeur de retour est inversée logiquement. Les expressions suivantes sont fonctionnellement équivalentes :

$chaine !~ /pattern/ not
$chaine =~ /pattern/

Nous avons dit que la valeur de retour indique le succès, mais il existe plusieurs sortes de succès. La substitution renvoie le nombre de substitutions réussies, comme la translittération. (En fait, la translittération sert souvent à compter les caractères.) Puisque n'importe quel résultat non nul est vrai, tout fonctionne. La forme de valeur vraie la plus spectaculaire est une valeur de liste : en contexte de liste, les recherches de motif peuvent renvoyer les sous-chaînes capturées par les parenthèses dans le motif. Conformément aux règles de l'affectation de liste, cette affectation retournera vrai si quelque chose a été détecté et affecté, et faux dans le cas contraire. C'est pourquoi vous voyez parfois des choses comme :

if ( ($c,$v) = $chaine =~ m/(\w+)=(\w*)/ ) {
    print "CLE $c VALEUR $v\n";
}

Décomposons tout cela. Le =~ a la précédence sur =, il se produit donc en premier. Le =~ lie $chaine à la recherche de motif à droite. Celle-ci recherche ce qui ressemble à CLE=VALEUR dans votre chaîne. Il se trouve en contexte de liste, car du côté droit d'une affectation de liste. Si le motif est trouvé, il renvoie une liste à affecter à $c et $v. L'affectation de liste elle-même se trouve dans un contexte scalaire et renvoie donc 2, le nombre de valeurs à droite de l'affectation. Et il se trouve que 2 est vrai, puisque notre contexte scalaire est aussi un contexte booléen. Quand la recherche échoue, aucune valeur n'est affectée, ce qui renvoie 0, qui est faux.

Voir le chapitre 5, Recherche de motif, pour en savoir plus sur le fonctionnement des motifs.

Perl fournit des opérateurs proches de ceux de C : * (multiplication), / (division) et % (modulo). * et / fonctionnent exactement comme vous vous y attendez, en multipliant ou divisant leurs deux opérandes. La division se fait en virgule flottante, à moins que vous n'ayez spécifié le pragma integer.

L'opérateur % convertit ses opérandes en entiers avant de calculer le reste de la division entière. (Néanmoins cette division est faite en virgule flottante donc vos opérandes peuvent faire 15 chiffres sur la plupart des machines 32 bits.) Supposons que nos deux opérandes s'appellent $a et $b. Si $b est positif, alors le résultat de $a % $b est $a moins le plus grand multiple de $b inférieur à $a (ce qui veut dire que le résultat sera toujours dans l'intervalle 0 .. $b-1). Si $b est négatif, alors le résultat de $a % $b est $a moins le plus petit multiple de $b supérieur à $a (ce qui veut dire que le résultat sera toujours dans l'intervalle $b+1 .. 0).

Quand on est à portée de use integer, % vous donne directement accès à l'opérateur modulo tel qu'il est implémenté par votre compilateur C. Cet opérateur n'est pas bien défini pour les opérandes négatifs, mais s'exécutera plus rapidement.

Le x est l'opérateur de répétition. En réalité, il s'agit de deux opérateurs. En contexte scalaire, il retourne une chaîne concaténée composée de l'opérande de gauche répété le nombre de fois spécifié par l'opérande de droite. (Pour assurer la compatibilité avec les versions précédentes, il le fait également en contexte de liste si l'argument de gauche n'est pas entre parenthèses.)

print '-' x 80;                           # imprime une rangée de tirets
print "\t" x ($tab/8), ' ' x ($tab%8);    # tabule à la colonne $tab

En contexte de liste, si l'opérande de gauche est une liste entre parenthèses, x fonctionne comme un réplicateur de liste plutôt que comme un réplicateur de chaîne. Cela peut servir à initialiser à la même valeur tous les éléments d'un tableau de longueur indéterminée.

@ones = (1) x 80;       # une liste de 80 1
@ones = (5) x @ones;    # met tous les éléments à 5

De la même manière, vous vous pouvez également utiliser x pour initialiser des tranches de tableaux et de hachages.

@cles = qw(du Perl aux cochons);
@hash{@cles} = ("") x @cles;

Si cela vous laisse perplexe, remarquez que @cles est utilisé à la fois comme une liste à gauche de l'affectation et comme une valeur scalaire (qui renvoie la longueur du tableau) à droite. L'exemple précédent a le même effet sur %hash que :

$hash{du}      = "";
$hash{Perl}    = "";
$hash{aux}     = "";
$hash{cochons} = "";

Étonnamment, Perl dispose des opérateurs usuels + (addition) et - (soustraction). Ces deux opérateurs convertissent leurs arguments de chaîne en valeurs numériques si nécessaire, et renvoient un résultat numérique.

Perl fournit également l'opérateur . qui réalise la concaténation de chaînes. Par exemple :

$presque = "Fred" . "Pierrafeu";        # renvoie FredPierrafeu

Remarquez que Perl n'ajoute pas d'espace entre les chaînes concaténées. Si vous voulez l'espace ou si vous avez plus de deux chaînes à concaténer, vous pouvez utiliser l'opérateur join, décrit au chapitre 29, Fonctions. Cependant, la plupart du temps on concatène implicitement dans une chaîne entre doubles apostrophes :

$nomcomplet = "$prenom $nom";

Les opérateurs de décalage de bits (<< et >>) renvoient la valeur de l'argument de gauche décalé à gauche (<<) ou à droite (>>) du nombre de bits spécifié par l'argument de droite. Les arguments doivent être des entiers. Par exemple :

1 << 4;     # renvoie 16
32 >> 4;    # renvoie 2

Faites attention cependant, car les résultats sur de grands nombres (ou sur des nombres négatifs) peuvent dépendre du nombre de bits utilisés par votre machine pour représenter les entiers.

Certaines des « fonctions » décrites au chapitre 29 sont en fait des opérateurs unaires. Le tableau 3-2 liste tous les opérateurs unaires nommés.

Les opérateurs unaires nommés ont une précédence supérieure à celle de certains opérateurs binaires. Par exemple :

sleep 4 | 3;

ne dort pas pendant 7 secondes ; il dort pendant 4 secondes puis prend la valeur de retour de sleep (typiquement zéro) et la combine par OU avec 3, comme si l'expression avait des parenthèses comme suit :

(sleep 4) | 3;

À comparer avec :

print 4 | 3;

qui prend effectivement la valeur de 4 combiné par OU avec 3 avant de l'afficher (7 dans ce cas), comme s'il était écrit :

print (4 | 3);

En effet, print est un opérateur de liste, et non un simple opérateur unaire. Une fois que vous saurez quels opérateurs sont des opérateurs de liste, vous n'aurez plus de problème pour distinguer les opérateurs de liste des opérateurs unaires. En cas de doute, vous pouvez toujours utiliser des parenthèses pour transformer un opérateur unaire en fonction. Souvenez-vous, si ça ressemble à une fonction, c'est une fonction.

Une autre caractéristique curieuse des opérateurs unaires nommés est que beaucoup d'entre eux prennent $_ comme argument par défaut, si vous ne leur en fournissez pas d'autre. Cependant, si vous omettez l'argument et que ce qui suit ressemble au début d'un argument, Perl va se tromper, car il attend un terme. Quand le caractère suivant du programme est l'un de ceux listés au tableau 3-3, le tokeniseur de Perl renvoie différents types de token selon qu'il attend un terme ou un opérateur.

Une erreur typique est donc :

next if length < 80;

où pour l'analyseur le < ressemble au début du symbole <> (un terme) au lieu du « inférieur à » (un opérateur) auquel vous pensiez. Il n'existe pas vraiment de moyen d'arranger les choses tout en gardant Perl pathologiquement éclectique. Si vous êtes paresseux au point de ne pouvoir vous résoudre à taper les deux caractères $_, l'une de ces instructions devrait faire l'affaire :

next if length() < 80;
next if (length) < 80;
next if 80 > length;
next unless length >= 80;

Quand un terme est attendu, un signe moins suivi d'une lettre seule sera toujours interprété comme un test de fichier. Un opérateur de test de fichier est un opérateur unaire qui prend comme argument un nom ou un handle de fichier, et teste le fichier associé pour savoir si une certaine propriété est vraie à son sujet. Si l'argument est omis, il teste $_, sauf pour -t, qui teste STDIN. Sauf si c'est indiqué autrement dans la documentation, il retourne 1 pour vrai et "" pour faux, ou la valeur indéfinie si le fichier n'existe pas ou n'est pas accessible. Les opérateurs de test de fichier actuellement implémentés sont listés au tableau 3-4.

Remarquez que -s/a/b/ ne fait pas une substitution négative. -exp($foo) fonctionne cependant comme prévu ; seules les lettres isolées qui suivent un signe moins sont interprétées comme des tests de fichier.

L'interprétation des opérateurs de test de permissions -r, -R, -w, -W, -x et -X est fondée uniquement sur le mode du fichier et les ID d'utilisateur et de groupe de l'utilisateur. Il peut y avoir d'autres raisons pour lesquelles vous ne pouvez effectivement pas lire, écrire ou exécuter le fichier, comme les listes de contrôle d'accès d'AFS (Andrew File System).(57) Notez également que pour le super utilisateur -r, -R, -w et -W renvoient toujours 1, et que -x et -X renvoient 1 si l'un des bits d'exécution est à 1 dans le mode. C'est pourquoi les scripts lancés par le super utilisateur peuvent nécessiter un stat ffin de connaître le véritable mode du fichier, ou bien remplacer temporairement l'UID par autre chose.

Les autres opérateurs de test de fichier se moquent de savoir qui vous êtes. N'importe qui peut utiliser le test pour les fichiers « simples » :

while (<>) {
    chomp;
    next unless -f $_;      # ignore les fichiers "spéciaux"
    ...
}

Les options -T et -B fonctionnent comme suit. Le premier bloc (plus ou moins) du fichier est examiné à la recherche de caractères inhabituels comme des codes de contrôle ou des octets donc le bit de poids fort est à 1 (et qui n'ont pas l'air d'être de l'UTF-8). Si on trouve plus d'un tiers d'octets inhabituels, c'est un fichier binaire ; sinon c'est un fichier texte. De même, tout fichier dont le premier bloc contient le caractère ASCII NUL (\0) est considéré comme binaire. Si -T ou -B est utilisé sur un handle de fichier, le tampon d'entrée standard (standard I/O ou « stdio ») en cours est examiné, au lieu du premier bloc du fichier. -T et -B renvoient vrai sur un fichier vide, ou sur un fichier à EOF (end-of-file : fin de fichier) quand on teste un handle. Comme Perl doit lire le fichier pour faire le test -T, vous devrez éviter de vous en servir sur des fichiers qui risquent de bloquer ou de vous causer des ennuis. C'est pourquoi la plupart du temps, vous devrez tester avec un -f d'abord, comme dans :

next unless -f $fichier && -T $fichier;

Si l'on donne à l'un des tests de fichier (ou à l'un des opérateurs stat ou lstat) le handle spécial constitué d'un souligné unique, c'est la structure stat du dernier test de fichier (ou de l'opérateur stat) qui est utilisée, économisant ainsi un appel système. (Cela ne marche pas avec -t, et il faudra vous souvenir que lstat et -l laissent dans la structure stat les valeurs pour le lien symbolique et non pour le fichier réel. De même, -l _ sera toujours faux après un stat normal.)

Voici quelques exemples :

print "Fait l'affaire.\n"    if -r $a || -w _ || -x _;

stat($fichier);
print "En lecture\n"         if -r _;
print "En écriture\n"        if -w _;
print "Exécutable\n"         if -x _;
print "Setuid\n"             if -u _;
print "Setgid\n"             if -g _;
print "Sticky\n"             if -k _;
print "Texte\n"              if -T _;
print "Binaire\n"            if -B _;

Les âges des fichiers donnés par -M, -A et -C sont en jours (avec partie fractionnaire) depuis le moment où le script a commencé à tourner. Cette date est stockée dans la variable spéciale $^T ($BASETIME). Donc, si le fichier a été modifié depuis que le script a démarré, vous obtiendrez une durée négative. Remarquez que comme la plupart des durées (86 399 sur 86 400 en moyenne) sont fractionnaires, il est généralement illusoire de tester l'égalité avec un entier sans passer par la fonction int. Exemples :

next unless -M $fichier > .5;       # fichier vieux de plus de 12 heures
&nouveaufichier if -M $fichier < 0; # fichier plus récent que le processus
&avertissemnt if int(-A) == 90;     # fichier ($_) accédé il y a 90 jours
                                    # aujourd'hui

Pour remettre à la date courante la date de démarrage du script, écrivez :

$^T = time;

Perl possède deux classes d'opérateurs relationnels. L'une d'elles opère sur les valeurs numériques et l'autre sur les valeurs de chaîne, comme indiqué au tableau 3-5.

Ces opérateurs renvoient 1 pour vrai et "" pour faux. Notez que les opérateurs relationnels sont non-associatifs, ce qui signifie que $a < $b < $c provoquera une erreur de syntaxe.

En l'absence de déclaration de locales, les comparaisons de chaînes s'appuient sur l'ordre lexicographique ASCII/Unicode et, contrairement à certains autres langages informatiques, les espaces finaux comptent pour la comparaison. Avec une déclaration de locale, l'ordre lexicographique spécifié par la locale est utilisé. (Les mécanismes de tri fondés sur les locales peuvent plus ou moins bien interagir avec les mécanismes Unicode actuellement en cours de développement.)

Les opérateurs d'égalité listés au tableau 3-6 ressemblent beaucoup aux opérateurs relationnels.

Les opérateurs égal et différent renvoient 1 pour vrai et "" pour faux (exactement comme les opérateurs relationnels). Les opérateurs <=> et cmp renvoient -1 si l'opérande de gauche est inférieur à celui de droite, 0 s'il sont égaux et +1 si l'opérande de gauche est supérieur à celui de droite. Bien que ces opérateurs semblent très proches des opérateurs relationnels, ils ont un niveau de précédence plus faible, et la syntaxe de $a < $b <=> $c < $d est donc valide.

Pour des raisons évidentes pour quiconque a vu Star Wars, l'opérateur <=> est aussi connu sous le nom d'opérateur « vaisseau spatial » (spaceship operator).

Comme C, Perl dispose des opérateurs ET, OU et OU-exclusif sur les bits : &, | et ^. Vous avez bien sûr remarqué, après votre étude attentive du tableau au début de ce chapitre, que le ET sur les bits possède une précédence supérieure aux autres ; nous avons triché pour tous les inclure dans cette discussion.

Ces opérateurs fonctionnent différemment sur les valeurs numériques et sur les chaînes. (C'est l'un des rares cas où Perl fait une différence.) Si l'un des opérandes est un nombre (ou a été utilisé comme un nombre), les deux opérandes sont convertis en entiers, puis l'opération sur les bits est effectuée. Ces entiers font au moins 32 bits de long, mais peuvent faire 64 bits sur certaines machines. L'important est qu'il existe une limite arbitraire imposée par l'architecture de la machine.

Si les deux opérandes sont des chaînes (et n'ont pas été utilisés comme des nombres depuis leur dernière mise à jour), les opérateurs font les opérations sur les bits sur les bits correspondants des deux chaînes. Dans ce cas, il n'y a aucune limite arbitraire, puisque les chaînes ne sont pas limitées en taille. Si l'une des chaînes est plus longue que l'autre, on considère que la plus courte dispose d'un nombre suffisant de bits à 0 pour compléter la différence.

Par exemple, si vous faites un ET entre deux chaînes :

"123.45" & "234.56"

vous obtenez une autre chaîne :

"020.44"

Mais si vous faites un ET sur une chaîne et un nombre :

"123.45" & 234.56

La chaîne est d'abord convertie en nombre, ce qui donne :

123.45 & 234.56

Les nombres sont ensuite convertis en entiers :

123 & 234

ce qui donne 106. Remarquez que toutes les chaînes de bits sont vraies (à moins de donner la chaîne « 0 »). Cela signifie que si vous voulez vérifier si l'un des octets résultant est non nul, vous ne devrez pas écrire ceci :

if ( "fred" & "\1\2\3\4" ) { ... }

mais cela :

if ( ("fred" & "\1\2\3\4") =~ /[^\0]/ ) { ... }

Comme C, Perl propose également les opérateurs && (ET logique) et || (OU logique). Ils sont évalués de gauche à droite (&& ayant une précédence légérement supérieure à celle de ||) pendant le test de vérité de l'instruction. Ces opérateurs sont appelés opérateurs court-circuit, car ils déterminent la vérité de l'instruction en évaluant le plus petit nombre d'opérandes possible. Par exemple, si l'opérande à gauche d'un opérateur && est faux, l'opérande de droite ne sera jamais évalué, car le résultat de l'opérateur sera faux quelle que soit la valeur de l'opérande de droite.

Non seulement de tels courts-circuits font gagner du temps, mais ils sont fréquemment utilisés pour contrôler le flux de l'évaluation. Par exemple, un idiome courant en Perl est :

open(FILE, "monfichier") || die "Impossible d'ouvrir monfichier: $!\n";

Dans ce cas, Perl évalue d'abord la fonction open. Si sa valeur est vraie (car monfichier a été ouvert avec succès), l'exécution de la fonction die n'est pas nécessaire et est donc omise. Vous pouvez littéralement lire « Ouvre mon fichier ou meurs ! ».

Les opérateurs && et || diffèrent de ceux de C en ceci qu'au lieu de retourner 0 ou 1, ils renvoient la dernière valeur évaluée. Dans le cas de ||, cela a le délicieux effet de vous permettre de choisir la première valeur vraie d'une série. Une manière raisonnablement portable de trouver le répertoire personnel d'un utilisateur pourrait donc être :

$home = $ENV{HOME}
     || $ENV{LOGDIR}
     || (getpwuid($<))[7]
     || die "Vous êtes SDF !\n";

D'un autre côté, comme l'argument de gauche toujours évalué en contexte scalaire, vous ne pouvez pas vous servir de || afin choisir entre deux agrégats pour une affectation :

@a = @b || @c;              # Ceci ne fait pas ce que vous voulez
@a = scalar(@b) || @c;      #, car voici ce que cela veut dire.
@a = @b ? @b : @c;          # En revanche cela marche bien.

Perl fournit également des opérateurs and et or de moindre précédence, que certains trouvent plus lisibles et qui ne vous forcent pas à utiliser des parenthèses sur les opérateurs de liste. Ils sont aussi à court-circuit. Voir le tableau 1-1 pour la liste complète.

L'opérateur d'intervalle .. comprend en fait deux opérateurs différents selon le contexte.

L'opérateur est bi-stable, comme un flip-flop électronique, et émule l'opérateur d'intervalle de ligne (virgule) de sed, awk et d'autres éditeurs. Chaque opérateur .. scalaire mémorise son propre état booléen. Il est faux tant que son opérande de gauche est faux. Une fois que l'opérande de gauche est vrai, l'opérateur reste vrai jusqu'à ce que l'opérande de droite soit vrai, après quoi l'opérateur d'intervalle redevient faux. L'opérateur ne devient pas faux jusqu'à sa prochaine évaluation. Il peut tester l'opérande de droite et devenir faux pendant la même évaluation que celle sur laquelle il est devenu vrai (comme l'opérateur de awk), mais renvoie vrai au moins une fois. Si vous ne voulez pas qu'il teste l'opérande de droite avant la prochaine évaluation (comme l'opérateur de sed) utilisez simplement trois points (...) au lieu de deux. Pour les deux opérateurs .. et ..., l'opérande de droite n'est pas évalué tant que l'opérateur se trouve dans l'état faux, et l'opérande de gauche n'est pas évalué tant que l'opérateur est dans l'état vrai.

La valeur renvoyée est soit la chaîne vide pour faux soit un numéro de séquence (commençant à 1) pour vrai. Le numéro de séquence est remis à zéro pour chaque opérateur d'intervalle rencontré. La chaîne « E0 » est accolée à la fin du numéro de séquence final dans un intervalle, ce qui n'affecte pas sa valeur numérique, mais vous donne quelque chose à chercher si vous voulez exclure l'élément final. Vous pouvez exclure le point de départ en attendant que le numéro de séquence soit plus grand que 1. Si l'un des opérandes de .. est un littéral numérique, cet opérande est implicitement comparé à la variable $., qui contient le numéro de ligne courant de votre fichier d'entrée. Exemples :

if (101 .. 200) { print; }    # imprime la deuxième centaine de lignes
next line if (1 .. /^$/);     # passe les entêtes d'un message
s/^/> / if (/^$/ .. eof());   # cite le corps d'un message

En contexte de liste, .. renvoie une liste de valeurs comptées à partir de la valeur de gauche jusqu'à la valeur de droite (par incréments de un). Cela sert à écrire des boucles for (1..10) et pour faire des tranches de tableaux :

for (101 .. 200) { print; }     # affiche 101102...199200
@foo = @foo[0 .. $#foo];        # un no-op coûteux
@foo = @foo[ -5 .. -1];         # la tranche des 5 derniers éléments

Si la valeur de gauche est supérieure à celle de droite, une liste vide est renvoyée. (Pour construire une liste en ordre inverse, voir l'opérateur reverse.)

Si ses opérandes sont des chaînes, l'opérateur d'intervalle emploie l'algorithme d'autoincrémentation magique vu précédemment.(58) Vous pouvez donc écrire :

@alphabet = ('A' .. 'Z');

pour obtenir toutes les lettres de l'alphabet (latin), ou :

$hexdigit = (0 .. 9, 'a' .. 'f')[$nombre & 15];

pour obtenir un chiffre hexadécimal, ou :

@z2 = ('01' .. '31'); print $z2[$jour];

pour obtenir des dates avec un zéro en tête. Vous pouvez également écrire :

@combis = ('aa' .. 'zz');

pour obtenir toutes les combinaisons de deux lettres minuscules. Attention cependant à quelque chose comme :

@grossescombis = ('aaaaaa' .. 'zzzzzz');

car cela va nécessiter beaucoup de mémoire. Pour être précis, il faudra de l'espace pour stocker 308 915 776 scalaires. Espérons que vous avez une grosse partition de swap. Vous devriez vous intéresser à une approche itérative.

L'opérateur ?: est le seul opérateur ternaire, comme en C. On l'appelle souvent l'opérateur conditionnel, car il fonctionne comme un if-then-else, excepté qu'il peut être inclus sans problème dans d'autres expressions et fonctions, car c'est une expression et non une instruction. En tant qu'opérateur ternaire, ses deux éléments séparent trois expressions :

COND ? EXPR_SI_VRAI : EXPR_SI_FAUX

Si la condition COND est vrai, seule l'expression EXPR_SI_VRAI est évaluée, et la valeur de cette expression devient la valeur de toute l'expression. Sinon, seule l'expression EXPR_SI_FAUX est évaluée, et sa valeur devient celle de toute l'expression.

Le contexte scalaire ou de liste se propage vers le deuxième ou le troisième argument, selon celui qui est sélectionné. (Le premier argument est toujours en contexte scalaire, puisque c'est une condition.)

$a = $ok ? $b : $c; # donne un scalaire
@a = $ok ? @b : @c; # donne un tableau
$a = $ok ? @b : @c; # donne le nombre d'éléments d'un tableau

Vous verrez souvent l'opérateur conditionnel inclus dans des listes de valeurs à formater avec printf, car personne n'a envie de dupliquer une instruction complète juste pour basculer entre deux valeurs proches.

printf "J'ai %d chameau%s.\n",
             $n,       $n <= 1 ? "" : "x";

La précédence de ?: est opportunément plus grande que celle de la virgule, mais inférieure à celle de la plupart des opérateurs que vous utiliserez à l'intérieur (comme == dans cet exemple) ; vous n'aurez donc généralement pas à utiliser de parenthèses. Mais vous pouvez ajouter des parenthèses pour clarifier, si vous voulez. Pour les opérateurs conditionnels emboîtés à l'intérieur de la partie EXPR_SI_VRAI d'autres opérateurs conditionnels, nous vous suggérons de de faire des sauts de ligne et d'indenter comme s'il s'agissait d'instruction if ordinaires :

$bissextile =
    $annee % 4 == 0
        ? $annee % 100 == 0
            ? $annee % 400 == 0
                ? 1
                : 0
            : 1
        : 0;

Pour les conditions imbriquées dans des parties EXPR_SI_FAUX d'opérateurs conditionnels précédents, vous pouvez faire quelque chose d'équivalent :

$bissextile =
    $annee % 4
        ? 0
        : $annee % 100
            ? 1
            : $annee % 400
                ? 0
                : 1;

mais il est habituellement préférable d'aligner verticalement toutes les COND et les EXPR_SI_VRAI :

$bissextile =
    $annee % 4 ? 0 :
    $annee % 100 ? 1 :
    $annee % 400 ? 0 : 1;

Même des structures assez encombrées peuvent s'éclaircir en alignant les points d'interrogation et les deux-points :

printf "Oui, j'aime mon livre du %s!\n",
    $i18n eq "anglais" ? "camel" :
    $i18n eq "allemand" ? "Kamel" :
    $i18n eq "japonais" ? "\x{99F1}\x{99DD}" :
                          "chameau"

Vous pouvez affecter à l'opérateur conditionnel(59) si le deuxième et le troisième arguments sont tous les deux des lvalues légales (c'est-à-dire qu'on peut leur affecter une valeur), et que tous deux sont soit des scalaires, soit des listes (sinon Perl ne saura pas quel contexte fournir à la partie droite de l'affectation) :

($a_ou_b ? $a : $b) = $c;  # donne la valeur de $c soit à $a, soit à $b

Souvenez-vous que l'opérateur conditionnel lie encore plus fort que les multiples opérateurs d'affectation. C'est habituellement ce que vous voulez (voir l'exemple $bissextile plus haut, par exemple), mais vous ne pourrez pas obtenir l'effet inverse sans parenthèses. L'utilisation d'affectations dans un opérateur conditionnel vous attirera des ennuis, et vous risquez même de ne pas avoir d'erreur à l'analyse, car l'opérateur conditionnel peut être analysé comme une lvalue. Par exemple, vous pourriez écrire ceci :

$a% 2?$a+=10: $a += 2       # FAUX

Mais ce serait analysé comme cela :

(($a%2)?($a+=10) : $a) += 2

Perl reconnaît les opérateurs d'affectation de C, et fournit également les siens. Il y en a un certain nombre :

Chaque opérateur nécessite une lvalue cible (typiquement une variable ou un élément de tableau) à sa gauche et une expression à sa droite. Pour l'opérateur d'affectation simple :

CIBLE = EXPR

La valeur de EXPR est stockée dans la variable ou à l'endroit désigné par CIBLE. Pour les autres opérateurs, Perl évalue l'expression :

CIBLE OP= EXPR

comme s'il était écrit :

CIBLE = CIBLE OP EXPR

C'est un bon moyen mnémotechnique, mais il est trompeur, et de deux manières. D'abord les opérateurs d'affectation sont analysés au niveau de précédence des affectations ordinaires, quelle que soit la précédence que l'opérateur OP aurait eue par lui-même. Ensuite, CIBLE n'est évalué qu'une seule fois. Habituellement cela n'a aucune importance, sauf en cas d'effets secondaires, comme pour une auto-incrémentation.

$var[$a++] += $valeur;               # $a is incrementé une fois
$var[$a++] = $var[$a++] + $valeur;   # $a is incrementé deux fois

À la différence de C, l'opérateur d'affectation produit une lvalue valide. Modifier une affectation revient à faire l'affectation puis à modifier la variable à laquelle on vient d'affecter une valeur. Cela peut servir à modifier une copie de quelque chose, comme ceci :

($tmp = $global) += $constante;

qui est équivalent à :

$tmp = $global + $constante;

De même :

($a +=2)*= 3;

est équivalent à :

$a += 2;
$a *= 3;

Ce n'est pas tellement utile, mais voici un idiome fréquent :

($nouveau = $ancien) =~ s/toto/titi/g;

Dans tous les cas, la valeur de l'affectation est la nouvelle valeur de la variable. Comme les opérateurs d'affectations sont associatifs de droite à gauche, cela peut servir à affecter la même valeur à plusieurs variables, comme dans :

$a=$b =$c = 0;

qui affecte 0 à $c et le résultat de cette opération (toujours 0) à $b, puis le résultat de (toujours 0) à $a.

Les affectations de listes ne se font qu'avec l'opérateur d'affectation simple, =. Dans un contexte de liste, une affectation de liste retourne la liste des nouvelles valeurs, tout comme l'affectation scalaire. En contexte scalaire, une affectation de liste renvoie le nombre de valeurs qui étaient disponibles à droite de l'affectation, comme indiqué au chapitre 2, Composants de Perl. Cela sert pour tester les fonctions qui renvoient une liste vide quand elles échouent (ou finissent par échouer), comme dans :

while (($cle, $valeur) = each %gloss) { ... }
next unless ($dev, $ino, $mode) = stat $fichier;

Le « , » binaire est l'opérateur virgule. En contexte scalaire, il évalue son argument de gauche en contexte vide, jette le résultat, puis évalue son argument de droite et retourne cette valeur. Exactement comme l'opérateur virgule de C. Par exemple :

$a = (1, 3);

affecte 3 à $a. Attention à ne pas confondre son utilisation en contexte scalaire avec son utilisation en contexte de liste. Dans un contexte de liste, une virgule est juste le séparateur des arguments de la liste et il insère ses deux arguments dans la LISTE. Il ne jette aucune valeur.

Par exemple, si vous modifiez l'exemple précédent en :

@a = (1, 3);

vous construisez une liste de deux éléments, tandis que :

atan2(1, 3);

appelle la fonction atan2 avec deux arguments.

La plupart du temps, le digramme => est juste un synonyme pour l'opérateur virgule. Il sert à documenter les arguments appariés. Il force également l'interprétation comme chaîne de tout identificateur placé à sa gauche.

La partie droite d'un opérateur de liste commande tous les arguments de l'opérateur de liste, qui sont séparés par des virgules ; donc la précédence d'un opérateur de liste est plus faible que celle de la virgule, si vous regardez vers la droite. Une fois qu'un opérateur de liste commence à avaler des arguments séparés par des virgules, les seules choses qui l'arrêtent sont les tokens qui terminent l'expression tout entière (comme les points-virgules ou les modificateurs d'instructions) ou les tokens qui terminent la sous-expression en cours (comme les parenthèses ou les crochets fermants) ou les opérateurs logiques de faible précédence dont nous aller parler tout de suite.

Perl fournit les opérateurs and, or, et not comme alternatives de moindre précédence à &&, ||, et !. Le comportement de ces opérateurs est identique — en particulier, and et or court-circuitent comme leurs alter ego, ce qui leur donne leur utilité non seulement pour les expressions logiques, mais aussi pour le contrôle du flux d'évaluation.

Comme la précédence de ces opérateurs est beaucoup plus basse que celle des opérateurs empruntés à C, vous pouvez les utiliser en toute sécurité après un opérateur de liste, sans qu'il soit besoin de parenthèses.

unlink "alpha", "beta", "gamma"
        or enrage(), next LIGNE;

Avec les opérateurs issus de C, vous auriez dû l'écrire comme ceci :

unlink("alpha", "beta", "gamma")
        || (enrage(), next LIGNE);

Mais vous ne pouvez pas simplement remplacer toutes les occurrences de || par or. Supposons que vous changiez ceci :

$xyz=$x|| $y|| $z;

en cela :

$xyz=$xor$yor $z; # FAUX

Cela ne ferait pas du tout la même chose ! La précédence de l'affectation est supérieure à celle de or, mais plus basse que celle de ||, donc on affecterait toujours $x à $xyz pour ensuite seulement faire les or. Pour obtenir le même résultat qu'avec ||, vous devrez écrire :

$xyz= ($xor $y or $z );

La morale de cette histoire, c'est qu'il faut toujours apprendre les règles de précédence (ou utiliser les parenthèses) quels que soient les opérateurs logiques que vous utilisez.

Il existe également un xor logique qui n'a pas d'équivalent exact en C ou en Perl, puisque le seul autre opérateur OU-exclusif (^) travaille sur les bits. L'opérateur xor ne peut pas court-circuiter, car les deux côtés doivent être évalués. Le meilleur équivalent de $a xor $b est peut-être !$a != !$b. On pourrait également écrire !$a ^ !$b ou même $a ? !$b : !!$b, bien sûr. L'essentiel est que $a et $b doivent tous les deux être évalués comme vrais ou faux dans un contexte booléen, et l'opérateur sur les bits existants n'en fournit pas sans qu'on l'y aide.

Voici ce que C a et que Perl n'a pas :

& unaire

• L'opérateur adresse-de. L'opérateur \ de Perl (qui fournit une référence) occupe la même niche écologique :

   

  Sélectionnez

  $ref_var = \$var;

• Mais les références de Perl sont plus sûres que les pointeurs de C.

* unaire

• L'opérateur de déréférencement d'adresse. Comme Perl ne connaît pas les adresses, il n'a pas besoin de les déréférencer. En revanche, Perl a des références et ce sont donc les caractères de préfixe variable qui servent d'opérateurs de déréférence, tout en indiquant le type : $, @, % et &. Étonnamment, il existe bien un opérateur * de déréférencement, mais comme * est le drôle de caractère indiquant un typeglob, vous ne l'utiliserez pas ainsi.

(TYPE)

• L'opérateur de transtypage. De toute façon, personne n'aime se faire transtyper.

Une instruction simple est une expression évaluée pour ses effets secondaires. Toute instruction simple doit se terminer par un point-virgule, sauf si c'est la dernière instruction d'un bloc. Dans ce cas, le point-virgule est optionnel — Perl sait que vous en avez fini avec cette instruction, puisque vous avez fini le bloc. Mais mettez quand même le point-virgule s'il s'agit d'un bloc multiligne, car vous pourriez bien ajouter une autre ligne par la suite.

Bien que des opérateurs comme eval {}, do {} et sub {} ressemblent à des instructions composées, en fait ce n'en sont pas. Certes, ils permettent d'avoir plusieurs instructions à l'intérieur, mais cela ne compte pas. Vus de l'extérieur, ces opérateurs sont juste des termes dans une expression ; c'est pourquoi ils nécessitent un point-virgule explicite quand ils sont utilisés comme dernier élément d'une instruction.

Toute instruction simple peut être optionnellement suivie d'un modificateur unique, juste avant le point-virgule final (ou la fin de bloc). Les modificateurs possibles sont :

if EXPR
unless EXPR
while EXPR
until EXPR
foreach LISTE

Les modificateurs if et unless fonctionnent comme peuvent s'y attendre les anglophones :

$trash->take('out') if $you_love_me;    # sors la poubelle si tu m'aimes
shutup() unless $you_want_me_to_leave;  # tais-toi, sauf si tu veux que
                                        # je m'en aille

Les modificateurs while et until sont évalués de façon répétée. Comme notre lectorat anglophone pouvait s'y attendre, un modificateur while exécute l'expression tant que sa propre expression reste vraie, tandis qu'un modificateur until continue de s'exécuter tant qu'elle reste fausse :

$expression++ while -e "$file$expression";
kiss('me') until $I_die;                # embrasse-moi jusqu'à la mort

Le modificateur foreach (aussi orthographié for) est évalué une fois par élément de sa LISTE, $_ étant un alias de l'élément courant :

s/java/perl/ for @curriculum;
print "champ: $_\n" foreach split /:/, $ligne;

Les modificateurs while et until ont la sémantique usuelle des boucles while (la condition est évaluée en premier), sauf quand ils s'appliquent à un doBLOC (ou à l'instruction maintenant dépréciée doSUBROUTINE), auquel cas le bloc s'exécute une fois avant que la condition soit évaluée. Cela vous permet d'écrire des boucles comme :

do {
    $ligne = <STDIN>;
    ...
} until $ligne eq ".\n";

Voyez aussi les trois différentes entrées de do au chapitre 29, Fonctions. Remarquez également que les opérateurs de contrôle de boucle décrits plus loin ne fonctionnent pas dans cette construction, car les modificateurs de boucles ne prennent pas d'étiquette. Vous pouvez toujours placer un bloc supplémentaire autour pour terminer plus tôt, ou à l'intérieur pour itérer avant la fin de la boucle, comme cela est décrit dans la section Blocs simples. Ou bien vous pourriez écrire une vraie boucle avec plusieurs commandes de contrôle de boucle à l'intérieur. À propos de vraies boucles, nous allons maintenant parler des instructions composées.

On appelle bloc une séquence d'instructions définie dans une portée(60). Parfois la portée s'étend sur un fichier tout entier, par exemple un fichier appelé avec require ou le fichier contenant votre programme principal. D'autres fois la portée a l'étendue d'une chaîne évaluée avec eval. Mais en général, un bloc est entouré d'accolades ({}). Quand nous parlons de portée, cela signifie n'importe laquelle de ces trois possibilités. Quand nous voudrons dire un bloc entouré d'accolades, nous emploierons le terme BLOC.

Les instructions composées sont construites à partir d'expressions et de BLOC. Les expressions sont construites à partir de termes et d'opérateurs. Dans nos descriptions syntaxiques, nous utiliserons le mot EXPR pour indiquer un emplacement où vous pouvez utiliser n'importe quelle expression scalaire. Pour indiquer une expression évaluée en contexte de liste, nous dirons LISTE.

Les constructions suivantes peuvent être utilisées pour contrôler l'exécution de BLOC de façon conditionnelle ou répétée. (L'étiquette LABEL est optionnelle.)

if (EXPR) BLOC
if (EXPR) BLOC else BLOC
if (EXPR) BLOC elsif (EXPR) BLOC ...
if (EXPR) BLOC elsif (EXPR) BLOC ... else BLOC

unless (EXPR) BLOC
unless (EXPR) BLOC else BLOC
unless (EXPR) BLOC elsif (EXPR) BLOC ...
unless (EXPR) BLOC elsif (EXPR) BLOC ... else BLOC

LABEL while (EXPR) BLOC
LABEL while (EXPR) BLOC continue BLOC
LABEL until (EXPR) BLOC
LABEL until (EXPR) BLOC continue BLOC

LABEL for (EXPR; EXPR; EXPR) BLOC

LABEL foreach (LISTE) BLOC
LABEL foreach VAR (LISTE) BLOC
LABEL foreach VAR (LISTE) BLOC continue BLOC

LABEL BLOC
LABEL BLOC continue BLOC

Remarquez qu'à l'inverse de C et de Java, elles sont définies en termes de BLOC, et non d'instructions. Cela signifie que les accolades sont obligatoires ; les instructions isolées ne sont pas autorisées. Si vous voulez écrire des conditions sans accolades, il y a plusieurs manières de le faire. Les lignes suivantes font toutes la même chose :

unless (open(TOTO, $toto))      { die "Impossible d'ouvrir $toto: $!" }
if (!open(TOTO, $toto))         { die "Impossible d'ouvrir $toto: $!" }

die "Impossible d'ouvrir $toto: $!"     unless open(TOTO, $toto);
die "Impossible d'ouvrir $toto: $!"     if !open(TOTO, $toto);

open(TOTO, $toto)               || die "Impossible d'ouvrir $toto: $!";
open TOTO, $toto                or die "Impossible d'ouvrir $toto: $!";

Nous avons tendance à préférer les deux dernières dans la plupart des cas. Elles sont plus lisibles que les autres, en particulier la version « or die ». Avec || vous devez vous habituer à utiliser les parenthèses religieusement, tandis qu'avec la version or, ce n'est pas grave de les oublier.

Mais la principale raison pour laquelle nous préférons les dernières versions est qu'elles mettent la partie la plus importante de l'instruction au début de la ligne, là où vous la verrez le mieux. La gestion d'erreur est repoussée vers la droite, où vous n'avez pas besoin d'y faire attention, sauf si vous le voulez2. Et si vous tabulez tous vos tests « or die » à la même position à droite de chaque ligne, c'est encore plus facile à lire :

chdir $dir                  or die "chdir $dir: $!";
open TOTO, $fichier         or die "open $fichier: $!";
@lines = <TOTO>             or die "$fichier est vide ?";
close TOTO                  or die "close $fichier: $!";

L'instruction if est simple. Comme les BLOCs sont délimités par des accolades, il n'y jamais d'ambiguïté pour savoir à quel if en particulier un else ou un elsif est lié. Dans une séquence donnée de BLOCs if/elsif/else, seul le premier dont la condition est vraie est exécuté. Si aucune des conditions n'est vraie, alors le BLOC else, s'il existe, est exécuté. C'est en général une bonne idée de mettre un else à la fin d'une chaîne de elsif, afin de se prémunir contre un cas oublié.

Si vous utilisez unless à la place de if, le sens du test est inversé. C'est-à-dire que :

unless ($x == 1) ...

est équivalent à :

if ($x != 1) ...

ou au plus laid :

if (!($x == 1)) ...

La portée d'une variable déclarée dans la condition de contrôle s'étend de sa déclaration jusqu'à la fin de l'instruction conditionnelle, y compris tous les elsif et l'éventuelle clause else finale, mais pas plus loin :

if ((my $couleur = <STDIN>) =~ /rouge/i) {
    $valeur = 0xff0000;
}
elsif ($couleur =~ /vert/i) {
    $valeur = 0x00ff00;
}
elsif ($couleur =~ /bleu/i) {
    $valeur = 0x0000ff;
}
else {
    warn "`$couleur' : composante RGB inconnue, le noir est sélectionné\n";
    $valeur = 0x000000;
}

Après le else, la variable $couleur est hors de portée. Si vous voulez que sa portée s'étende plus loin, déclarez la variable plus tôt.

Dans leur syntaxe formelle, toutes les instructions de boucle comportent un LABEL (ou étiquette) facultatif. (Vous pouvez mettre une telle étiquette sur n'importe quelle instruction, mais cela a une signification spéciale pour les boucles.) S'il est présent, le label consiste en un identificateur suivi de deux-points. Il est courant d'écrire l'étiquette en majuscules pour éviter tout conflit avec des mots réservés et les faire mieux ressortir. Bien que Perl ne se pose pas de problème si vous utilisez un label qui a déjà une signification comme if ou open, vos lecteurs risquent de se tromper.

4-4-a. Instructions while et until▲

while (my $ligne = <STDIN>) {
    $ligne = lc $ligne;
}
continue {
    print $ligne;   # toujours visible
}
# $ligne maintenant hors de portée

4-4-b. Boucles for▲

LABEL:
  for (my $i = 1; $i <= 10; $i++) {
      ...
  }

{
    my $i = 1;
  LABEL:
    while ($i <= 10) {
        ...
    }
    continue {
        $i++;
    }
}

for ($i = 0, $bit = 0; $i < 32; $i++, $bit <<= 1) {
    print "Le bit $i is est à 1\n" if $mask & $bit;
}
# les valeurs de $i et $bit persistent après la boucle

for (my ($i, $bit) = (0, 1); $i < 32; $i++, $bit <<= 1) {
    print "Le bit $i is est à 1\n" if $mask & $bit;
}
# les $i et $bit de la boucle sont maintenant hors de portée

$sur_un_tty = -t STDIN && -t STDOUT;
sub prompt { print "yes? " if $sur_un_tty }
for ( prompt(); <STDIN>; prompt() ) {
    # fait quelque chose
}

for (;;) {
    ...
}

while (1) {
    ...
}

4-4-c. Boucles foreach▲

foreach VAR (LISTE) {
    ...
}

$somme = 0; foreach $valeur (@tableau) { $somme += $valeur }

for $decompte (10,9,8,7,6,5,4,3,2,1,'BOUM') {   # compte à rebours
    print "$decompte\n"; sleep(1);
}

for (reverse 'BOUM', 1 .. 10) {                 # pareil
    print "$_\n"; sleep(1);
}

for $champ (split /:/, $data) {                 # toute expression de LISTE
    print "Le champ contient : '$champ'\n";
}

foreach $cle (sort keys %hash) {
    print "$cle => $hash{$cle}\n";
}

foreach $paye (@salaires) {             # une augmentation de 8%
    $paye *= 1.08;
}

for (@noel, @paques) {                  # change le menu
    s/pâté/foie gras/;
}
s/pâté/foie gras/ for @noel, @paques;   # idem

for ($scalaire, @tableau, values %hash) {
    s/^\s+//;                           # retire les espaces initiaux
    s/\s+$//;                           # retire les espaces finaux
}

for my  $i    (1 .. 10) { ... }       # $i toujours lexicale
for our $Tick (1 .. 10) { ... }       # $Tick toujours globale

for ($i = 0; $i < @tab1; $i++) {
    for ($j = 0; $j < @tab2; $j++) {
        if ($tab1[$i] > $tab2[$j]) {
            last; # Impossible d'aller à la boucle externe. :-(
        }
        $tab1[$i] += $tab2[$j];
    }
    # voici où ce last m'emmène
}

WID: foreach $ceci (@tab1) {
    JET: foreach $cela (@tab2) {
        next WID if $ceci > $cela;
        $ceci += $cela;
    }
}

4-4-d. Contrôle de boucle▲

next LIGNE if /^#/; # supprime les commentaires

last LABEL
next LABEL
redo LABEL

LIGNE: while (<STDIN>) {
    last LIGNE if /^$/;       # sort quand l'entête de mail est fini
    ...
}

LIGNE: while (<STDIN>) {
    next LIGNE if /^#/;     # ignore les commentaires
    next LIGNE if /^$/;     # ignore les lignes blanches
    ...
} continue {
    $compte++;
}

while (<>) {
    chomp;
    if (s/\\$//) {
        $_ .= <>;
        redo unless eof; # ne pas lire au-delà de la fin de chaque fichier
    }
    # traitement de $_
}

LIGNE: while (defined($ligne = <ARGV>)) {
    chomp($ligne);
    if ($ligne =~ s/\\$//) {
        $ligne .= <ARGV>;
        redo LIGNE unless eof(ARGV);
    }
    # traitement de $ligne
}

ARG: while (@ARGV && $ARGV[0] =~ s/^-(?=.)//) {
    OPT: for (shift @ARGV) {
        m/^$/       && do {                             next ARG; };
        m/^-$/      && do {                             last ARG; };
        s/^d//      && do { $Niveau_Debug++;            redo OPT; };
        s/^l//      && do { $Genere_Listing++;          redo OPT; };
        s/^i(.*)//  && do { $Sur_Place = $1 || ".bak";  next ARG; };
        say_usage("Option inconnue : $_");
    }
}

open FICHIER, $fichier
    or warn "Impossible d'ouvrir $fichier : $!\n", next FICHIER; # FAUX

open FICHIER, $fichier
    or warn("Impossible d'ouvrir $fichier : $!\n"), next FICHIER; # Correct

unless (open FICHIER, $fichier) {
    warn "Impossible d'ouvrir $fichier: $!\n";
    next FICHIER;
}

Un BLOC (étiqueté ou non) est en soi l'équivalent sémantique d'une boucle qui s'exécute une seule fois. C'est pourquoi vous pouvez utiliser last pour quitter un bloc ou redo pour relancer le bloc.(63) Remarquez que ceci n'est pas le cas des blocs à l'intérieur d'eval {}, de sub {} ou, ce qui en étonne beaucoup, de do {}. En effet, ce ne sont pas des blocs de boucle, car ce ne sont pas des blocs par eux-mêmes. Le mot-clef qui les précède fait d'eux les termes d'expressions qui se trouvent contenir un bloc de code. N'étant pas des blocs de boucle, ils ne peuvent être étiquetés et les contrôles de boucle ne s'y appliquent pas. Les contrôles de boucle ne s'appliquent qu'aux véritables boucles, tout comme return ne s'utilise que dans un sous-programme (ou un eval).

Les contrôles de boucle ne marchent pas non plus avec un if ou un unless, puisque ce ne sont pas des boucles. Mais vous pouvez toujours ajouter une paire d'accolades supplémentaires pour construire un bloc simple qui lui est une boucle :

if (/pattern/) {{
    last if /alpha/;
    last if /beta/;
    last if /gamma/;
    # ne fait quelque chose que si on se trouve encore dans le if()
}}

Voici comment utiliser un bloc pour faire fonctionner les opérateurs de contrôle de boucle avec une construction do {}. Pour faire un next ou un redo sur un do, ajouter un bloc simple à l'intérieur :