perlsyn - En ligne dans le cloud

PROGRAMME:

Nom

perlsyn - Syntaxe Perl

DESCRIPTION

Un programme Perl consiste en une séquence de déclarations et d'instructions qui s'exécutent à partir du
de haut en bas. Les boucles, sous-programmes et autres structures de contrôle vous permettent de sauter
autour dans le code.

Perl est un de forme libre langue : vous pouvez le formater et le mettre en retrait comme bon vous semble. Espaces
sert principalement à séparer les jetons, contrairement aux langages comme Python où il s'agit d'un élément important
partie de la syntaxe, ou Fortran là où cela n'a pas d'importance.

De nombreux éléments syntaxiques de Perl sont facultatif. Plutôt que de vous obliger à mettre
parenthèses autour de chaque appel de fonction et déclarer chaque variable, vous pouvez souvent laisser
ces éléments explicites et Perl comprendra ce que vous vouliez dire. C'est ce qu'on appelle Do
Ce que I Médian, abrégé DWIM. Il permet aux programmeurs d'être paresseux et coder dans un style
avec lequel ils sont à l'aise.

Perl emprunte syntaxe et des concepts issus de nombreux langages : awk, sed, C, Bourne Shell,
Smalltalk, Lisp et même l'anglais. D'autres langages ont emprunté la syntaxe à Perl,
en particulier ses extensions d'expressions régulières. Donc si vous avez programmé dans un autre
langage, vous verrez des morceaux familiers en Perl. Ils fonctionnent souvent de la même manière, mais voir perltrap
pour plus d’informations sur leurs différences.

Déclarations
Les seules choses que vous devez déclarer en Perl sont les formats de rapport et les sous-programmes (et
parfois même pas de sous-programmes). Une variable scalaire contient la valeur non définie ("undef")
jusqu'à ce qu'on lui ait attribué une valeur définie, qui est autre chose que "undef". Quand
utilisé comme nombre, "undef" est traité comme 0 ; lorsqu'il est utilisé comme chaîne, il est traité comme le
chaîne vide, ""; et lorsqu'elle est utilisée comme référence à laquelle elle n'est pas attribuée, elle est traitée
comme une erreur. Si vous activez les avertissements, vous serez averti d'une valeur non initialisée
chaque fois que vous traitez "undef" comme une chaîne ou un nombre. Eh bien, généralement. Contextes booléens,
telles que:

si ($a) {}

sont exemptés d'avertissements (parce qu'ils se soucient de la vérité plutôt que de la définition).
Opérateurs tels que "++", "--", "+=", "-=" et ".=", qui opèrent sur des variables non définies
telles que:

undef $a;
$a++ ;

sont également toujours exemptés de tels avertissements.

Une déclaration peut être placée n'importe où, mais n'a aucun effet sur l'exécution de
la séquence principale d'instructions : les déclarations prennent toutes effet au moment de la compilation. Tous
les déclarations sont généralement placées au début ou à la fin du script. Toutefois, si
vous utilisez des variables privées de portée lexicale créées avec "my()", "state()" ou
"notre()", vous devrez vous assurer que votre format ou votre définition de sous-programme est identique
bloquez la portée comme my si vous prévoyez de pouvoir accéder à ces variables privées.

Déclarer un sous-programme permet d'utiliser un nom de sous-programme comme s'il s'agissait d'un opérateur de liste
à partir de ce moment-là dans le programme. Vous pouvez déclarer un sous-programme sans le définir
en disant "sous-nom", donc :

sous mon nom ;
$me = monnom $0 ou mourir "je ne peux pas obtenir mon nom" ;

Une simple déclaration comme celle-ci déclare que la fonction est un opérateur de liste, pas unaire
opérateur, il faut donc faire attention à utiliser des parenthèses (ou "ou" au lieu de "||".)
"||" l'opérateur est trop étroitement lié pour être utilisé après les opérateurs de liste ; ça fait partie du dernier
élément. Vous pouvez toujours utiliser des parenthèses autour des arguments des opérateurs de liste pour inverser la tendance.
lister l'opérateur en quelque chose qui se comporte davantage comme un appel de fonction. Alternativement,
vous pouvez utiliser le prototype "($)" pour transformer le sous-programme en opérateur unaire :

sous mon nom ($);
$moi = monnom $0 || mourir "je ne peux pas obtenir mon nom" ;

Cela s'analyse maintenant comme vous vous en doutez, mais vous devez quand même prendre l'habitude d'utiliser
parenthèses dans cette situation. Pour en savoir plus sur les prototypes, voir perlsub.

Les déclarations de sous-programmes peuvent également être chargées avec l'instruction "require" ou les deux chargées
et importé dans votre espace de noms avec une instruction "use". Voir perlmod pour plus de détails à ce sujet.

Une séquence d'instructions peut contenir des déclarations de variables de portée lexicale, mais à part
En déclarant un nom de variable, la déclaration agit comme une instruction ordinaire et est
élaboré dans la séquence d’énoncés comme s’il s’agissait d’un énoncé ordinaire. Que
signifie qu'il a en fait des effets à la compilation et à l'exécution.

Description
Le texte à partir du caractère "#" jusqu'à la fin de la ligne est un commentaire et est ignoré.
Les exceptions incluent "#" à l'intérieur d'une chaîne ou d'une expression régulière.

Simple Déclarations
Le seul type d’énoncé simple est une expression évaluée pour ses effets secondaires. Chaque
une instruction simple doit être terminée par un point-virgule, à moins qu'il ne s'agisse de l'instruction finale de
un bloc, auquel cas le point-virgule est facultatif. Mais mettez quand même le point-virgule si le
block occupe plus d’une ligne, car vous pouvez éventuellement en ajouter une autre. Noter que
il existe des opérateurs comme "eval {}", "sub {}" et "do {}" qui du dernier comme composé
déclarations, mais ne le sont pas - ce ne sont que des TERMES dans une expression - et ont donc besoin d'un explicite
terminaison lorsqu'elle est utilisée comme dernier élément d'une instruction.

Vérité et votre Mensonge
Le chiffre 0, les chaînes '0' et "", la liste vide "()" et "undef" sont tous faux dans un
contexte booléen. Toutes les autres valeurs sont vraies. Négation d'une vraie valeur par "!" ou non"
renvoie une fausse valeur spéciale. Lorsqu'il est évalué comme une chaîne, il est traité comme "", mais comme un
nombre, il est traité comme 0. La plupart des opérateurs Perl qui renvoient vrai ou faux se comportent de cette manière
façon.

Déclaration Modificateurs
Toute déclaration simple peut éventuellement être suivie d'un UNIQUE modificateur, juste avant le
point-virgule final (ou fin de bloc). Les modificateurs possibles sont :

si EXPR
sauf EXPR
tandis que EXPR
jusqu'à EXPR
pour la LISTE
LISTE foreach
quand EXPR

Le « EXPR » qui suit le modificateur est appelé « condition ». Sa vérité ou
le mensonge détermine le comportement du modificateur.

"if" exécute l'instruction une fois if et seulement si la condition est vraie. "à moins que" soit le
ci-contre, il exécute l'instruction à moins que la condition est vraie (c'est-à-dire si le
la condition est fausse).

imprimer "Les bassets ont de longues oreilles" si longueur $ear >= 10 ;
go_outside() et play() sauf si $is_raining ;

Le modificateur "for(each)" est un itérateur : il exécute l'instruction une fois pour chaque élément de
la LISTE (avec $_ alias pour chaque élément à tour de rôle).

imprimer "Bonjour $_!\n" pour qw (infirmière mondiale Dolly) ;

"pendant" répète la déclaration tout en la condition est vraie. "jusqu'à" fait le contraire, c'est
répète la déclaration jusqu'au la condition est vraie (ou alors que la condition est fausse) :

# Ces deux éléments comptent de 0 à 10.
imprimer $i++ tandis que $i <= 10 ;
imprimer $j++ jusqu'à $j > 10 ;

Les modificateurs « while » et « jusqu'à » ont la sémantique habituelle de la « boucle while » (conditionnelle
évalué en premier), sauf lorsqu'il est appliqué à un BLOC "do" (ou au "do"-SUBROUTINE Perl4
instruction), auquel cas le bloc s’exécute une fois avant que la condition ne soit évaluée.

C'est pour que vous puissiez écrire des boucles comme :

faire {
$ligne = ;

} jusqu'à !défini($line) || $line eq ".\n"

Voir "faire" dans perlfunc. Notez également que les instructions de contrôle de boucle décrites plus loin ne pas
fonctionne dans cette construction, car les modificateurs ne prennent pas d'étiquettes de boucle. Désolé. Tu peux toujours
placez un autre bloc à l'intérieur (pour "suivant") ou autour (pour "dernier") pour faire ce genre de
chose. Pour "suivant", doublez simplement les accolades :

faire {{
suivant si $x == $y ;
# fais quelque chose ici
}} jusqu'à $x++ > $z ;

Pour "dernier", il faut être plus élaboré :

BOUCLE: {
faire {
dernier si $x = $y**2 ;
# fais quelque chose ici
} tandis que $x++ <= $z;
}

NOTE: Le comportement d'un "mon", "état" ou "notre" modifié avec un modificateur d'instruction
une construction conditionnelle ou en boucle (par exemple, "mon $x si ...") est indéfini. La valeur de
la variable "ma" peut être "undef", n'importe quelle valeur précédemment assignée, ou éventuellement n'importe quoi
autre. Ne comptez pas là-dessus. Les futures versions de Perl pourraient faire quelque chose de différent de
version de Perl sur laquelle vous l'essayez. Voilà des dragons.

Le modificateur « quand » est une fonctionnalité expérimentale apparue pour la première fois dans Perl 5.14. Utiliser
cela, vous devez inclure une déclaration "use v5.14". (Techniquement, cela nécessite uniquement le
fonctionnalité "switch", mais cet aspect n'était pas disponible avant la version 5.14.) Opérationnel uniquement
à partir d'une boucle "foreach" ou d'un bloc "donné", il exécute l'instruction uniquement si le
correspondance intelligente "$_ ~~ EXPR" est vrai. Si l'instruction s'exécute, elle est suivie d'un "suivant"
de l'intérieur d'un "foreach" et "break" de l'intérieur d'un "donné".

Dans l'implémentation actuelle, la boucle "foreach" peut se trouver n'importe où dans le "quand"
portée dynamique du modificateur, mais doit être dans la portée lexicale du bloc "donné". Ce
la restriction pourrait être assouplie dans une version ultérieure. Voir « Instructions Switch » ci-dessous.

Composant Déclarations
En Perl, une séquence d'instructions qui définit une portée est appelée un bloc. Parfois un
le bloc est délimité par le fichier qui le contient (dans le cas d'un fichier obligatoire, ou par le
programme dans son ensemble), et parfois un bloc est délimité par l'étendue d'une chaîne (dans le
cas d'une évaluation).

Mais généralement, un bloc est délimité par des accolades, également appelées accolades. Nous appellerons
cette syntaxe construit un BLOC.

Les instructions composées suivantes peuvent être utilisées pour contrôler le flux :

si (EXPR) BLOC
si (EXPR) BLOC sinon BLOC
if (EXPR) BLOC elsif (EXPR) BLOC ...
if (EXPR) BLOC elsif (EXPR) BLOC ... sinon BLOC

sauf si (EXPR) BLOQUE
sauf si (EXPR) BLOC sinon BLOC
à moins que (EXPR) BLOC elsif (EXPR) BLOC ...
sauf si (EXPR) BLOC elsif (EXPR) BLOC ... sinon BLOC

donné (EXPR) BLOC

ÉTIQUETTE pendant que (EXPR) BLOQUE
ÉTIQUETTE pendant que (EXPR) BLOC continue BLOC

ÉTIQUETTE jusqu'à (EXPR) BLOC
ÉTIQUETTE jusqu'à ce que (EXPR) BLOC continue BLOC

ÉTIQUETTE pour le BLOC (EXPR ; EXPR ; EXPR)
ÉTIQUETTE pour le BLOC VAR (LISTE)
ÉTIQUETTE pour VAR (LISTE) BLOC continuer BLOC

ÉTIQUETTE pour chaque (EXPR ; EXPR ; EXPR) BLOC
ÉTIQUETTE pour chaque BLOC VAR (LISTE)
ÉTIQUETTE pour chaque VAR (LISTE) BLOC continuer BLOC

BLOC D'ÉTIQUETTE
ÉTIQUETTE BLOC continuer BLOC

BLOC DE PHASES

L'énoncé expérimental « donné » est pas automatiquement activé; voir "Instructions Switch"
ci-dessous pour savoir comment procéder et les mises en garde qui en découlent.

Contrairement à C et Pascal, en Perl, ils sont tous définis en termes de BLOCS et non d'instructions.
Cela signifie que les accolades sont conditions--aucune déclaration pendante n'est autorisée. Si tu
souhaitez écrire des conditions sans accolades, il existe plusieurs autres façons de le faire.
Les éléments suivants font tous la même chose :

if (!open(FOO)) { die "Impossible d'ouvrir $FOO : $!" }
die "Impossible d'ouvrir $FOO : $!" sauf si ouvert(FOO);
ouvert(FOO) || die "Impossible d'ouvrir $FOO: $!";
ouvert(FOO) ? () : die "Impossible d'ouvrir $FOO : $!";
# un peu exotique, ce dernier

L'instruction « si » est simple. Parce que les BLOCS sont toujours délimités par des boucles bouclées
entre parenthèses, il n'y a jamais d'ambiguïté quant à savoir avec quel "si" un "sinon" va avec. Si tu utilises
"sauf si" à la place de "si", le sens du test est inversé. Comme "si", "à moins que" peut être
suivi de "autre". "sauf si" peut même être suivi d'une ou plusieurs instructions "elsif",
bien que vous souhaitiez peut-être y réfléchir à deux fois avant d'utiliser cette construction de langage particulière, car
tous ceux qui liront votre code devront réfléchir au moins à deux fois avant de pouvoir comprendre
Que se passe-t-il.

L'instruction "while" exécute le bloc tant que l'expression est vraie. Le "jusqu'à"
L'instruction exécute le bloc tant que l'expression est fausse. Le LABEL est facultatif,
et s'il est présent, se compose d'un identifiant suivi de deux points. L'ÉTIQUETTE identifie le
boucle pour les instructions de contrôle de boucle "next", "last" et "redo". Si le LABEL est omis,
l'instruction de contrôle de boucle fait référence à la boucle englobante la plus interne. Cela peut inclure
examiner dynamiquement votre pile d'appels au moment de l'exécution pour trouver le LABEL. Tellement désespéré
le comportement déclenche un avertissement si vous utilisez le pragma « utiliser les avertissements » ou le -w drapeau.

S'il y a un BLOC "continuer", il est toujours exécuté juste avant que le conditionnel soit sur le point d'être exécuté.
à réévaluer. Ainsi, il peut être utilisé pour incrémenter une variable de boucle, même lorsque la
la boucle a été poursuivie via l'instruction "next".

Lorsqu'un bloc est précédé d'un mot clé de phase de compilation tel que "BEGIN", "END", "INIT",
"CHECK", ou "UNITCHECK", alors le bloc ne s'exécutera que pendant la phase correspondante de
exécution. Voir perlmod pour plus de détails.

Les modules d'extension peuvent également se connecter à l'analyseur Perl pour définir de nouveaux types de composés.
déclarations. Ceux-ci sont introduits par un mot-clé que l'extension reconnaît, et le
la syntaxe suivant le mot-clé est entièrement définie par l'extension. Si vous êtes un
implémenteur, voir "PL_keyword_plugin" dans perlapi pour le mécanisme. Si vous utilisez un tel
un module, consultez la documentation du module pour plus de détails sur la syntaxe qu'il définit.

boucle Contrôle
La commande "next" démarre la prochaine itération de la boucle :

LIGNE : tandis que ( ) {
LIGNE suivante si /^#/; # supprimer les commentaires

}

La "dernière" commande sort immédiatement de la boucle en question. Le bloc "continuer", le cas échéant,
n'est pas exécuté :

LIGNE : tandis que ( ) {
dernière LIGNE si /^$/; # sortie lorsque vous avez terminé avec l'en-tête

}

La commande "redo" redémarre le bloc de boucle sans réévaluer le conditionnel. Le
Le bloc "continuer", le cas échéant, est pas réalisé. Cette commande est normalement utilisée par les programmes qui
veulent se mentir sur ce qui vient d'être entré.

Par exemple, lors du traitement d'un fichier comme /etc/termcap. Si vos lignes de saisie peuvent se terminer par
des barres obliques inverses pour indiquer la suite, vous souhaitez avancer et obtenir l'enregistrement suivant.

tandis que (<>) {
mâcher;
si (s/\\$//) {
$_ .= <>;
refaire sauf si eof();
}
# traite maintenant $_
}

qui est un raccourci Perl pour la version écrite plus explicitement :

LIGNE : while (défini($line = )) {
chomp($ligne);
si ($ligne =~ s/\\$//) {
$ligne .= ;
refaire LINE sauf si eof(); # pas eof(ARGV) !
}
# traite maintenant $line
}

Notez que s'il y avait un bloc "continuer" sur le code ci-dessus, il ne serait exécuté que
sur les lignes supprimées par l'expression régulière (puisque refaire ignore le bloc continuer). Un bloc continuer
est souvent utilisé pour réinitialiser les compteurs de lignes ou "m?pat?" matchs ponctuels :

# inspiré par :1,$g/fred/s//WILMA/
tandis que (<>) {
m?(fred) ? && s//WILMA 1 $ WILMA/;
m?(Barney) ? && s//BETTY $1 BETTY/;
m?(Homère) ? && s//MARGE $1 MARGE/;
} Continuez {
imprimer "$ARGV $. : $_" ;
fermer ARGV si eof ; # réinitialiser $.
réinitialiser si eof ; # réinitialiser ?pat?
}

Si le mot « pendant » est remplacé par le mot « jusqu'à », le sens du test est inversé,
mais le conditionnel est toujours testé avant la première itération.

Les instructions de contrôle de boucle ne fonctionnent pas dans un « si » ou un « sauf », car ce ne sont pas des boucles. Toi
Cependant, vous pouvez doubler les accolades pour les rendre telles.

si (/modèle/) {{
dernier si /fred/;
suivant si /barney/; # même effet que "dernier",
# mais ne documente pas aussi bien
# fais quelque chose ici
}}

Ceci est dû au fait qu'un bloc agit en lui-même comme une boucle qui s'exécute une seule fois, voir
"BLOCS de base".

La forme "while/if BLOC BLOC", disponible en Perl 4, n'est plus disponible. Remplacer
toute occurrence de "if BLOCK" par "if (do BLOCK)".

Pour Boucles
La boucle "for" de style C de Perl fonctionne comme la boucle "while" correspondante ; ça veut dire que ceci :

pour ($i = 1; $i < 10; $i++) {

}

c'est la même chose que ça :

$ i = 1;
tandis que ($i < 10) {

} Continuez {
$ i ++;
}

Il y a une différence mineure : si les variables sont déclarées avec "my" lors de l'initialisation
section du "for", la portée lexicale de ces variables est exactement la boucle "for" (la
corps de la boucle et les sections de contrôle).

Comme cas particulier, si le test dans la boucle "for" (ou la boucle "while" correspondante) est
vide, il est traité comme vrai. C'est-à-dire les deux

pour (;;) {

}

et votre

tandis que () {

}

sont traités comme des boucles infinies.

Outre la boucle normale d'index de tableau, "for" peut se prêter à de nombreuses autres fonctions intéressantes.
applications. En voici un qui évite le problème que vous rencontrez si vous testez explicitement
fin de fichier sur un descripteur de fichier interactif provoquant le blocage de votre programme.

$on_a_tty = -t STDIN && -t STDOUT;
sous-invite { print "oui?" if $on_a_tty }
pour ( invite(); ; invite() ) {
# faire quelque chose
}

Utiliser "readline" (ou la forme d'opérateur, "") comme conditionnel d'une boucle "for" est
raccourci pour ce qui suit. Ce comportement est le même qu'une boucle conditionnelle « while ».

pour ( prompt(); défini( $_ = ); prompt() ) {
# faire quelque chose
}

Pour chaque Boucles
La boucle "foreach" parcourt une valeur de liste normale et définit la variable scalaire VAR sur
être chaque élément de la liste à tour de rôle. Si la variable est précédée du mot clé "my",
il est alors de portée lexicale et n'est donc visible que dans la boucle. Sinon,
la variable est implicitement locale à la boucle et retrouve son ancienne valeur à la sortie de la boucle.
boucle. Si la variable a été précédemment déclarée avec "my", elle utilise cette variable au lieu de
le global, mais il est toujours localisé dans la boucle. Cette localisation implicite se produit
uniquement dans une boucle "foreach".

Le mot-clé « foreach » est en fait un synonyme du mot-clé « for », vous pouvez donc utiliser l'un ou l'autre.
Si VAR est omis, $_ est défini sur chaque valeur.

Si un élément de LIST est une lvalue, vous pouvez le modifier en modifiant VAR à l'intérieur de la boucle.
À l’inverse, si un élément de LIST n’est PAS une lvalue, toute tentative de modification de cet élément
échouera. En d'autres termes, la variable d'index de boucle "foreach" est un alias implicite pour
chaque élément de la liste sur lequel vous effectuez une boucle.

Si une partie de LIST est un tableau, "foreach" deviendra très confus si vous ajoutez ou supprimez
éléments dans le corps de la boucle, par exemple avec "splice". Alors ne fais pas ça.

"foreach" ne fera probablement pas ce que vous attendez si VAR est une variable liée ou autre variable spéciale.
Ne faites pas ça non plus.

Depuis Perl 5.22, il existe une variante expérimentale de cette boucle qui accepte une variable
précédé d'une barre oblique inverse pour VAR, auquel cas les éléments de la LISTE doivent être des références.
La variable avec barre oblique inverse deviendra un alias pour chaque élément référencé dans la LISTE, ce qui
doit être du bon type. La variable n'a pas besoin d'être un scalaire dans ce cas, et le
La barre oblique inverse peut être suivie de « mon ». Pour utiliser ce formulaire, vous devez activer le "refaliasing"
fonctionnalité via "utiliser la fonctionnalité". (Voir fonctionnalité. Voir aussi « Affectation à des références » dans perlref.)

Exemples :

pour (@ary) { s/foo/bar/ }

pour mon $elem (@elements) {
$elem *= 2;
}

pour $count (inverse(1..10), "BOOM") {
print $count, "\n" ;
sleep(1);
}

for (1..15) { print "Joyeux Noël\n"; }

foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
print "Article : $item\n" ;
}

utiliser la fonctionnalité « refaliasing » ;
aucun avertissement "experimental::refaliasing" ;
foreach \mon %hash (@array_of_hash_references) {
# faire quelque chose que chaque %hash
}

Voici comment un programmeur C peut coder un algorithme particulier en Perl :

pour (mon $i = 0; $i < @ary1; $i++) {
pour (mon $j = 0; $j < @ary2; $j++) {
si ($ary1[$i] > $ary2[$j]) {
dernier; # Je ne peux pas aller à l'extérieur :-(
}
$ary1[$i] += $ary2[$j];
}
# c'est là que ce dernier m'emmène
}

Alors que voici comment un programmeur Perl plus à l'aise avec l'idiome pourrait procéder :

EXTERNE : pour mon $wid (@ary1) {
INTÉRIEUR : pour mon $jet (@ary2) {
suivant OUTER si $wid > $jet ;
$wid += $jet ;
}
}

Vous voyez à quel point c'est plus facile ? C'est plus propre, plus sûr et plus rapide. C'est plus propre parce que c'est
moins bruyant. C'est plus sûr car si du code est ajouté plus tard entre les boucles interne et externe
activé, le nouveau code ne sera pas exécuté accidentellement. Le "suivant" itère explicitement l'autre
boucle plutôt que de simplement terminer la boucle interne. Et c'est plus rapide car Perl exécute
une instruction "foreach" plus rapidement que la boucle "for" équivalente.

Les pirates Perl perspicaces ont peut-être remarqué qu'une boucle "for" a une valeur de retour, et que
cette valeur peut être capturée en enveloppant la boucle dans un bloc "do". La récompense pour cela
découverte est ce conseil d'avertissement : la valeur de retour d'une boucle "for" n'est pas spécifiée et
peut changer sans préavis. Ne vous y fiez pas.

Basic BLOCS
Un BLOC en lui-même (étiqueté ou non) est sémantiquement équivalent à une boucle qui exécute
une fois. Ainsi, vous pouvez utiliser n'importe quelle instruction de contrôle de boucle pour quitter ou redémarrer le
bloc. (Notez que c'est ne pas vrai dans "eval{}", "sub{}", ou contrairement à la croyance populaire
Les blocs "do{}", qui font ne pas comptent comme des boucles.) Le bloc "continue" est facultatif.

La construction BLOCK peut être utilisée pour émuler des structures de cas.

CHANGER: {
si (/^abc/) { $abc = 1; dernier COMMUTATEUR ; }
si (/^def/) { $def = 1; dernier COMMUTATEUR ; }
si (/^xyz/) { $xyz = 1; dernier COMMUTATEUR ; }
$rien = 1 ;
}

Vous trouverez également cette boucle "foreach" utilisée pour créer un topique et un commutateur :

CHANGER:
pour ($var) {
si (/^abc/) { $abc = 1; dernier COMMUTATEUR ; }
si (/^def/) { $def = 1; dernier COMMUTATEUR ; }
si (/^xyz/) { $xyz = 1; dernier COMMUTATEUR ; }
$rien = 1 ;
}

De telles constructions sont assez fréquemment utilisées, à la fois parce que les anciennes versions de Perl n'avaient pas
déclaration officielle "switch", et aussi parce que la nouvelle version décrite immédiatement ci-dessous
reste expérimental et peut parfois prêter à confusion.

Basculer Déclarations
À partir de Perl 5.10.1 (enfin, 5.10.0, mais ça n'a pas fonctionné correctement), vous pouvez dire

utiliser la fonctionnalité « commutateur » ;

pour activer une fonctionnalité de commutation expérimentale. Ceci est vaguement basé sur une ancienne version d'un
Proposition Perl 6, mais elle ne ressemble plus à la construction Perl 6. Vous bénéficiez également du
changer de fonctionnalité chaque fois que vous déclarez que votre code préfère s'exécuter sous une version de Perl
c'est 5.10 ou version ultérieure. Par exemple:

utiliser la v5.14 ;

Grâce à la fonctionnalité "switch", Perl obtient les mots-clés expérimentaux "given", "when",
"par défaut", "continuer" et "pause". À partir de Perl 5.16, on peut préfixer le commutateur
mots-clés avec "CORE ::" pour accéder à la fonctionnalité sans instruction "use feature". Le
les mots-clés « donné » et « quand » sont analogues à « changer » et « cas » dans d'autres langues, donc
le code de la section précédente pourrait être réécrit comme

utiliser la v5.10.1 ;
pour ($var) {
quand (/^abc/) { $abc = 1 }
quand (/^def/) { $def = 1 }
quand (/^xyz/) { $xyz = 1 }
par défaut { $rien = 1 }
}

Le "foreach" est la manière non expérimentale de définir un topique. Si vous souhaitez utiliser le
"donné" très expérimental, qui pourrait s'écrire ainsi :

utiliser la v5.10.1 ;
donné ($var) {
quand (/^abc/) { $abc = 1 }
quand (/^def/) { $def = 1 }
quand (/^xyz/) { $xyz = 1 }
par défaut { $rien = 1 }
}

Depuis la version 5.14, cela peut également s'écrire de cette façon :

utiliser la v5.14 ;
pour ($var) {
$abc = 1 quand /^abc/;
$def = 1 quand /^def/;
$xyz = 1 quand /^xyz/;
par défaut { $rien = 1 }
}

Ou si vous ne voulez pas jouer la sécurité, comme ceci :

utiliser la v5.14 ;
donné ($var) {
$abc = 1 quand /^abc/;
$def = 1 quand /^def/;
$xyz = 1 quand /^xyz/;
par défaut { $rien = 1 }
}

Les arguments de "donné" et "quand" sont dans un contexte scalaire, et "donné" attribue le $_
variable sa valeur de sujet.

Exactement ce que le EXPR L’argument du « quand » se produit est difficile à décrire avec précision, mais en
en général, il essaie de deviner ce que vous voulez faire. Parfois, il est interprété comme "$_ ~~
EXPR", et parfois ce n'est pas le cas. Il se comporte également différemment lorsqu'il est entouré lexicalement d'un
bloc "donné" que lorsqu'il est entouré dynamiquement par une boucle "foreach". Les règles sont
beaucoup trop difficile à comprendre pour être décrit ici. Voir « Détails expérimentaux sur des données
et quand" plus tard.

En raison d'un bug malheureux dans la façon dont "donné" a été implémenté entre Perl 5.10 et 5.16, sous
ces implémentations, la version de $_ régie par "donné" est simplement une portée lexicale
copie de l'original, et non un alias à portée dynamique vers l'original, comme ce serait le cas s'il
étaient un "foreach" ou sous la spécification originale et actuelle du langage Perl 6.
Ce bug a été corrigé dans Perl 5.18. Si vous voulez vraiment un $_ lexical, précisez que
explicitement, mais notez que "my $_" est désormais obsolète et avertira à moins que des avertissements n'aient été émis.
été désactivé :

étant donné (mon $_ = EXPR) { ... }

Si votre code doit encore s'exécuter sur des versions plus anciennes, restez sur "foreach" pour votre topique.
et tu seras moins malheureux.

Aller à
Bien que ce ne soit pas pour les âmes sensibles, Perl prend en charge une instruction « goto ». Il y a
trois formes : "goto"-LABEL, "goto"-EXPR et "goto"-&NAME. Le LABEL d’une boucle n’est pas réellement
une cible valide pour un « goto » ; c'est juste le nom de la boucle.

Le formulaire "goto"-LABEL trouve l'instruction étiquetée par LABEL et y reprend l'exécution.
Il ne peut pas être utilisé pour accéder à une construction nécessitant une initialisation, telle qu'un
sous-programme ou une boucle "foreach". Il ne peut pas non plus être utilisé pour entrer dans une construction qui est
optimisé. Il peut être utilisé pour aller presque partout ailleurs dans la portée dynamique,
y compris en dehors des sous-programmes, mais il est généralement préférable d'utiliser une autre construction telle que
"dernier" ou "mourir". L'auteur de Perl n'a jamais ressenti le besoin d'utiliser cette forme de "goto"
(en Perl, c'est le cas - C est une autre affaire).

La forme "goto"-EXPR attend un nom d'étiquette, dont la portée sera résolue dynamiquement. Ce
permet les "goto" calculés par FORTRAN, mais n'est pas nécessairement recommandé si vous êtes
optimisation pour la maintenabilité :

goto(("FOO", "BAR", "GLARCH")[$i]);

La forme "goto"-&NAME est hautement magique et remplace un appel au sous-programme nommé
pour le sous-programme en cours d'exécution. Ceci est utilisé par les sous-programmes "AUTOLOAD()" qui souhaitent
pour charger un autre sous-programme et ensuite faire comme si l'autre sous-programme avait été appelé
en premier lieu (sauf que toute modification de @_ dans le sous-programme actuel est
propagé à l'autre sous-programme.) Après le "goto", même "caller()" ne pourra pas
pour dire que cette routine a été appelée en premier.

Dans presque tous les cas comme celui-ci, c'est généralement une bien meilleure idée d'utiliser le format structuré
contrôlez les mécanismes de flux de « suivant », « dernier » ou « refaire » au lieu de recourir à un « aller à ».
Pour certaines applications, la paire catch et throw de "eval{}" et mourir() par exception
le traitement peut également être une approche prudente.

Notre Ellipse Déclaration
Depuis Perl 5.12, Perl accepte les points de suspension, ""...", comme espace réservé pour le code qui
vous n'avez pas encore implémenté. Cette forme de points de suspension, la déclaration non appliquée, devrait
ne pas être confondu avec l'opérateur de bascule binaire "...". L'une est une déclaration et la
autre un opérateur. (Perl ne les confond généralement pas car généralement Perl peut dire
s'il veut un opérateur ou une instruction, mais voir ci-dessous pour les exceptions.)

Lorsque Perl 5.12 ou version ultérieure rencontre une instruction points de suspension, il l'analyse sans erreur,
mais si et quand vous devez réellement essayer de l'exécuter, Perl lève une exception avec le
texte "Non implémenté":

utiliser la v5.12 ;
sous non implémenté { ... }
eval {non implémenté() };
if ($@ =~ /^Non implémenté à /) {
dites « J'ai trouvé des points de suspension ! » ;
}

Vous ne pouvez utiliser l’instruction elliptique que pour remplacer une instruction complète. Ces
exemples du fonctionnement des points de suspension :

utiliser la v5.12 ;
{ ... }
sous foo { ... }
...;
eval { ... } ;
sous quelque chose {
mon $self = shift;
...;
}
$x = faire {
mon $n;
...;
dites « Hourra ! » ;
$n ;
};

L’énoncé elliptique ne peut pas remplacer une expression faisant partie d’un ensemble plus vaste.
puisque le "..." est également la version à trois points de l'opérateur de bascule (voir
"Opérateurs de gamme" en perlop).

Ces exemples de tentatives d'utilisation de points de suspension sont des erreurs de syntaxe :

utiliser la v5.12 ;

imprimer ...;
open(mon $fh, ">", "/dev/passwd") ou ... ;
if ($condition && ... ) { say "Howdy" };

Il existe des cas où Perl ne peut pas immédiatement faire la différence entre un
expression et une déclaration. Par exemple, la syntaxe d'un bloc et d'un hachage anonyme
Le constructeur de référence a la même apparence à moins qu'il n'y ait quelque chose dans les accolades pour donner à Perl un
indice. Les points de suspension sont une erreur de syntaxe si Perl ne devine pas que le "{ ... }" est un bloc.
Dans ce cas, il ne pense pas que le "..." soit des points de suspension car il attend un
expression au lieu d'une déclaration :

@transformed = carte { ... } @input; # erreur de syntaxe

À l'intérieur de votre bloc, vous pouvez utiliser un ";" avant les points de suspension pour indiquer que le "{ ... }" est un
bloc et non un constructeur de référence de hachage. Maintenant, les points de suspension fonctionnent :

@transformed = carte {; ... } @saisir; # ';' lève l'ambiguïté

Remarque : Certaines personnes appellent familièrement ce morceau de ponctuation "yada-yada" ou
"triple-dot", mais son vrai nom est en fait des points de suspension.

POD : Embarqué Documentation
Perl dispose d'un mécanisme permettant de mélanger la documentation avec le code source. Pendant qu'il s'attend
le début d'une nouvelle instruction, si le compilateur rencontre une ligne commençant par un
signe égal et un mot, comme ça

=head1 Ici, il y a des pods !

Ensuite, ce texte et tout le texte restant jusqu'à et y compris une ligne commençant par
"=cut" sera ignoré. Le format du texte intermédiaire est décrit dans perlpod.

Cela vous permet de mélanger librement votre code source et votre texte de documentation, comme dans

= article élégant ($)

La fonction snazzle() se comportera de la manière la plus spectaculaire
forme que vous pouvez éventuellement imaginer, même sans exception
pyrotechnie cybernétique.

= revenons au compilateur, rien de ce truc de pod !

sous-snazzle($) {
mon $truc = décalage ;
.........
}

Notez que les traducteurs pod ne doivent examiner que les paragraphes commençant par une directive pod.
(cela facilite l'analyse), alors que le compilateur sait réellement rechercher les échappements de pod
même au milieu d'un paragraphe. Cela signifie que les éléments secrets suivants seront
ignoré à la fois par le compilateur et les traducteurs.

$a=3 ;
=trucs secrets
warn "Ni POD ni CODE !?"
=réduire
print "j'ai obtenu $a\n" ;

Vous ne devriez probablement pas compter sur le fait que "warn()" soit supprimé pour toujours. Pas tous les modules
les traducteurs se comportent bien à cet égard, et peut-être que le compilateur deviendra plus pointilleux.

On peut également utiliser les directives pod pour commenter rapidement une section de code.

Plaine Vieux Description (Pas!)
Perl peut traiter les directives de ligne, un peu comme le préprocesseur C. En utilisant cela, on peut
contrôler l'idée de Perl concernant les noms de fichiers et les numéros de ligne dans les messages d'erreur ou d'avertissement (en particulier
pour les chaînes traitées avec "eval()"). La syntaxe de ce mécanisme est presque
le même que pour la plupart des préprocesseurs C : il correspond à l'expression régulière

# exemple : '# ligne 42 "new_filename.plx"'
/^\# \s*
ligne \s+ (\d+) \s*
(?:\s("?)([^"]+)\g2) ? \s*
$/x

avec $1 étant le numéro de ligne de la ligne suivante et $3 étant le nom de fichier facultatif
(spécifié avec ou sans guillemets). Notez qu'aucun espace ne peut précéder le "#", contrairement à
préprocesseurs C modernes.

Il y a un piège assez évident inclus dans la directive line : les débogueurs et les profileurs
affichera uniquement la dernière ligne source à apparaître à un numéro de ligne particulier dans un fichier donné.
Il faut veiller à ne pas provoquer de collisions de numéros de ligne dans le code que vous souhaitez déboguer
plus tard.

Voici quelques exemples que vous devriez pouvoir saisir dans votre shell de commande :

% perl
# ligne 200 "bzzzt"
# le '#' sur la ligne précédente doit être le premier caractère en ligne
mourir 'foo';
__FINIR__
foo à la ligne bzzzt 201.

% perl
# ligne 200 "bzzzt"
eval qq[\n#line 2001 ""\ndie 'foo']; imprimer $@;
__FINIR__
foo à - ligne 2001.

% perl
eval qq[\n#line 200 "foo bar"\ndie 'foo']; imprimer $@;
__FINIR__
foo à foo bar ligne 200.

% perl
# ligne 345 "goop"
eval "\n#line " . __DOUBLER__ . ' "' . __FILE__ ."\"\ndie 'foo'";
imprimer $@;
__FINIR__
foo à la ligne goop 345.

Expérimental Plus de détails on donné et votre quand
Comme mentionné précédemment, la fonctionnalité « switch » est considérée comme hautement expérimentale ; c'est
sujet à changement sans préavis. En particulier, « quand » comporte des comportements délicats qui
devraient changer pour devenir moins compliqués à l’avenir. Ne vous fiez pas à son courant
(mauvaise) mise en œuvre. Avant Perl 5.18, « donné » avait également des comportements délicats que vous deviez
méfiez-vous toujours si votre code doit s'exécuter sur des versions plus anciennes de Perl.

Voici un exemple plus long de « donné » :

utilisez la fonctionnalité ":5.10" ;
donné ($foo) {
quand (undef) {
dites « $foo n'est pas défini » ;
}
quand ("foo") {
dites '$foo est la chaîne "foo"';
}
quand ([1,3,5,7,9]) {
dites « $foo est un chiffre impair » ;
continuer; # Tomber dans
}
quand ($_ < 100) {
dites « $foo est numériquement inférieur à 100 » ;
}
quand (\&compliqué_check) {
dites « une vérification compliquée de $foo est vraie » ;
}
défaut {
die q(je ne sais pas quoi faire avec $foo) ;
}
}

Avant Perl 5.18, "given(EXPR)" attribuait la valeur de EXPR à une simple portée lexicale
copier (!) de $_, pas un alias à portée dynamique comme le fait "foreach". Cela l'a fait
similaire à

faire { mon $_ = EXPR ; ... }

sauf que le bloc était automatiquement libéré par un "quand" réussi ou un
"pause" explicite. Parce qu'il ne s'agissait que d'une copie, et parce qu'elle n'avait qu'une portée lexicale,
pas de portée dynamique, vous ne pouvez pas faire les choses avec lesquelles vous êtes habitué dans un
boucle "foreach". En particulier, cela ne fonctionnait pas pour les appels de fonctions arbitraires si ceux-ci
les fonctions pourraient essayer d'accéder à $_. Mieux vaut s'en tenir à "foreach" pour cela.

L’essentiel de la puissance provient du smartmatching implicite qui peut parfois s’appliquer. La plupart de
l'heure, "when(EXPR)" est traitée comme une correspondance intelligente implicite de $_, c'est-à-dire "$_ ~~ EXPR".
(Voir "Smartmatch Operator" dans perlop pour plus d'informations sur le smartmatching.) Mais quand
EXPR est l'un des 10 cas exceptionnels (ou choses similaires) énumérés ci-dessous, il est utilisé
directement en tant que booléen.

1. Un appel de sous-programme défini par l'utilisateur ou un appel de méthode.

2. Une correspondance d'expression régulière sous la forme "/REGEX/", "$foo =~ /REGEX/" ou "$foo =~
EXPR". En outre, une correspondance d'expression régulière niée sous la forme "!/REGEX/", "$foo !~
/REGEX/", ou "$foo !~ EXPR".

3. Une correspondance intelligente qui utilise un opérateur "~~" explicite, tel que "EXPR ~~ EXPR".

NOTE: Vous devrez souvent utiliser "$c ~~ $_" car le cas par défaut utilise "$_ ~~ $c" ,
ce qui est souvent le contraire de ce que vous souhaitez.

4. Un opérateur de comparaison booléen tel que "$_ < 10" ou "$x eq "abc"". Le relationnel
les opérateurs auxquels cela s'applique sont les six comparaisons numériques ("", "=",
"==" et "!=") et les six comparaisons de chaînes ("lt", "gt", "le", "ge", "eq" et
"ne").

5. Au moins les trois fonctions intégrées "défini(...)", "existe(...)" et "eof(...)".
Nous pourrions un jour en ajouter d’autres plus tard si nous y réfléchissons.

6. Une expression niée, que ce soit "!(EXPR)" ou "not(EXPR)", ou un ou exclusif logique,
"(EXPR1) xou (EXPR2)". Les versions bit à bit ("~" et "^") ne sont pas incluses.

7. Un opérateur filetest, avec exactement 4 exceptions : "-s", "-M", "-A" et "-C", car ceux-ci
renvoie des valeurs numériques, pas des valeurs booléennes. L'opérateur filetest "-z" n'est pas inclus
dans la liste des exceptions.

8. Les opérateurs de bascule ".." et "...". Notez que l'opérateur de bascule "..." est
complètement différent de la déclaration elliptique "..." qui vient d'être décrite.

Dans les 8 cas ci-dessus, la valeur de EXPR est utilisée directement comme booléen, donc non
le smartmatching est terminé. Vous pouvez considérer le « quand » comme un match intelligent et intelligent.

De plus, Perl inspecte les opérandes des opérateurs logiques pour décider s'il faut utiliser
smartmatching pour chacun en appliquant le test ci-dessus aux opérandes :

9. Si EXPR est "EXPR1 && EXPR2" ou "EXPR1 et EXPR2", le test est appliqué récursivement à
EXPR1 et EXPR2. Seulement si tous les deux les opérandes réussissent également le test, récursivement, sera le
l'expression soit traitée comme booléenne. Sinon, le smartmatching est utilisé.

10. Si EXPR est "EXPR1 || EXPR2", "EXPR1 // EXPR2" ou "EXPR1 ou EXPR2", le test est
appliqué récursivement à EXPR1 uniquement (qui pourrait lui-même être une priorité plus élevée ET
opérateur, par exemple, et donc soumis à la règle précédente), et non à EXPR2. Si EXPR1
est d'utiliser le smartmatching, alors EXPR2 le fait également, peu importe ce que EXPR2 contient. Mais
si EXPR2 ne parvient pas à utiliser le smartmatching, alors le deuxième argument ne sera pas
soit. Ceci est assez différent du cas "&&" que nous venons de décrire, alors soyez prudent.

Ces règles sont compliquées, mais le but est qu'elles fassent ce que vous voulez (même si vous
je ne comprends pas très bien pourquoi ils le font). Par exemple:

quand (/^\d+$/ && $_ < 75) { ... }

sera traité comme une correspondance booléenne car les règles disent à la fois une correspondance regex et un
un test explicite sur $_ sera traité comme un booléen.

Aussi:

quand ([qw(foo bar)] && /baz/) { ... }

utilisera smartmatching car seulement UN des opérandes est un booléen : les autres utilisations
smartmatching, et c’est gagnant.

En outre:

quand ([qw(foo bar)] || /^baz/) { ... }

utilisera la correspondance intelligente (seul le premier opérande est pris en compte), alors que

quand (/^baz/ || [qw(foo bar)]) { ... }

testera uniquement l'expression régulière, ce qui fera que les deux opérandes seront traités comme des booléens. Attention
pour celui-ci, alors, car un arrayref est toujours une vraie valeur, ce qui le rend effectivement
redondant. Pas une bonne idée.

Les opérateurs booléens tautologues vont encore être optimisés. Ne soyez pas tenté de
écrire

quand ("foo" ou "bar") { ... }

Cela optimisera jusqu'à "foo", donc "bar" ne sera jamais pris en compte (même si les règles
dites d'utiliser un smartmatch sur "foo"). Pour une série comme celle-ci, une référence de tableau fonctionnera,
car cela déclenchera un smartmatching :

quand ([qw(foo bar)] { ... }

Ceci est quelque peu équivalent à la fonctionnalité de secours de l'instruction switch de style C
(à ne pas confondre avec De Perl fonctionnalité de secours--voir ci-dessous), dans laquelle le même
block est utilisé pour plusieurs instructions "case".

Un autre raccourci utile est que, si vous utilisez un tableau littéral ou un hachage comme argument pour
« donné », il devient référence. Donc "given (@foo)" est identique à "given(\@foo)",
par exemple.

"default" se comporte exactement comme "when(1 == 1)", c'est-à-dire qu'il correspond toujours.

Abandonner ande

Vous pouvez utiliser le mot-clé "break" pour sortir du bloc "donné" englobant. Chaque "quand"
le bloc se termine implicitement par un "break".

Tomber dans

Vous pouvez utiliser le mot-clé "continue" pour passer d'un cas à l'autre :

donné($foo) {
when (/x/) { say '$foo contient un x'; continuer }
when (/y/) { say '$foo contient un y' }
default { say '$foo ne contient pas de y' }
}

Retour Plus-value

Lorsqu'une instruction « donnée » est également une expression valide (par exemple, lorsqu'il s'agit de la dernière
instruction d'un bloc), il s'évalue à :

· Une liste vide dès qu'une "pause" explicite est rencontrée.

· La valeur de la dernière expression évaluée de la clause "when"/"default" réussie,
s'il y en a un.

· La valeur de la dernière expression évaluée du bloc "donné" si aucune condition n'est
vrai.

Dans les deux derniers cas, la dernière expression est évaluée dans le contexte qui a été appliqué à
le bloc "donné".

Notez que, contrairement à "if" et "sauf si", les instructions "quand" ayant échoué sont toujours évaluées comme étant vides.
liste.

mon prix $ = faire {
donné ($article) {
quand (["poire", "pomme"]) { 1 }
pause quand "voter"; # Mon vote ne peut pas être acheté
1e10 quand /Mona Lisa/;
"inconnu";
}
};

Actuellement, les blocs « donnés » ne peuvent pas toujours être utilisés comme expressions appropriées. Cela peut être
abordé dans une future version de Perl.

Commutation in a boucle

Au lieu d'utiliser "given()", vous pouvez utiliser une boucle "foreach()". Par exemple, voici une façon
pour compter combien de fois une chaîne particulière apparaît dans un tableau :

utiliser la v5.10.1 ;
mon compte $ = 0 ;
pour (@array) {
quand ("foo") { ++$count }
}
print "\@array contient $count copies de 'foo'\n";

Ou dans une version plus récente :

utiliser la v5.14 ;
mon compte $ = 0 ;
pour (@array) {
++$count quand "foo" ;
}
print "\@array contient $count copies de 'foo'\n";

À la fin de tous les blocs « quand », il y a un « suivant » implicite. Vous pouvez remplacer cela par
un "dernier" explicite si vous n'êtes intéressé que par le premier match.

Cela ne fonctionne pas si vous spécifiez explicitement une variable de boucle, comme dans "for $item (@array)".
Vous devez utiliser la variable par défaut $_.

Différences de Perl 6

Les constructions Perl 5 smartmatch et "given"/"when" ne sont pas compatibles avec leur Perl 6
analogues. La différence la plus visible et la moins importante est que, en Perl 5,
des parenthèses sont requises autour de l'argument de "given()" et "when()" (sauf lorsque ceci
le dernier est utilisé comme modificateur d'instruction). Les parenthèses en Perl 6 sont toujours facultatives dans un
construction de contrôle telle que "if()", "while()" ou "when()" ; ils ne peuvent pas être rendus facultatifs dans
Perl 5 sans trop de confusion potentielle, car Perl 5 analyserait le
expression

étant donné $foo {

}

comme si l'argument de "donné" était un élément du hachage %foo, interprétant le
accolades comme syntaxe d'élément de hachage.

Cependant, il existe de très nombreuses autres différences. Par exemple, cela fonctionne en Perl 5 :

utiliser la v5.12 ;
mon @primary = ("rouge", "bleu", "vert");

si (@primary ~~ "rouge") {
dites « les smartmatchs primaires sont rouges » ;
}

if ("rouge" ~~ @primary) {
dites « rouge smartmatches primaire » ;
}

dites « c'est tout, les amis ! » ;

Mais cela ne fonctionne pas du tout en Perl 6. Au lieu de cela, vous devez utiliser le "any" (parallélisable)
opérateur:

le cas échéant (@primary) eq "rouge" {
dites « les smartmatchs primaires sont rouges » ;
}

si "rouge" eq any (@primary) {
dites « rouge smartmatches primaire » ;
}

Le tableau des smartmatches dans "Smartmatch Operator" dans perlop n'est pas identique à celui
proposé par la spécification Perl 6, principalement en raison des différences entre Perl 6 et Perl
5, mais aussi parce que les spécifications de Perl 6 ont changé depuis que Perl 5 s'est précipité dans
adoption précoce.

En Perl 6, "when()" fera toujours une correspondance intelligente implicite avec son argument, alors qu'en Perl
5, il est pratique (bien que potentiellement déroutant) de supprimer cette correspondance intelligente implicite dans
diverses situations assez vaguement définies, telles que décrites grossièrement ci-dessus. (La différence est
en grande partie parce que Perl 5 n'a pas, même en interne, de type booléen.)

Utilisez Perlsyn en ligne en utilisant les services onworks.net