.\" Automatically generated by Pod::Man 2.09 (Pod::Simple 3.04)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  | will give a
.\" real vertical bar.  \*(C+ will give a nicer C++.  Capital omega is used to
.\" do unbreakable dashes and therefore won't be available.  \*(C` and \*(C'
.\" expand to `' in nroff, nothing in troff, for use with C<>.
.tr \(*W-|\(bv\*(Tr
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.if \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.\"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.hy 0
.if n .na
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "PERLTRAP 1"
.TH PERLTRAP 1 "2006-03-10" "DocFr" "User Contributed Perl Documentation"
.SH "NAME/NOM"
.IX Header "NAME/NOM"
perltrap \- Les pie\*`ges de Perl pour l'imprudent
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
Le plus gros pie\*`ge est d'oublier d'utiliser la directive \f(CW\*(C`use
warnings\*(C'\fR ou l'option \fB\-w\fR ; voir perllexwarn et perlrun. Le
deuxie\*`me plus gros pie\*`ge est de ne pas rendre la totalite\*' de votre
programme exe\*'cutable sous \f(CW\*(C`use strict\*(C'\fR. Le troisie\*`me plus grand pie\*`ge
est de ne pas lire la liste des changements effectue\*'s dans cette
version de Perl ; voir perldelta.
.Sh "Pie\*`ges de awk"
.IX Subsection "Pie`ges de awk"
Les utilisateurs avertis de \fBawk\fR devraient se soucier
particulie\*`rement de ce qui suit\ :
.IP "\(bu" 4
Un programme Perl est exe\*'cute\*' une seule fois et non pour chacune des
lignes d'entre\*'e. Vous pouvez obtenir une boucle implicite en utilisant
les options \f(CW\*(C`\-n\*(C'\fR et \f(CW\*(C`\-p\*(C'\fR.
.IP "\(bu" 4
Le module English, charge\*' par
.Sp
.Vb 1
\&    use English;
.Ve
.Sp
vous permet de vous re\*'fe\*'rer aux variables spe\*'ciales (comme \f(CW$/\fR) par
des noms (comme \f(CW$RS\fR), comme si elles e\*'taient en \fBawk\fR ; voir
perlvar pour plus de de\*'tails.
.IP "\(bu" 4
Le point-virgule est requis apre\*`s toute instruction simple en Perl
(sauf a\*` la fin d'un bloc). La fin de ligne n'est pas un de\*'limiteur
d'instruction.
.IP "\(bu" 4
Les accolades sont requises pour les \f(CW\*(C`if\*(C'\fRs et les \f(CW\*(C`while\*(C'\fRs.
.IP "\(bu" 4
Les variables commencent par \*(L"$\*(R", \*(L"@\*(R" ou \*(L"%\*(R" en Perl.
.IP "\(bu" 4
Les tableaux sont indexe\*'s a\*` partir de 0. De la me\*^me manie\*`re, les
positions renvoye\*'es par \f(CW\*(C`substr()\*(C'\fR et \f(CW\*(C`index()\*(C'\fR dans les chai\*^nes sont
compte\*'es a\*` partir de 0.
.IP "\(bu" 4
Vous devez de\*'cider si votre tableau a pour indices des nombres ou des
chai\*^nes.
.IP "\(bu" 4
Les hachages ne sont pas cre\*'e\*'s par une simple re\*'fe\*'rence.
.IP "\(bu" 4
Vous devez de\*'cider si une comparaison porte sur des chai\*^nes ou des
nombres.
.IP "\(bu" 4
La lecture d'une entre\*'e ne la de\*'coupe pas pour vous. Vous devez la
transformer en un tableau vous\-me\*^me. Et l'ope\*'rateur \f(CW\*(C`split()\*(C'\fR a des
arguments diffe\*'rents qu'en \fBawk\fR.
.IP "\(bu" 4
La ligne courante en entre\*'e est normalement dans \f(CW$_\fR, pas dans \f(CW$0\fR. Elle
n'a en ge\*'ne\*'ral pas encore perdu sa fin de ligne ($0 est le nom du
programme exe\*'cute\*'). Voir perlvar.
.IP "\(bu" 4
$\fIdigit\fR ne se re\*'fe\*`re pas a\*` des champs \*(-- il se re\*'fe\*`re aux
sous\-chai\*^nes de\*'tecte\*'es par le dernier motif de correspondance.
.IP "\(bu" 4
L'instruction \f(CW\*(C`print()\*(C'\fR n'ajoute pas de se\*'parateurs de champs et
d'enregistrements a\*` moins que vous ne fixiez \f(CW$,\fR et \f(CW\*(C`$\e\*(C'\fR. Vous
pouvez fixer \f(CW$OFS\fR et \f(CW$ORS\fR si vous utilisez le module English.
.IP "\(bu" 4
Vous devez ouvrir vos fichiers avant d'y e\*'crire.
.IP "\(bu" 4
L'ope\*'rateur d'intervalle est \*(L"..\*(R", et pas la virgule. L'ope\*'rateur
virgule fonctionne comme en C.
.IP "\(bu" 4
L'ope\*'rateur de correspondance est \*(L"=~\*(R", pas \*(L"~\*(R" (\*(L"~\*(R" est l'ope\*'rateur
de comple\*'ment a\*` 1, comme en C).
.IP "\(bu" 4
L'ope\*'rateur d'exponentiation est \*(L"**\*(R", pas \*(L"^\*(R". \*(L"^\*(R" est l'ope\*'rateur
\&\s-1XOR\s0, comme en C (vous savez, on pourrait finir par avoir la sensation
que \fBawk\fR est intrinse\*`quement incompatible avec C).
.IP "\(bu" 4
L'ope\*'rateur de concate\*'nation est \*(L".\*(R", pas la chai\*^ne vide (utiliser la
chai\*^ne vide rendrait \f(CW\*(C`/pat/ /pat/\*(C'\fR impossible a\*` analyser
lexicalement, car le troisie\*`me signe de division serait interpre\*'te\*'
comme un ope\*'rateur de division \*(-- le de\*'tecteur de mots\-cle\*'s est en
fait le\*'ge\*`rement sensible au contexte pour les ope\*'rateurs tels que \*(L"/\*(R",
\&\*(L"?\*(R", et \*(L">\*(R". Et en fait, \*(L".\*(R" lui\-me\*^me peut e\*^tre le de\*'but d'un nombre).
.IP "\(bu" 4
Les mots\-cle\*'s \f(CW\*(C`next\*(C'\fR, \f(CW\*(C`exit\*(C'\fR, et \f(CW\*(C`continue\*(C'\fR fonctionnement
diffe\*'remment.
.IP "\(bu" 4
Les variables suivantes fonctionnent diffe\*'remment\ :
.Sp
.Vb 10
\&      Awk       Perl
\&      ARGC      scalar @ARGV (a\*` comparer avec $#ARGV)
\&      ARGV[0]   $0
\&      FILENAME  $ARGV
\&      FNR       $. \- quelque chose
\&      FS        (ce que vous voulez)
\&      NF        $#Fld, ou quelque chose comme c\*,a
\&      NR        $.
\&      OFMT      $#
\&      OFS       $,
\&      ORS       $\e
\&      RLENGTH   length($&)
\&      RS        $/
\&      RSTART    length($`)
\&      SUBSEP    $;
.Ve
.IP "\(bu" 4
Vous ne pouvez pas mettre un motif dans \f(CW$RS\fR, seulement une chai\*^ne.
.IP "\(bu" 4
En cas de doute, faites passer la construction \fBawk\fR dans \fBa2p\fR et
voyez ce que cela donne.
.Sh "Pie\*`ges de C"
.IX Subsection "Pie`ges de C"
Les programmeurs C et \*(C+ devraient prendre note de ce qui suit\ :
.IP "\(bu" 4
Les accolades sont requises pour les \f(CW\*(C`if\*(C'\fRs et les \f(CW\*(C`while\*(C'\fRs.
.IP "\(bu" 4
Vous devez utiliser \f(CW\*(C`elsif\*(C'\fR a\*` la place de \f(CW\*(C`else if\*(C'\fR.
.IP "\(bu" 4
Les mots\-cle\*'s \f(CW\*(C`break\*(C'\fR et \f(CW\*(C`continue\*(C'\fR de C deviennent respectivement
\&\f(CW\*(C`last\*(C'\fR et \f(CW\*(C`next\*(C'\fR en Perl. Contrairement au C, ceux-ci ne
fonctionnent \fIpas\fR a\*` l'inte\*'rieur d'une structure \f(CW\*(C`do { }
while\*(C'\fR. Voir \*(L"Contro\*^le de Boucle\*(R" in perlsyn.
.IP "\(bu" 4
Il n'y a pas d'instruction switch (mais il est aise\*' d'en construire
une a\*` la vole\*'e, voir \*(L"BLOCs de Base et Instruction
Switch\*(R" in perlsyn).
.IP "\(bu" 4
Les variables commencent par \*(L"$\*(R", \*(L"@\*(R" ou \*(L"%\*(R" en Perl.
.IP "\(bu" 4
Les commentaires commencent par \*(L"#\*(R", pas par \*(L"/*\*(R" ou \*(L"//\*(R". Perl peut
interpre\*'ter un commentaire C/\*(C+ comme un ope\*'rateur de division, un
expression rationnelle non termine\*'e ou comme l'ope\*'rateur \*(L"de\*'fini\-ou\*(R".
.IP "\(bu" 4
Vous ne pouvez pas re\*'cupe\*'rer l'adresse de quelque chose, bien que
l'ope\*'rateur barre oblique inverse de Perl vous permette de faire
quelque chose d'assez proche : cre\*'er une re\*'fe\*'rence.
.IP "\(bu" 4
\&\f(CW\*(C`ARGV\*(C'\fR doit e\*^tre en majuscules. \f(CW$ARGV[0]\fR est l'\f(CW\*(C`argv[1]\*(C'\fR du C, et
\&\f(CW\*(C`argv[0]\*(C'\fR atterrit dans \f(CW$0\fR.
.IP "\(bu" 4
Les appels syste\*`mes tels que \f(CW\*(C`link()\*(C'\fR, \f(CW\*(C`unlink()\*(C'\fR, \f(CW\*(C`rename()\*(C'\fR,
etc. renvoient autre chose que ze\*'ro en cas de succe\*`s. (En revanche,
\&\f(CW\*(C`system()\*(C'\fR retourne un ze\*'ro en cas de succe\*`s.)
.IP "\(bu" 4
Les handlers de signaux manipulent des noms de signaux, pas des
nombres. Utilisez \f(CW\*(C`kill \-l\*(C'\fR pour de\*'terminer leurs noms sur votre
syste\*`me.
.Sh "Pie\*`ges de sed"
.IX Subsection "Pie`ges de sed"
Les programmeurs \fBsed\fR expe\*'rimente\*'s devraient prendre note de ce qui
suit\ :
.IP "\(bu" 4
Un programme Perl est exe\*'cute\*' une seule fois et non pour chacune des
lignes d'entre\*'e. Vous pouvez obtenir une boucle implicite en utilisant
les options \f(CW\*(C`\-n\*(C'\fR et \f(CW\*(C`\-p\*(C'\fR.
.IP "\(bu" 4
Les re\*'fe\*'rences arrie\*`res dans les substitutions utilisent \*(L"$\*(R" a\*` la
place de \*(L"\e\*(R".
.IP "\(bu" 4
Les me\*'tacaracte\*`res d'expressions rationnelles \*(L"(\*(R", \*(L")\*(R", et \*(L"|\*(R" ne sont
pas pre\*'ce\*'de\*'s de barres obliques inverses.
.IP "\(bu" 4
L'ope\*'rateur d'intervalle est \f(CW\*(C`...\*(C'\fR, a\*` la place de la virgule.
.Sh "Pie\*`ges du shell"
.IX Subsection "Pie`ges du shell"
les programmeurs shell de\*'gourdis devraient prendre note de ce qui
suit\ :
.IP "\(bu" 4
L'ope\*'rateur accent grave effectue une interpolation de variable sans
se soucier de la pre\*'sence ou non d'apostrophes dans la commande.
.IP "\(bu" 4
L'ope\*'rateur accent grave ne fait pas de traduction de la valeur de
retour, contrairement au \fBcsh\fR.
.IP "\(bu" 4
Les shells (en particulier \fBcsh\fR) effectuent plusieurs niveaux de
substitution sur chaque ligne de commande. Perl ne fait de
substitution que dans certaines structures comme les guillemets, les
accents graves, les crochets et les motifs de recherche.
.IP "\(bu" 4
Les shells interpre\*`tent les scripts petits bouts par petits
bouts. Perl compile tout le programme avant de l'exe\*'cuter (sauf les
blocs \f(CW\*(C`BEGIN\*(C'\fR, qu'il exe\*'cute lors de la compilation).
.IP "\(bu" 4
Les arguments sont disponibles via \f(CW@ARGV\fR, et pas \f(CW$1\fR, \f(CW$2\fR, etc.
.IP "\(bu" 4
L'environnement n'est pas automatiquement mis a\*` disposition sous forme
de variables scalaires distinctes.
.IP "\(bu" 4
Les tests en shell utilisent \*(L"=\*(R", \*(L"!=\*(R", \*(L"<\*(R", etc. pour les
comparaisons de chai\*^nes et \*(L"\-eq\*(R", \*(L"\-ne\*(R", \*(L"\-lt\*(R", etc. pour les
comparaisons nume\*'riques. En Perl, c'est exactement le contraire\ : on
utilise \f(CW\*(C`eq\*(C'\fR, \f(CW\*(C`ne\*(C'\fR, \f(CW\*(C`lt\*(C'\fR, etc. pour les comparaisons de chai\*^nes et
\&\f(CW\*(C`==\*(C'\fR, \f(CW\*(C`!=\*(C'\fR, \f(CW\*(C`<\*(C'\fR, etc. pour les comparaisons nume\*'riques.
.Sh "Pie\*`ges de Perl"
.IX Subsection "Pie`ges de Perl"
Les programmeurs Perl pratiquants devraient prendre note de ce qui
suit\ :
.IP "\(bu" 4
Souvenez-vous que de nombreuses ope\*'rations se comportent diffe\*'remment
selon qu'elles sont appele\*'es dans un contexte de liste ou dans un
contexte scalaire. Voir perldata pour plus de de\*'tails.
.IP "\(bu" 4
E\*'vitez autant que possible les barewords, en particulier ceux en
minuscules. Vous ne pouvez pas dire rien qu'en le regardant si un
bareword est une fonction ou une chai\*^ne. En utilisant les apostrophes
pour les chai\*^nes et des parenthe\*`ses pour les appels de fonctions, vous
permettrez qu'on ne les confonde jamais.
.IP "\(bu" 4
Vous ne pouvez pas distinguer, par simple inspection, les fonctions
inte\*'gre\*'es qui sont, par construction, des ope\*'rateurs unaires (comme
\&\f(CW\*(C`chop()\*(C'\fR et \f(CW\*(C`chdir()\*(C'\fR) de celles qui sont des ope\*'rateurs de liste
(comme \f(CW\*(C`print()\*(C'\fR et \f(CW\*(C`unlink()\*(C'\fR). (Sauf a\*` utiliser des prototypes,
les sous-programmes de\*'finis par l'utilisateur ne peuvent e\*^tre \fBque\fR
des ope\*'rateurs de liste, jamais des ope\*'rateurs unaires). Voir
perlop et perlsub.
.IP "\(bu" 4
Les gens ont du mal a\*` se souvenir que certaines fonctions utilisent
par de\*'faut \f(CW$_\fR, ou \f(CW@ARGV\fR, ou autre chose, tandis que d'autres ne le
font pas alors qu'on pourrait s'y attendre.
.IP "\(bu" 4
La structure <\s-1FH\s0> n'est pas le nom du handle de fichier, c'est un
ope\*'rateur lisant une ligne sur ce handle. Les donne\*'es lues sont
affecte\*'es a\*` \f(CW$_\fR seulement si la lecture du fichier est la seule
condition d'une boucle while\ :
.Sp
.Vb 3
\&    while (<FH>)      { }
\&    while (defined($_ = <FH>)) { }..
\&    <FH>;  # donne\*'es rejete\*'es !
.Ve
.IP "\(bu" 4
Souvenez-vous de ne pas utiliser \f(CW\*(C`=\*(C'\fR lorsque vous avez besoin de
\&\f(CW\*(C`=~\*(C'\fR ; ces deux structures sont tre\*`s diffe\*'rentes\ :
.Sp
.Vb 2
\&    $x =  /foo/;
\&    $x =~ /foo/;
.Ve
.IP "\(bu" 4
La structure \f(CW\*(C`do {}\*(C'\fR n'est pas une ve\*'ritable boucle sur laquelle vous
pourriez utiliser les instructions de contro\*^le de boucle.
.IP "\(bu" 4
Utilisez \f(CW\*(C`my()\*(C'\fR pour les variables locales chaque fois que vous
pouvez vous en satisfaire (mais voyez perlform pour les cas ou\*` vous
ne le pouvez pas). L'utilisation de \f(CW\*(C`local()\*(C'\fR donne vraiment une
valeur locale a\*` une variable globale, ce qui vous met a\*` la merci
d'effets secondaires de porte\*'e dynamique impre\*'vus.
.IP "\(bu" 4
Si vous localisez une variable exporte\*'e dans un module, sa valeur
exporte\*'e value ne changera pas. Le nom local devient un alias pour une
nouvelle valeur, mais le nom externe est toujours un alias de
l'original.
.Sh "Pie\*`ges entre Perl4 et Perl5"
.IX Subsection "Pie`ges entre Perl4 et Perl5"
Les programmeurs Perl4 pratiquants devraient prendre note des pie\*`ges
suivants, spe\*'cifiques au passage entre Perl4 et Perl5.
.PP
Ils sont cru\*^ment commande\*'s par la liste suivante\ :
.IP "Pie\*`ges lie\*'s aux corrections de bugs, aux de\*'sapprobations et aux abandons" 4
.IX Item "Pie`ges lie's aux corrections de bugs, aux de'sapprobations et aux abandons"
Tout ce qui a e\*'te\*' corrige\*' en tant que bug de perl4, supprime\*' ou
de\*'sapprouve\*' en tant que caracte\*'ristique de perl4, avec l'intention
d'encourager l'usage d'une autre caracte\*'ristique de perl5.
.IP "Pie\*`ges de l'analyse syntaxique" 4
.IX Item "Pie`ges de l'analyse syntaxique"
Pie\*`ges qui semblent provenir du nouvel analyseur.
.IP "Pie\*`ges nume\*'riques" 4
.IX Item "Pie`ges nume'riques"
Pie\*`ges lie\*'s aux ope\*'rateurs nume\*'riques ou mathe\*'matiques.
.IP "Pie\*`ges des types ge\*'ne\*'raux de donne\*'es" 4
.IX Item "Pie`ges des types ge'ne'raux de donne'es"
Pie\*`ges impliquant les types de donne\*'es standards de perl.
.IP "Pie\*`ges du contexte \- contexte scalaire et de liste" 4
.IX Item "Pie`ges du contexte - contexte scalaire et de liste"
Pie\*`ges lie\*'s au contexte dans les instructions et de\*'clarations
scalaires ou de liste.
.IP "Pie\*`ges de la pre\*'ce\*'dence (les priorite\*'s)" 4
.IX Item "Pie`ges de la pre'ce'dence (les priorite's)"
Pie\*`ges lie\*'s a\*` la pre\*'ce\*'dence lors de l'analyse, de l'e\*'valuation et de
l'exe\*'cution du code.
.IP "Pie\*`ges des expressions rationnelles ge\*'ne\*'rales lors de l'utilisation de s///, etc." 4
.IX Item "Pie`ges des expressions rationnelles ge'ne'rales lors de l'utilisation de s///, etc."
Pie\*`ges lie\*'s a\*` l'utilisation de la reconnaissance de motifs.
.IP "Pie\*`ges des sous\-programmes, des signaux, des tris" 4
.IX Item "Pie`ges des sous-programmes, des signaux, des tris"
Pie\*`ges lie\*'s a\*` l'utilisation des signaux et des handlers de signaux,
aux sous-programmes ge\*'ne\*'raux, et aux tris, ainsi qu'aux sous-progammes
de tri.
.IP "Pie\*`ges du syste\*`me d'exploitation" 4
.IX Item "Pie`ges du syste`me d'exploitation"
Pie\*`ges spe\*'cifiques au syste\*`me d'exploitation.
.IP "Pie\*`ges de \s-1DBM\s0" 4
.IX Item "Pie`ges de DBM"
Pie\*`ges spe\*'cifiques a\*` l'utilisation de \f(CW\*(C`dbmopen()\*(C'\fR, et aux
imple\*'mentations particulie\*`res de dbm.
.IP "Pie\*`ges non classe\*'s" 4
.IX Item "Pie`ges non classe's"
Tout le reste.
.PP
Si vous trouvez un exemple de pie\*`ge de conversion qui ne soit pas
liste\*' ici, soumettez-le a\*` <\fIperlbug@perl.org\fR> en vue de son
inclusion. Notez aussi qu'un certain nombre d'entre eux peuvent e\*^tre
de\*'tecte\*'s par le pragma \f(CW\*(C`use warnings\*(C'\fR ou par l'option \fB\-w\fR.
.Sh "Pie\*`ges lie\*'s aux corrections de bugs, aux de\*'sapprobations et aux abandons"
.IX Subsection "Pie`ges lie's aux corrections de bugs, aux de'sapprobations et aux abandons"
Tout ce qui a e\*'te\*' abandonne\*', de\*'sapprouve\*' ou corrige\*' comme e\*'tant un bug
depuis perl4.
.IP "\(bu" 4
Les symboles commenc\*,ant par \*(L"_\*(R" ne sont plus force\*'ment dans main.
.Sp
Les symboles commenc\*,ant par \*(L"_\*(R" ne sont plus force\*'ment dans le
paquetage main, sauf pour \f(CW$_\fR lui\-me\*^me (ainsi que \f(CW@_\fR, etc.).
.Sp
.Vb 2
\&    package test;
\&    $_legacy = 1;
\&
\&    package main;
\&    print "\e$_legacy is ",$_legacy,"\en";
\&
\&    # perl4 affiche : $_legacy is 1
\&    # perl5 affiche : $_legacy is
.Ve
.IP "\(bu" 4
Le double deux-points dans un nom de variable est un se\*'parateur de nom de paquetage
.Sp
Le double deux-points est de\*'sormais un se\*'parateur de paquetage valide
dans un nom de variable. Ainsi ceux-ci se comportent diffe\*'remment en
perl4 et en perl5, car le paquetage n'existe pas.
.Sp
.Vb 3
\&    $a=1;$b=2;$c=3;$var=4;
\&    print "$a::$b::$c ";
\&    print "$var::abc::xyz\en";
\&
\&    # perl4 affiche : 1::2::3 4::abc::xyz
\&    # perl5 affiche : 3
.Ve
.Sp
E\*'tant donne\*' que \f(CW\*(C`::\*(C'\fR est maintenant le de\*'limiteur de paquetage
pre\*'fe\*'re\*', on peut se demander si ceci doit e\*^tre conside\*'re\*' comme un bug
ou non (l'ancien de\*'limiteur de paquetage, ' , est utilise\*' ici).
.Sp
.Vb 2
\&    $x = 10 ;
\&    print "x=${'x}\en" ;
\&
\&    # perl4 affiche : x=10
\&    # perl5 affiche : Can't find string terminator "'" anywhere before EOF
.Ve
.Sp
Vous pouvez e\*'viter ce proble\*`me, en restant compatible avec perl4, si
vous incluez toujours explicitement le nom du paquetage\ :
.Sp
.Vb 2
\&    $x = 10 ;
\&    print "x=${main'x}\en" ;
.Ve
.Sp
Voyez aussi les pie\*`ges de pre\*'ce\*'dence, pour l'analyse de \f(CW$:\fR.
.IP "\(bu" 4
Les deuxie\*`mes et troisie\*`mes arguments de \f(CW\*(C`splice()\*(C'\fR ont un contexte scalaire
.Sp
Les deuxie\*`mes et troisie\*`mes arguments de \f(CW\*(C`splice()\*(C'\fR sont de\*'sormais
e\*'value\*'s dans un contexte scalaire (comme l'indique le Camel) pluto\*^t
que dans un contexte de liste.
.Sp
.Vb 5
\&    sub sub1{return(0,2) }          # retourne une liste de 2 e\*'le\*'ments
\&    sub sub2{ return(1,2,3)}        # retourne une liste de 3 e\*'le\*'ments
\&    @a1 = ("a","b","c","d","e");
\&    @a2 = splice(@a1,&sub1,&sub2);
\&    print join(' ',@a2),"\en";
\&
\&    # perl4 affiche : a b
\&    # perl5 affiche : c d e
.Ve
.IP "\(bu" 4
Impossible de faire un \f(CW\*(C`goto\*(C'\fR vers un bloc optimise\*'
.Sp
Vous ne pouvez pas faire un \f(CW\*(C`goto\*(C'\fR dans un bloc optimise\*'. Mince.
.Sp
.Vb 1
\&    goto marker1;
\&
\&    for(1){
\&    marker1:
\&        print "Here I is!\en";
\&    }
\&
\&    # perl4 affiche : Here I is!
\&    # perl5 erreur : Can't "goto" into the middle of a foreach loop
.Ve
.IP "\(bu" 4
Impossible d'utiliser l'espace dans un nom de variable ou comme de\*'limiteur
.Sp
Il n'est plus le\*'gal syntaxiquement d'utiliser l'espace comme nom de
variable, ou comme de\*'limiteur pour tout type de structure entre
apostrophes. Mince et remince.
.Sp
.Vb 3
\&    $a = ("foo bar");
\&    $b = q baz ;
\&    print "a is $a, b is $b\en";
\&
\&    # perl4 affiche : a is foo bar, b is baz
\&    # erreur de perl5 : Bareword found where operator expected
.Ve
.IP "\(bu" 4
\&\f(CW\*(C`while/if BLOCK BLOCK\*(C'\fR a disparu
.Sp
La syntaxe archai\*:que while/if \s-1BLOC\s0 \s-1BLOC\s0 n'est plus supporte\*'e.
.Sp
.Vb 6
\&    if { 1 } {
\&        print "True!";
\&    }
\&    else {
\&        print "False!";
\&    }
\&
\&    # perl4 affiche : True!
\&    # erreur de perl5 : syntax error at test.pl line 1, near "if {"
.Ve
.IP "\(bu" 4
\&\f(CW\*(C`**\*(C'\fR est prioritaire sur le moins unaire
.Sp
L'ope\*'rateur \f(CW\*(C`**\*(C'\fR est de\*'sormais plus prioritaire que le moins
unaire. Cela devait fonctionner ainsi selon la documentation, mais ce
n'e\*'tait pas le cas.
.Sp
.Vb 1
\&    print \-4**2,"\en";
\&
\&    # perl4 affiche : 16
\&    # perl5 affiche : \-16
.Ve
.IP "\(bu" 4
\&\f(CW\*(C`foreach\*(C'\fR a change\*' lorsqu'il est applique\*' a\*` une liste
.Sp
La signification de \f(CW\*(C`foreach{}\*(C'\fR a le\*'ge\*`rement change\*' lorsqu'il
traverse une liste qui n'est pas un tableau. Auparavant, il
fonctionait en affectant la liste a\*` un tableau temporaire, mais ce
n'est plus le cas (pour des raisons d'efficacite\*'). Cela veut dire que
vous ite\*'rez maintenant sur les vraies valeurs de la liste, pas sur des
copies de ces valeurs. Les modifications de la variable de boucle
peuvent changer les valeurs originelles.
.Sp
.Vb 5
\&    @list = ('ab','abc','bcd','def');
\&    foreach $var (grep(/ab/,@list)){
\&        $var = 1;
\&    }
\&    print (join(':',@list));
\&
\&    # perl4 affiche : ab:abc:bcd:def
\&    # perl5 affiche : 1:1:bcd:def
.Ve
.Sp
Pour garder la se\*'mantique de Perl4, vous devrez affecter explicitement
votre liste a\*` un tableau temporaire puis ite\*'rer dessus. Vous pourriez
par exemple devoir changer
.Sp
.Vb 1
\&    foreach $var (grep(/ab/,@list)){
.Ve
.Sp
en
.Sp
.Vb 1
\&    foreach $var (@tmp = grep(/ab/,@list)){
.Ve
.Sp
Sinon changer \f(CW$var\fR modifiera les valeurs de \f(CW@list\fR (Cela arrive le plus
souvent lorsque vous utilisez \f(CW$_\fR comme variable de boucle, et
appelez dans celle-ci des sous-programmes qui ne localisent pas
correctement \f(CW$_\fR).
.IP "\(bu" 4
\&\f(CW\*(C`split\*(C'\fR sans argument a change\*' de comportement
.Sp
\&\f(CW\*(C`split\*(C'\fR sans argument se comporte de\*'sormais comme \f(CW\*(C`split ' '\*(C'\fR (qui
ne retourne pas de champ nul initial si \f(CW$_\fR commence par une espace),
il se comportait habituellement comme \f(CW\*(C`split /\es+/\*(C'\fR (qui le fait).
.Sp
.Vb 2
\&    $_ = ' hi mom';
\&    print join(':', split);
\&
\&    # perl4 affiche : :hi:mom
\&    # perl5 affiche : hi:mom
.Ve
.IP "\(bu" 4
comportement corrige\*' de l'option \fB\-e\fR
.Sp
Perl 4 ignorait tout texte attache\*' a\*` une option \fB\-e\fR, et prenait
toujours le petit bout de code dans l'argument suivant. Qui plus est,
il acceptait silencieusement une option \fB\-e\fR non suivie d'un
argument. Ces deux comportements ont e\*'te\*' supprime\*'s.
.Sp
.Vb 1
\&    perl \-e'print "attached to \-e"' 'print "separate arg"'
\&
\&    # perl4 affiche : separate arg
\&    # perl5 affiche : attached to \-e
\&
\&    perl \-e
\&
\&    # perl4 affiche :
\&    # perl5 meurt : No code specified for \-e.
.Ve
.IP "\(bu" 4
\&\f(CW\*(C`push\*(C'\fR retourne le nombre d'e\*'le\*'ments de la liste re\*'sultante
.Sp
En Perl 4, la valeur de retour de \f(CW\*(C`push\*(C'\fR n'e\*'tait pas documente\*'e, mais
c'e\*'tait en fait la dernie\*`re valeur pousse\*'e sur la liste cible. En Perl
5, la valeur de retour de \f(CW\*(C`push\*(C'\fR est documente\*'e, mais elle a change\*',
c'est de\*'sormais le nombre d'e\*'le\*'ments de la liste re\*'sultante.
.Sp
.Vb 2
\&    @x = ('existing');
\&    print push(@x, 'first new', 'second new');
\&
\&    # perl4 affiche : second new
\&    # perl5 affiche : 3
.Ve
.IP "\(bu" 4
Certains messages d'erreur ont change\*'
.Sp
Certains messages d'erreur sont diffe\*'rents.
.IP "\(bu" 4
\&\f(CW\*(C`split\*(C'\fR respecte les arguments des sous-programmes
.Sp
En Perl 4, dans un contexte de liste, si les de\*'limiteurs du premier
argument de \f(CW\*(C`split()\*(C'\fR e\*'taient \f(CW\*(C`??\*(C'\fR, le re\*'sultat e\*'tait place\*' dans
\&\f(CW@_\fR tout en e\*'tant retourne\*' normalement. Perl 5 respecte maintenant
les arguments de vos sous\-programmes.
.IP "\(bu" 4
Bogues supprime\*'s
.Sp
Certains bugs ont peut\-e\*^tre e\*'te\*' supprime\*'s par inadvertance. :\-)
.Sh "Pie\*`ges de l'analyse syntaxique"
.IX Subsection "Pie`ges de l'analyse syntaxique"
Pie\*`ges entre Perl4 et Perl5 ayant un rapport avec l'analyse syntaxique.
.IP "\(bu" 4
Un espace entre . et = produit une erreur
.Sp
Notez l'espace entre . et =
.Sp
.Vb 2
\&    $string . = "more string";
\&    print $string;
\&
\&    # perl4 affiche: more string
\&    # perl5 affiche : syntax error at \- line 1, near ". ="
.Ve
.IP "\(bu" 4
Meilleure analyse syntaxique en perl 5
.Sp
L'analyse syntaxique est meilleure en perl 5
.Sp
.Vb 3
\&    sub foo {}
\&    &foo
\&    print("hello, world\en");
\&
\&    # perl4 affiche : hello, world
\&    # perl5 affiche : syntax error
.Ve
.IP "\(bu" 4
analyse syntaxique des fonctions
.Sp
Re\*`gle \*(L"si c\*,a a l'air d'une fonction, c'est une fonction\*(R".
.Sp
.Vb 2
\&  print
\&    ($foo == 1) ? "is one\en" : "is zero\en";
\&
\&    # perl4 affiche : is zero
\&    # perl5 avertit : "Useless use of a constant in void context" if using \-w
.Ve
.IP "\(bu" 4
L'interpolation de la construction $#tableau a change\*'
.Sp
L'interpolation de chai\*^ne de la structure \f(CW$#tableau\fR diffe\*`re lorsque
des accolades sont utilise\*'es autour du nom.
.Sp
.Vb 2
\&    @a = (1..3);
\&    print "${#a}";
\&
\&    # perl4 affiche : 2
\&    # perl5 e\*'choue sur une erreur de syntaxe
\&
\&    @a = (1..3);
\&    print "$#{a}";
\&
\&    # perl4 affiche : {a}
\&    # perl5 affiche : 2
.Ve
.IP "\(bu" 4
Perl devine si un \f(CW\*(C`{\*(C'\fR qui suit un \f(CW\*(C`map\*(C'\fR ou un \f(CW\*(C`grep\*(C'\fR de\*'bute un \s-1BLOC\s0 ou une re\*'fe\*'rence a\*` une table de hachage
.Sp
Lorsque Perl rencontre \f(CW\*(C`map {\*(C'\fR (ou \f(CW\*(C`grep {\*(C'\fR), il doit deviner si
l'accolade \f(CW\*(C`{\*(C'\fR de\*'bute un nouveau \s-1BLOC\s0 ou une re\*'fe\*'rence a\*` une table de
hachage. Si il devine mal, il indiquera une erreur de syntaxe au
niveau de l'accolade fermante \f(CW\*(C`}\*(C'\fR et de le virgule manquante (ou
inattendue).
.Sp
Utilisez un \f(CW\*(C`+\*(C'\fR unaire avant l'accolade \f(CW\*(C`{\*(C'\fR d'une re\*'fe\*'rence a\*` une
table de hachage ou un \f(CW\*(C`+\*(C'\fR unaire applique\*' a\*` la premie\*`re chose qui
commence le \s-1BLOC\s0 (apre\*`s l'accolade \f(CW\*(C`{\*(C'\fR) pour que perl devine
correctement tout le temps. (Voir \*(L"map\*(R" in perlfunc.)
.Sh "Pie\*`ges nume\*'riques"
.IX Subsection "Pie`ges nume'riques"
Pie\*`ges entre Perl4 et Perl5 ayant un rapport avec les ope\*'rateurs
nume\*'riques, les ope\*'randes, ou leurs sorties.
.IP "\(bu" 5
Sortie formatte\*'e et chiffres significatifs
.Sp
Sortie formatte\*'e et chiffres significatifs. En ge\*'ne\*'ral, Perl 5 essaye
d'e\*^tre plus pre\*'cis. Par exemple, sur une Sparc sous Solaris\ :
.Sp
.Vb 2
\&    print 7.373504 \- 0, "\en";
\&    printf "%20.18f\en", 7.373504 \- 0;
\&
\&    # Perl4 affiche :
\&    7.373503999999996141
\&    7.37350399999999614
\&
\&    # Perl5 affiche :
\&    7.373504
\&    7.37350399999999614
.Ve
.Sp
Remarquez que le premier re\*'sultat est mieux en Perl 5.
.Sp
Les re\*'sultats que vous obtenez sont variables puisque vos fonctions
d'affichage des flottants et vos flottants eux\-me\*^me peuvent e\*^tre
diffe\*'rents.
.IP "\(bu" 5
De\*'tection du de\*'passement de l'entier signe\*' maximale lors d'une
auto\-incre\*'mentation
.Sp
Cette de\*'tection a e\*'te\*' re\*'tablie. Auparavant on pouvait montre que
l'ope\*'rateur d'auto\-incre\*'mentation ne voyait pas qu'un nombre avait
de\*'passe\*' la limite supe\*'rieure des entiers signe\*'s. Cela a e\*'te\*' re\*'gle\*' dans
la version 5.003_04. Mais soyez toujours prudent lorsque vous utilisez
de grands entiers. En cas de doute\ :
.Sp
.Vb 1
\&   use Math::BigInt;
.Ve
.IP "\(bu" 5
L'affectation du re\*'sultat d'un test d'e\*'galite\*' nume\*'rique ne fonctionne pas
.Sp
L'affectation du re\*'sultat d'un test d'e\*'galite\*' nume\*'rique ne fonctionne
pas en perl5 lorsque le test e\*'choue (auparavant il renvoyait 0). Les
tests logique retourne maintenant une chai\*^ne vide, au lieu de 0.
.Sp
.Vb 2
\&    $p = ($test == 1);
\&    print $p,"\en";
\&
\&    # perl4 affiche : 0
\&    # perl5 affiche :
.Ve
.Sp
Voir aussi \*(L"//, etc.\*(R"\*(L" in \*(R"Pie\*`ges des expressions rationnelles ge\*'ne\*'rales lors de
l'utilisation de s pour un autre exemple de cette nouvelle
caracte\*'ristique...
.IP "\(bu" 5
Ope\*'rateurs de chai\*^ne bit par bit
.Sp
Lorsque des ope\*'rateurs bit par bit qui peuvent travailler sur des
nombres ou sur des chai\*^nes (\f(CW\*(C`& | ^ ~\*(C'\fR) n'ont que des chai\*^nes pour
arguments, perl4 traite les ope\*'randes comme des chai\*^nes de bits dans
la mesure ou\*` le programme contenait un appel a\*` la fonction
\&\f(CW\*(C`vec()\*(C'\fR. perl5 traite les ope\*'randes chai\*^nes comme des chai\*^nes de bits
(Voir \*(L"Ope\*'rateurs bit a\*` bit sur les chai\*^nes\*(R" in perlop pour plus de
de\*'tails).
.Sp
.Vb 6
\&    $fred = "10";
\&    $barney = "12";
\&    $betty = $fred & $barney;
\&    print "$betty\en";
\&    # De\*'commentez la ligne suivante pour changer le comportement de perl4
\&    # ($dummy) = vec("dummy", 0, 0);
\&
\&    # Perl4 affiche :
\&    8
\&
\&    # Perl5 affiche :
\&    10
\&
\&    # Si vec() est utilise\*' quelque part dans le programme, les deux
\&    # affichent :
\&    10
.Ve
.Sh "Pie\*`ges des types de donne\*'es ge\*'ne\*'raux"
.IX Subsection "Pie`ges des types de donne'es ge'ne'raux"
Pie\*`ges entre Perl4 et Perl5 impliquant la plupart des types de donne\*'es, et
leur usage dans certaines expressions et/ou contextes.
.IP "\(bu" 5
Les indices ne\*'gatifs partent maintenant de la fin du tableau
.Sp
Les indices de tableau ne\*'gatifs sont maintenant compte\*'s depuis la fin
du tableau.
.Sp
.Vb 2
\&    @a = (1, 2, 3, 4, 5);
\&    print "The third element of the array is $a[3] also expressed as $a[\-2] \en";
\&
\&    # perl4 affiche : The third element of the array is 4 also expressed as
\&    # perl5 affiche : The third element of the array is 4 also expressed as 4
.Ve
.IP "\(bu" 5
Diminuer la valeur de \f(CW$#tableau\fR supprime les e\*'le\*'ments du tableau
.Sp
De\*'sormais, diminuer la valeur de \f(CW$#array\fR supprime re\*'ellement les
e\*'le\*'ments exce\*'dentaires du tableau, et rend impossible leur
re\*'cupe\*'ration.
.Sp
.Vb 6
\&    @a = (a,b,c,d,e);
\&    print "Before: ",join('',@a);
\&    $#a =1;
\&    print ", After: ",join('',@a);
\&    $#a =3;
\&    print ", Recovered: ",join('',@a),"\en";
\&
\&    # perl4 affiche : Before: abcde, After: ab, Recovered: abcd
\&    # perl5 affiche : Before: abcde, After: ab, Recovered: ab
.Ve
.IP "\(bu" 5
Les tables de hachage sont de\*'finies me\*^me vide
.Sp
Les hachages sont de\*'finis avant me\*^me d'e\*^tre remplie
.Sp
.Vb 4
\&    local($s,@a,%h);
\&    die "scalar \e$s defined" if defined($s);
\&    die "array \e@a defined" if defined(@a);
\&    die "hash \e%h defined" if defined(%h);
\&
\&    # perl4 affiche :
\&    # perl5 meurt : hash %h defined
.Ve
.Sp
Perl ge\*'ne\*`re de\*'sormais un avertissement lorsqu'il voit defined(@a) et
defined(%h).
.IP "\(bu" 5
Affectation globale de variable localise\*'e a\*` variable
.Sp
L'affectation globale de variable a\*` variable e\*'chouera si la variable
affecte\*'e est localise\*'e apre\*`s l'affectation
.Sp
.Vb 4
\&    @a = ("This is Perl 4");
\&    *b = *a;
\&    local(@a);
\&    print @b,"\en";
\&
\&    # perl4 affiche : This is Perl 4
\&    # perl5 affiche :
.Ve
.IP "\(bu" 5
Affection globale de \f(CW\*(C`undef\*(C'\fR
.Sp
L'affectation globale de \f(CW\*(C`undef\*(C'\fR n'a pas d'effet en Perl 5. En Perl
4, elle rend inde\*'fini le scalaire associe\*' (mais peut avoir d'autres
effets secondaires, y compris des \s-1SEGV\s0). Perl 5 e\*'met un avertissement
lorsqu'on affecte globalement \f(CW\*(C`undef\*(C'\fR (Notez bien que l'affectation
globale de \f(CW\*(C`undef\*(C'\fR n'est pas la me\*^me chose que d'appliquer la
fonction \f(CW\*(C`undef\*(C'\fR a\*` une variable globale (\f(CW\*(C`undef $foo\*(C'\fR)).
.Sp
.Vb 3
\&    $foo = "bar";
\&    *foo = undef;
\&    print $foo;
\&  
\&    # perl4 affiche :
\&    # perl4 avertit : "Use of uninitialized variable" si \-w
\&    # perl5 affiche : bar
\&    # perl5 avertit : "Undefined value assigned to typeglob" si \-w
.Ve
.IP "\(bu" 5
Changements dans la ne\*'gation unaire (de chai\*^nes)
.Sp
Changements dans la ne\*'gation unaire (de chai\*^nes). Ce changement
affecte a\*` la fois la valeur de retour et ce qu'elle fait a\*` l'incre\*'ment
automagique.
.Sp
.Vb 4
\&    $x = "aaa";
\&    print ++$x," : ";
\&    print \-$x," : ";
\&    print ++$x,"\en";
\&
\&    # perl4 affiche : aab : \-0 : 1
\&    # perl5 affiche : aab : \-aab : aac
.Ve
.IP "\(bu" 5
Modifier une constante est interdit
.Sp
perl 4 vous laisse modifier les constantes\ :
.Sp
.Vb 10
\&    $foo = "x";
\&    &mod($foo);
\&    for ($x = 0; $x < 3; $x++) {
\&        &mod("a");
\&    }
\&    sub mod {
\&        print "before: $_[0]";
\&        $_[0] = "m";
\&        print "  after: $_[0]\en";
\&    }
\&
\&    # perl4:
\&    # before: x  after: m
\&    # before: a  after: m
\&    # before: m  after: m
\&    # before: m  after: m
\&
\&    # Perl5:
\&    # before: x  after: m
\&    # Modification of a read\-only value attempted at foo.pl line 12.
\&    # before: a
.Ve
.IP "\(bu" 5
Le comportement de \f(CW\*(C`defined $var\*(C'\fR a change\*'
.Sp
Le comportement est le\*'ge\*`rement diffe\*'rent pour\ :
.Sp
.Vb 1
\&    print "$x", defined $x
\&
\&    # perl 4: 1
\&    # perl 5: <no output, $x is not called into existence>
.Ve
.IP "\(bu" 5
Suicide de variable
.Sp
Le suicide de variable est plus cohe\*'rent sous Perl 5. Perl5 montre le
me\*^me comportement pour les hachages et les scalaires, que celui
montrer par Perl4 uniquement pour les scalaires.
.Sp
.Vb 4
\&    $aGlobal{ "aKey" } = "global value";
\&    print "MAIN:", $aGlobal{"aKey"}, "\en";
\&    $GlobalLevel = 0;
\&    &test( *aGlobal );
\&
\&    sub test {
\&        local( *theArgument ) = @_;
\&        local( %aNewLocal ); # perl 4 != 5.001l,m
\&        $aNewLocal{"aKey"} = "this should never appear";
\&        print "SUB: ", $theArgument{"aKey"}, "\en";
\&        $aNewLocal{"aKey"} = "level $GlobalLevel";   # what should print
\&        $GlobalLevel++;
\&        if( $GlobalLevel<4 ) {
\&            &test( *aNewLocal );
\&        }
\&    }
\&
\&    # Perl4:
\&    # MAIN:global value
\&    # SUB: global value
\&    # SUB: level 0
\&    # SUB: level 1
\&    # SUB: level 2
\&
\&    # Perl5:
\&    # MAIN:global value
\&    # SUB: global value
\&    # SUB: this should never appear
\&    # SUB: this should never appear
\&    # SUB: this should never appear
.Ve
.Sh "Pie\*`ges du contexte \- contextes scalaires et de liste"
.IX Subsection "Pie`ges du contexte - contextes scalaires et de liste"
.RS 5
*****
.Sp
* Les e\*'le\*'ments des liste d'arguments des formats sont e\*'value\*'s dans un contexte de liste
.Sp
Les e\*'le\*'ments des listes d'arguments pour les formats sont de\*'sormais
e\*'value\*'s dans un contexte de liste. Cela signifie que vous pouvez
maintenant interpoler les valeurs de liste.
.Sp
.Vb 6
\&    @fmt = ("foo","bar","baz");
\&    format STDOUT=
\&    @<<<<< @||||| @>>>>>
\&    @fmt;
\&    .
\&    write;
\&
\&    # erreur de perl4 :  Please use commas to separate fields in file
\&    # perl5 affiche : foo     bar      baz
.Ve
.Sp
* \f(CW\*(C`caller\*(C'\fR retourne faux si il est e\*'value\*' dans un context scalaire et qu'il n'y a pas d'appelant
.Sp
La fonction \f(CW\*(C`caller()\*(C'\fR retourne maintenant la valeur faux dans un
contexte scalaire s'il n'y a pas d'appelant. Cela laisse les fichiers
de bibliothe\*`que de\*'terminer s'ils sont en train d'e\*^tre demande\*'s.
.Sp
.Vb 1
\&    caller() ? (print "You rang?\en") : (print "Got a 0\en");
\&
\&    # erreur de perl4 : There is no caller
\&    # perl5 affiche : Got a 0
.Ve
.Sp
* L'ope\*'rateur virgule dans un contexte scalaire donne un contexte scalaire a\*` ses arguments
.Sp
L'ope\*'rateur virgule dans un contexte scalaire est de\*'sormais garanti
comme donnant un contexte scalaire a\*` ses arguments.
.Sp
.Vb 3
\&    @y= ('a','b','c');
\&    $x = (1, 2, @y);
\&    print "x = $x\en";
\&
\&    # Perl4 affiche :  x = c  # pense contexte de liste,
\&                              # interpole la liste
\&    # Perl5 affiche :  x = 3  # sait que le scalaire utilise la
\&                              # longueur de la liste
.Ve
.Sp
* \f(CW\*(C`sprintf()\*(C'\fR est prototype\*' comme \f(CW\*(C`($;@)\*(C'\fR
.Sp
La fonction \f(CW\*(C`sprintf()\*(C'\fR utilise maintenant le prototype
\&\f(CW\*(C`($;@)\*(C'\fR. Elle donne donc un contexte scalaire a\*` son premier
argument. Donc\*, si vous lui passer un tableau, elle ne fera
probablement pas ce que vous souhaitez contrairement a\*` Perl 4\ :
.Sp
.Vb 3
\&    @z = ('%s%s', 'foo', 'bar');
\&    $x = sprintf(@z);
\&    print $x;
\&  
\&    # perl4 affiche : foobar
\&    # perl5 affiche : 3
.Ve
.Sp
\&\f(CW\*(C`printf()\*(C'\fR continue a\*` fonctionner comme en Perl 4. Donc\ :
.Sp
.Vb 2
\&    @z = ('%s%s', 'foo', 'bar');
\&    printf STDOUT (@z);
\&
\&    # perl4 affiche : foobar
\&    # perl5 affiche : foobar
.Ve
.RE
.Sh "Pie\*`ges de la pre\*'ce\*'dence (les priorite\*'s)"
.IX Subsection "Pie`ges de la pre'ce'dence (les priorite's)"
Pie\*`ges entre Perl4 et Perl5 impliquant l'ordre de pre\*'ce\*'dence.
.PP
Perl 4 a presque les me\*^mes re\*`gles de pre\*'ce\*'dence que Perl 5 pour les
ope\*'rateurs qu'ils ont en commun. Toutefois, Perl 4 semble avoir
contenu des incohe\*'rences ayant rendu son comportement diffe\*'rent de
celui qui e\*'tait documente\*'.
.IP "\(bu" 5
\&\s-1LHS\s0 vs. \s-1RHS\s0 pour tout ope\*'rateur d'affectation
.Sp
\&\s-1LHS\s0 vs. \s-1RHS\s0 pour tout ope\*'rateur d'affectation. \s-1LHS\s0 est d'abord e\*'value\*'
en perl4, mais en second en perl5 ; ceci peut modifier les relations
entre les effets de bord dans les sous\-expressions.
.Sp
.Vb 3
\&    @arr = ( 'left', 'right' );
\&    $a{shift @arr} = shift @arr;
\&    print join( ' ', keys %a );
\&
\&    # perl4 affiche : left
\&    # perl5 affiche : right
.Ve
.IP "\(bu" 5
Erreurs se\*'mantiques dues aux re\*`gles de pre\*'ce\*'dence
.Sp
Voici des expressions devenues des erreurs se\*'mantiques a\*` cause de la
pre\*'ce\*'dence\ :
.Sp
.Vb 6
\&    @list = (1,2,3,4,5);
\&    %map = ("a",1,"b",2,"c",3,"d",4);
\&    $n = shift @list + 2;   # premier e\*'le\*'ment de la liste plus 2
\&    print "n is $n, ";
\&    $m = keys %map + 2;     # nombre d'e\*'le\*'ments du hachage plus 2
\&    print "m is $m\en";
\&
\&    # perl4 affiche : n is 3, m is 6
\&    # erreur de perl5 et e\*'chec de la compilation
.Ve
.IP "\(bu" 5
Pre\*'ce\*'dence identique pour les ope\*'rateurs d'affectation et l'affectation
.Sp
La pre\*'ce\*'dence des ope\*'rateurs d'affectation est de\*'sormais la me\*^me que
celle de l'affectation. Perl 4 leur donnait par erreur la pre\*'ce\*'dence
de l'ope\*'rateur associe\*'. Vous devez donc maintenant les mettre entre
parenthe\*`ses dans les expressions telles que
.Sp
.Vb 1
\&    /foo/ ? ($a += 2) : ($a \-= 2);
.Ve
.Sp
Autrement
.Sp
.Vb 1
\&    /foo/ ? $a += 2 : $a \-= 2
.Ve
.Sp
serait analyse\*' de fac\*,on errone\*'e sous la forme
.Sp
.Vb 1
\&    (/foo/ ? $a += 2 : $a) \-= 2;
.Ve
.Sp
D'autre part,
.Sp
.Vb 1
\&    $a += /foo/ ? 1 : 2;
.Ve
.Sp
fonctionne de\*'sormais comme un programmeur C pourrait s'y attendre.
.IP "\(bu" 5
\&\f(CW\*(C`open\*(C'\fR peut ne\*'cessiter des parenthe\*`se autour du filehandle
.Sp
.Vb 1
\&    open FOO || die;
.Ve
.Sp
est de\*'sormais incorrect. Vous devez mettre le handle de fichier entre
parenthe\*`ses. Sinon, perl5 laisse sa pre\*'ce\*'dence par de\*'faut a\*`
l'instruction\ :
.Sp
.Vb 1
\&    open(FOO || die);
\&
\&    # perl4 ouvre ou meurt
\&    # perl5 ouvre FOO, et ne mourrait que si 'FOO' e\*'tait faux, c.\-a\*`\-d. jamais
.Ve
.IP "\(bu" 5
Suppression de la priorite\*' de \f(CW$:\fR sur C\f(CW$::\fR
.Sp
perl4 donne la pre\*'ce\*'dence a\*` la variable spe\*'ciale \f(CW$:\fR, tandis que
perl5 traite \f(CW$::\fR comme e\*'tant le \f(CW\*(C`paquetage\*(C'\fR principale
.Sp
.Vb 1
\&    $a = "x"; print "$::a";
\&
\&    # perl 4 affiche : \-:a
\&    # perl 5 affiche : x
.Ve
.IP "\(bu" 5
Pre\*'ce\*'dence des ope\*'rateurs de test sur fichiers telle que documente\*'e
.Sp
perl4 a une pre\*'ce\*'dence buggue\*'e pour les ope\*'rateurs de test de fichiers
vis\-a\*`\-vis des ope\*'rateurs d'affectation. Ainsi, bien que la table de
pre\*'ce\*'dence de perl4 laisse a\*` penser que \f(CW\*(C`\-e $foo .= "q"\*(C'\fR devrait e\*^tre
analyse\*' comme \f(CW\*(C`((\-e $foo) .= "q")\*(C'\fR, il l'analyse en fait comme \f(CW\*(C`(\-e
($foo .= "q"))\*(C'\fR. En perl5, la pre\*'ce\*'dence est telle que documente\*'e.
.Sp
.Vb 1
\&    \-e $foo .= "q"
\&
\&    # perl4 affiche : no output
\&    # perl5 affiche : Can't modify \-e in concatenation
.Ve
.IP "\(bu" 5
\&\f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`each\*(C'\fR, \f(CW\*(C`values\*(C'\fR sont des ope\*'rateurs unaires nomme\*'s normaux
.Sp
En perl4, \f(CW\*(C`keys()\*(C'\fR, \f(CW\*(C`each()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR e\*'taient des ope\*'rateurs spe\*'ciaux
de haute pre\*'ce\*'dence qui agissaient sur un simple hachage, mais en
perl5, ce sont des ope\*'rateurs unaires nomme\*'s normaux. Tels que
documente\*'s, ces ope\*'rateurs ont une pre\*'ce\*'dence plus basse que les
ope\*'rateurs arithme\*'tiques et de concate\*'nation \f(CW\*(C`+ \- .\*(C'\fR, mais les
variantes de perl4 de ces ope\*'rateurs se lient en fait plus e\*'troitement
que \f(CW\*(C`+ \- .\*(C'\fR. Ainsi, pour\ :
.Sp
.Vb 2
\&    %foo = 1..10;
\&    print keys %foo \- 1
\&
\&    # perl4 affiche : 4
\&    # perl5 affiche : Type of arg 1 to keys must be hash (not subtraction)
.Ve
.Sp
Le comportement de perl4 e\*'tait probablement plus utile, mais moins
cohe\*'rent.
.Sh "Pie\*`ges des expressions rationnelles ge\*'ne\*'rales lors de l'utilisation de s///, etc."
.IX Subsection "Pie`ges des expressions rationnelles ge'ne'rales lors de l'utilisation de s///, etc."
Tous types de pie\*`ges concernant les expressions rationnelles.
.IP "\(bu" 5
\&\f(CW\*(C`s'$lhs'$rhs'\*(C'\fR n'effectue d'interpolation ni d'un co\*^te\*' ni de l'autre
.Sp
\&\f(CW\*(C`s'$lhs'$rhs'\*(C'\fR n'effectue de\*'sormais d'interpolation ni d'un co\*^te\*' ni
de l'autre. \f(CW$lhs\fR e\*'tait habituellement interpole\*', mais pas \f(CW$rhs\fR (et ne
de\*'tecte toujours pas un '$' litte\*'ral dans la chai\*^ne)
.Sp
.Vb 4
\&    $a=1;$b=2;
\&    $string = '1 2 $a $b';
\&    $string =~ s'$a'$b';
\&    print $string,"\en";
\&
\&    # perl4 affiche : $b 2 $a $b
\&    # perl5 affiche : 1 2 $a $b
.Ve
.IP "\(bu" 5
\&\f(CW\*(C`/m//g\*(C'\fR attache son e\*'tat a\*` la chai\*^ne fouille\*'e
.Sp
\&\f(CW\*(C`m//g\*(C'\fR attache maintenant son e\*'tat a\*` la chai\*^ne fouille\*'e pluto\*^t que
l'expression rationnelle (une fois que la porte\*'e d'un bloc est
quitte\*'e pour le sous\-programme, l'e\*'tat de la chai\*^ne fouille\*'e est
perdu)
.Sp
.Vb 5
\&    $_ = "ababab";
\&    while(m/ab/g){
\&        &doit("blah");
\&    }
\&    sub doit{local($_) = shift; print "Got $_ "}
\&
\&    # perl4 affiche : Got blah Got blah Got blah Got blah
\&    # perl5 affiche : boucle infinie de blah...
.Ve
.IP "\(bu" 5
\&\f(CW\*(C`m//o\*(C'\fR utilise\*' dans un sous-programme anonyme
.Sp
Couramment, si vous utilisez le qualificateur \f(CW\*(C`m//o\*(C'\fR sur une
expression rationnelle dans un sous-programme anonyme, \fItoutes\fR les
fermetures ge\*'ne\*'re\*'es dans ce sous-programme anonyme utiliseront
l'expression rationnelle telle qu'elle a e\*'te\*' compile\*'e lors de sa toute
premie\*`re utilisation dans une telle fermeture. Par exemple, si vous
dites
.Sp
.Vb 9
\&    sub build_match {
\&        my($left,$right) = @_;
\&        return sub { $_[0] =~ /$left stuff $right/o; };
\&    }
\&    $good = build_match('foo','bar');
\&    $bad = build_match('baz','blarch');
\&    print $good\->('foo stuff bar') ? "ok\en" : "not ok\en";
\&    print $bad\->('baz stuff blarch') ? "ok\en" : "not ok\en";
\&    print $bad\->('foo stuff bar') ? "not ok\en" : "ok\en";
.Ve
.Sp
Pour la plupart des distribution de Perl5, cela affichera\ :
.Sp
.Vb 3
\&  ok
\&  not ok
\&  not ok
.Ve
.Sp
\&\f(CW\*(C`build_match()\*(C'\fR retournera toujours un sous-programme qui correspondra
au contenu de \f(CW$left\fR et de \f(CW$right\fR tels qu'ils e\*'taient la \fIpremie\*`re\fR
fois que \f(CW\*(C`build_match()\*(C'\fR a e\*'te\*' appele\*', et pas tels qu'ils sont dans
l'appel en cours.
.IP "\(bu" 5
\&\f(CW$+\fR ne contient plus la chai\*^ne reconnue
.Sp
Si aucune parenthe\*`se n'est utilise\*'e dans une correspondance, Perl4
fixe \f(CW$+\fR a\*` toute la corerspondance, tout comme \f(CW$&\fR. Perl5 ne le
fait pas.
.Sp
.Vb 2
\&    "abcdef" =~ /b.*e/;
\&    print "\e$+ = $+\en";
\&
\&    # perl4 affiche : bcde
\&    # perl5 affiche :
.Ve
.IP "\(bu" 5
Une substitution retoure la chai\*^ne vide si elle e\*'choue
.Sp
La substitution retourne de\*'sormais la chai\*^ne vide si elle e\*'choue
.Sp
.Vb 3
\&    $string = "test";
\&    $value = ($string =~ s/foo//);
\&    print $value, "\en";
\&
\&    # perl4 affiche : 0
\&    # perl5 affiche :
.Ve
.Sp
Voir aussi \*(L"Pie\*`ges Nume\*'riques\*(R" pour un autre exemple de cette
nouvelle caracte\*'ristique.
.IP "\(bu" 5
\&\f(CW\*(C`s`lhs`rhs`\*(C'\fR est une substitution normale
.Sp
\&\f(CW\*(C`s`lhs`rhs`\*(C'\fR (en utilisant des accents graves) est maintenant une
substitution normale, sans expansion des accents graves
.Sp
.Vb 3
\&    $string = "";
\&    $string =~ s`^`hostname`;
\&    print $string, "\en";
\&
\&    # perl4 affiche : <the local hostname>
\&    # perl5 affiche : hostname
.Ve
.IP "\(bu" 5
Analyse stricte des variables utilise\*'es dans les expressions rationnelles
.Sp
Analyse plus stricte des variables utilise\*'es dans les expressions
rationnelles
.Sp
.Vb 1
\&    s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
\&
\&    # perl4: compile sans erreur
\&    # perl5: compile avec l'erreur :
\&    #   Scalar found where operator expected ..., near "$opt$plus"
.Ve
.Sp
un ajout a\*` cet exemple, apparemment depuis le me\*^me script, est la
ve\*'ritable valeur de la chai\*^ne apre\*`s la substitution. \f(CW\*(C`[$opt]\*(C'\fR est une
classe de caracte\*`re en perl4 et un indice de tableau en perl5
.Sp
.Vb 5
\&    $grpc = 'a';
\&    $opt  = 'r';
\&    $_ = 'bar';
\&    s/^([^$grpc]*$grpc[$opt]?)/foo/;
\&    print ;
\&
\&    # perl4 affiche : foo
\&    # perl5 affiche : foobar
.Ve
.IP "\(bu" 5
\&\f(CW\*(C`m?x?\*(C'\fR ne correspond qu'une seule fois
.Sp
Sous perl5, \f(CW\*(C`m?x?\*(C'\fR ne correspond qu'une fois, comme \f(CW\*(C`?x?\*(C'\fR. Sous
perl4, cela correspondait plusieurs fois, comme \f(CW\*(C`/x/\*(C'\fR ou \f(CW\*(C`m!x!\*(C'\fR.
.Sp
.Vb 10
\&    $test = "once";
\&    sub match { $test =~ m?once?; }
\&    &match();
\&    if( &match() ) {
\&        # m?x? correspond plusieurs fois
\&        print "perl4\en";
\&    } else {
\&        # m?x? correspond une seule fois
\&        print "perl5\en";
\&    }
\&
\&    # perl4 affiche : perl4
\&    # perl5 affiche : perl5
.Ve
.IP "\(bu" 5
L'e\*'chec d'une reconnaissance par expression rationnelle ne re\*'initialise pas les variables de reconnaissance
.Sp
Contrairement a\*` Ruby, l'e\*'chec d'une reconnaissance par expression
rationnelle ne re\*'initialise pas les variables de reconnaissance
(\f(CW$1\fR, \f(CW$2\fR, ..., \f(CW$`\fR, ...).
.Sh "Pie\*`ges des sous\-programmes, des signaux et des tris"
.IX Subsection "Pie`ges des sous-programmes, des signaux et des tris"
Le groupe ge\*'ne\*'ral de pie\*`ges entre Perl4 et Perl5 ayant un rapport avec
les Signaux, les Tris, et leurs sous-programmes associe\*'s, ainsi que
les pie\*`ges ge\*'ne\*'raux lie\*'s aux sous\-programmes. Cela inclut certains
pie\*`ges spe\*'cifiques au syste\*`me d'exploitation.
.IP "\(bu" 5
Les barewords (mots simples) sont conside\*'re\*'s comme des appels de sous-programmes
.Sp
Les barewords (mots simples) qui e\*'taient conside\*'re\*'s comme des chai\*^nes
pour Perl sont maintenant conside\*'re\*'s comme des appels de
sous-programmes si un sous-programme ayant ce nom est de\*'ja\*` de\*'fini (le
compilateur l'a de\*'ja\*` vu).
.Sp
.Vb 3
\&    sub SeeYa { warn"Hasta la vista, baby!" }
\&    $SIG{'TERM'} = SeeYa;
\&    print "SIGTERM is now $SIG{'TERM'}\en";
\&
\&    # perl4 affiche : SIGTERM is now main'SeeYa
\&    # perl5 affiche : SIGTERM is now main::1
.Ve
.Sp
Utilisez \fB\-w\fR pour capturer celui-ci
.IP "\(bu" 5
reverse n'est plus autorise\*' en tant que nom de sous-programme de tri
.Sp
reverse n'est plus autorise\*' en tant que nom de sous-programme de tri.
.Sp
.Vb 2
\&    sub reverse{ print "yup "; $a <=> $b }
\&    print sort reverse (2,1,3);
\&
\&    # perl4 affiche : yup yup 123
\&    # perl5 affiche : 123
\&    # perl5 avertit (si \-w) : Ambiguous call resolved as CORE::reverse()
.Ve
.IP "\(bu" 5
\&\f(CW\*(C`warn()\*(C'\fR ne vous laisse pas spe\*'cifier un handle de fichier.
.Sp
Bien qu'il ait _toujours_ imprime\*' sur \s-1STDERR\s0, \f(CW\*(C`warn()\*(C'\fR vous laissait
spe\*'cifier un handle de fichier en perl4. Avec perl5, ce n'est plus le
cas.
.Sp
.Vb 1
\&    warn STDERR "Foo!";
\&
\&    # perl4 affiche : Foo!
\&    # perl5 affiche : String found where operator expected
.Ve
.Sh "Pie\*`ges du syste\*`me d'exploitation"
.IX Subsection "Pie`ges du syste`me d'exploitation"
.IP "\(bu" 5
SysV re\*'initialise correctement un gestionnnaire de signal (signal handler)
.Sp
Sous \s-1HPUX\s0, et certains autres syste\*`mes d'exploitation de la famille
SysV, on devait re\*'initialiser tout handle de signal a\*` l'inte\*'rieur de
la fonction de gestion du signal, chaque fois qu'un signal e\*'tait
traite\*' avec perl4. Avec perl5, la re\*'initialisation est de\*'sormais faite
correctement. Tout code reposant sur un handler n'e\*'tant _pas_
re\*'initialise\*' devra e\*^tre re\*'e\*'crit.
.Sp
Depuis la version 5.002, Perl utilise \f(CW\*(C`sigaction()\*(C'\fR sous SysV.
.Sp
.Vb 4
\&    sub gotit {
\&        print "Got @_... ";
\&    }
\&    $SIG{'INT'} = 'gotit';
\&
\&    $| = 1;
\&    $pid = fork;
\&    if ($pid) {
\&        kill('INT', $pid);
\&        sleep(1);
\&        kill('INT', $pid);
\&    } else {
\&        while (1) {sleep(10);}
\&    }
\&
\&    # perl4 (HPUX) affiche : Got INT...
\&    # perl5 (HPUX) affiche : Got INT... Got INT...
.Ve
.IP "\(bu" 5
La fonction \f(CW\*(C`seek()\*(C'\fR sous SysV ajoute maintenant correctement
.Sp
Sous les syste\*`mes d'exploitation de la famille SysV, \f(CW\*(C`seek()\*(C'\fR sur un
fichier ouvert en mode d'ajout \f(CW\*(C`>>\*(C'\fR fait de\*'sormais ce qu'il
doit selon la page de manuel de \f(CW\*(C`fopen()\*(C'\fR.  C'est\-a\*`\-dire que lorsqu'un
fichier est ouvert en mode d'ajout, il est impossible d'e\*'craser les
informations de\*'ja\*` pre\*'sentes dans le fichier.
.Sp
.Vb 8
\&    open(TEST,">>seek.test");
\&    $start = tell TEST ;
\&    foreach(1 .. 9){
\&        print TEST "$_ ";
\&    }
\&    $end = tell TEST ;
\&    seek(TEST,$start,0);
\&    print TEST "18 characters here";
\&
\&    # perl4 (solaris) seek.test dit : 18 characters here
\&    # perl5 (solaris) seek.test dit : 1 2 3 4 5 6 7 8 9 18 characters here
.Ve
.Sh "Pie\*`ges de l'interpolation"
.IX Subsection "Pie`ges de l'interpolation"
Pie\*`ges entre Perl4 et Perl5 ayant un rapport avec la fac\*,on dont les
choses sont interpole\*'es dans certaines expressions, instructions, dans
certains contexts, ou quoi que ce soit d'autre.
.IP "\(bu" 5
Un \f(CW\*(C`@\*(C'\fR est de\*'sormais toujours interpole\*' en tant que tableau dans une chai\*^ne entre guillemets
.Sp
Un \f(CW\*(C`@\*(C'\fR est de\*'sormais toujours interpole\*' en tant que tableau dans une chai\*^ne entre guillemets
.Sp
.Vb 1
\&    print "To: someone@somewhere.com\en";
\&
\&    # perl4 affiche : To:someone@somewhere.com
\&    # perl < 5.6.1, erreur : In string, @somewhere now must be written as \e@somewhere
\&    # perl >= 5.6.1, avertissement : Possible unintended interpolation of @somewhere in string
.Ve
.IP "\(bu" 5
Une chai\*^ne entre guillemets ne peut plus se terminer par un $ sans e\*'chappement
.Sp
Les chai\*^nes entre guillemets ne peuvent plus se terminer par un $ non
prote\*'ge\*' par le caracte\*`re d'e\*'chappement.
.Sp
.Vb 2
\&    $foo = "foo$";
\&    print "foo is $foo\en";
\&
\&    # perl4 affiche : foo is foo$
\&    # erreur de perl5 : Final $ should be \e$ or $name
.Ve
.Sp
Note\ : perl5 \s-1NE\s0 ge\*'ne\*`re \s-1PAS\s0 une erreur pour un @ final.
.IP "\(bu" 5
Un expression quelconque entre accolades dans une chai\*^ne entre guillemets est e\*'value\*'e
.Sp
Perl e\*'value maintenant parfois des expressions quelconques place\*'es
entre accolades qui apparaissent entre des guillemets (habituellement
lorsque l'accolade ouvrante est pre\*'ce\*'de\*'e par \f(CW\*(C`$\*(C'\fR ou \f(CW\*(C`@\*(C'\fR).
.Sp
.Vb 5
\&    @www = "buz";
\&    $foo = "foo";
\&    $bar = "bar";
\&    sub foo { return "bar" };
\&    print "|@{w.w.w}|${main'foo}|";
\&
\&    # perl4 affiche : |@{w.w.w}|foo|
\&    # perl5 affiche : |buz|bar|
.Ve
.Sp
Notez que vous pouvez utiliser \f(CW\*(C`use strict;\*(C'\fR pour vous mettre a\*`
l'abri de tels pie\*`ges sous perl5.
.IP "\(bu" 5
\&\f(CW$$x\fR tente de de\*'re\*'fe\*'rencer \f(CW$x\fR
.Sp
La construction \*(L"this is $$x\*(R" interpolait le pid a\*` cet endroit, mais
elle essaye maintenant de de\*'re\*'fencer \f(CW$x\fR. \f(CW$$\fR tout seul fonctionne
toutefois toujours bien.
.Sp
.Vb 3
\&    $s = "a reference";
\&    $x = *s;
\&    print "this is $$x\en";
\&
\&    # perl4 affiche : this is XXXx   (XXX is the current pid)
\&    # perl5 affiche : this is a reference
.Ve
.IP "\(bu" 5
Le cre\*'ation d'une table de hachage au vol par un \f(CW\*(C`eval
"EXPR"\*(C'\fR doit e\*^tre prote\*'ge\*'e
.Sp
La cre\*'ation de hachage a\*` la vole\*'e par \f(CW\*(C`eval "EXPR"\*(C'\fR exige maintenant
soit que les deux \f(CW\*(C`$\*(C'\fR soient prote\*'ge\*'s dans la spe\*'cification du nom du
hachage, soit que les deux accolades soient prote\*'ge\*'es. Si les
accolades sont prote\*'ge\*'es, le re\*'sultat sera compatible entre perl4 et
perl5. C'est une pratique tre\*`s commune qui devrait e\*^tre modifie\*'e de
fac\*,on a\*` utiliser si possible la forme bloc d'\f(CW\*(C`eval{}\*(C'\fR.
.Sp
.Vb 5
\&    $hashname = "foobar";
\&    $key = "baz";
\&    $value = 1234;
\&    eval "\e$$hashname{'$key'} = q|$value|";
\&    (defined($foobar{'baz'})) ?  (print "Yup") : (print "Nope");
\&
\&    # perl4 affiche : Yup
\&    # perl5 affiche : Nope
.Ve
.Sp
En changeant
.Sp
.Vb 1
\&    eval "\e$$hashname{'$key'} = q|$value|";
.Ve
.Sp
par
.Sp
.Vb 1
\&    eval "\e$\e$hashname{'$key'} = q|$value|";
.Ve
.Sp
on obtient le re\*'sultat suivant\ :
.Sp
.Vb 2
\&    # perl4 affiche : Nope
\&    # perl5 affiche : Yup
.Ve
.Sp
ou en le changeant par
.Sp
.Vb 1
\&    eval "\e$$hashname\e{'$key'\e} = q|$value|";
.Ve
.Sp
on obtient le re\*'sultat suivant\ :
.Sp
.Vb 3
\&    # perl4 affiche : Yup
\&    # perl5 affiche : Yup
\&    # et est compatible avec les deux versions
.Ve
.IP "\(bu" 5
Bogues des versions pre\*'ce\*'dentes de perl
.Sp
Certains programmes perl4 se reposaient inconsciemment sur les bugs de
versions pre\*'ce\*'dentes de perl.
.Sp
.Vb 1
\&    perl \-e '$bar=q/not/; print "This is $foo{$bar} perl5"'
\&
\&    # perl4 affiche : This is not perl5
\&    # perl5 affiche : This is perl5
.Ve
.IP "\(bu" 5
Interpolation de crochets (tableaux) et des accolades (tables de hachage)
.Sp
Vous devez faire attention a\*` l'interpolation des crochets (tableaux)
et des accolades (tables de hachage).
.Sp
.Vb 1
\&    print "$foo["
\&
\&    perl 4 affiche : [
\&    perl 5 affiche : syntax error
\&
\&    print "$foo{"
\&
\&    perl 4 affiche : {
\&    perl 5 affiche : syntax error
.Ve
.Sp
Perl 5 s'attend a\*` trouver un indice (ou une cle\*') apre\*`s le crochet
ouvrant (ou l'accolade ouvrante) ainsi que le crochet fermant
(l'accolade fermante) correspondant. Pour retrouver le comportement de
Perl 4, vous devez prote\*'ger votre crochet (ou accolade) par le
caracte\*`re d'e\*'chappement.
.Sp
.Vb 2
\&    print "$foo\e[";
\&    print "$foo\e{";
.Ve
.IP "\(bu" 5
Interpolation de \f(CW\*(C`\e$$foo{bar}\*(C'\fR
.Sp
De fac\*,on similaire, prenez garde a\*` \f(CW\*(C`\e$$foo{bar}\*(C'\fR
.Sp
.Vb 2
\&    $foo = "baz";
\&    print "\e$$foo{bar}\en";
\&
\&    # perl4 affiche : $baz{bar}
\&    # perl5 affiche : $
.Ve
.Sp
Perl 5 cherche \f(CW$array{bar}\fR qui n'existe pas, mais perl 4 est
content de simplement substituer \f(CW$foo\fR par \*(L"baz\*(R". Faites attention a\*`
cela, en particulier dans les \f(CW\*(C`eval\*(C'\fR's.
.IP "\(bu" 5
Une chai\*^ne \f(CW\*(C`qq()\*(C'\fR dans un \f(CW\*(C`eval\*(C'\fR ne trouve pas sa fin de chai\*^ne
.Sp
Une chai\*^ne \f(CW\*(C`qq()\*(C'\fR passe\*'e a\*` \f(CW\*(C`eval\*(C'\fR pose le proble\*`me suivant\ :
.Sp
.Vb 5
\&    eval qq(
\&        foreach \e$y (keys %\e$x\e) {
\&            \e$count++;
\&        }
\&    );
\&
\&    # perl4 exe\*'cute cela sans proble\*`me
\&    # perl5 affiche : Can't find string terminator ")"
.Ve
.Sh "Pie\*`ges \s-1DBM\s0"
.IX Subsection "Pie`ges DBM"
Pie\*`ges ge\*'ne\*'raux de \s-1DBM\s0.
.IP "\(bu" 5
Perl5 doit e\*^tre lie\*' avec la me\*^me bibliothe\*`que dbm/ndbm que la version par de\*'faut de \f(CW\*(C`dbmopen()\*(C'\fR
.Sp
Les bases de donne\*'es existantes cre\*'e\*'es sous perl4 (ou tout autre outil
dbm/ndbm) peuvent faire e\*'chouer le me\*^me script une fois exe\*'cute\*' sous
perl5. L'exe\*'cutable de perl5 doit avoir e\*'te\*' lie\*' avec le me\*^me dbm/ndbm
par de\*'faut que \f(CW\*(C`dbmopen()\*(C'\fR pour qu'il fonctionne correctement sans
lien via \f(CW\*(C`tie\*(C'\fR vers une imple\*'mentation dbm sous forme d'extension.
.Sp
.Vb 2
\&    dbmopen (%dbm, "file", undef);
\&    print "ok\en";
\&
\&    # perl4 affiche : ok
\&    # perl5 affiche : ok (IFF linked with \-ldbm or \-lndbm)
.Ve
.IP "\(bu" 5
Un de\*'passement de la limite de taille d'une cle\*' ou d'une valeur \s-1DBM\s0 arre\*^te perl5 imme\*'diatement
.Sp
Les bases de donne\*'es existantes cre\*'e\*'es sous perl4 (ou tout autre outil
dbm/ndbm) peuvent faire e\*'chouer le me\*^me script une fois exe\*'cute\*' sous
perl5. L'erreur ge\*'ne\*'re\*'e lorsque la limite de la taille cle\*'/valeur est
de\*'passe\*'e provoquera la sortie imme\*'diate de perl5.
.Sp
.Vb 4
\&    dbmopen(DB, "testdb",0600) || die "couldn't open db! $!";
\&    $DB{'trap'} = "x" x 1024;  # valeur trop grande pour la plupart
\&                               # des dbm/ndbm
\&    print "YUP\en";
\&
\&    # perl4 affiche :
\&    dbm store returned \-1, errno 28, key "trap" at \- line 3.
\&    YUP
\&
\&    # perl5 affiche :
\&    dbm store returned \-1, errno 28, key "trap" at \- line 3.
.Ve
.Sh "Pie\*`ges non classe\*'s"
.IX Subsection "Pie`ges non classe's"
Tout le reste.
.IP "\(bu" 5
Pie\*`ge \f(CW\*(C`require\*(C'\fR/\f(CW\*(C`do\*(C'\fR utilisant la valeur de retour
.Sp
Si le fichier doit.pl contient\ :
.Sp
.Vb 5
\&    sub foo {
\&        $rc = do "./do.pl";
\&        return 8;
\&    }
\&    print &foo, "\en";
.Ve
.Sp
Et le fichier do.pl contient l'unique ligne suivante\ :
.Sp
.Vb 1
\&    return 3;
.Ve
.Sp
Exe\*'cuter doit.pl donne le re\*'sultat suivant\ :
.Sp
.Vb 2
\&    # perl 4 affiche : 3 (abandonne to\*^t le sous\-programme)
\&    # perl 5 affiche : 8
.Ve
.Sp
Le comportement est le me\*^me si vous remplacez \f(CW\*(C`do\*(C'\fR par \f(CW\*(C`require\*(C'\fR.
.IP "\(bu" 5
\&\f(CW\*(C`split\*(C'\fR sur une chai\*^ne vide avec une \s-1LIMIT\s0 spe\*'cifie\*'e
.Sp
.Vb 2
\&        $string = '';
\&    @list = split(/foo/, $string, 2)
.Ve
.Sp
Perl4 retourne une liste a\*` un e\*'le\*'ment contenant la chai\*^ne vide mais
Perl5 retourne une liste vide.
.PP
Comme toujours, si certains de ces pie\*`ges sont de\*'clare\*'s un jour
officiellement comme e\*'tant des bugs, ils seront corrige\*'s et retire\*'s.
.SH "TRADUCTION"
.IX Header "TRADUCTION"
.Sh "Version"
.IX Subsection "Version"
Cette traduction franc\*,aise correspond a\*` la version anglaise distribue\*'e avec
perl 5.8.8.  Pour en savoir plus concernant ces traductions, consultez
<http://perl.enstimac.fr/>.
.Sh "Traducteur"
.IX Subsection "Traducteur"
Tarduction initiale (5.6.0)\ : Roland Trique <\fIroland.trique@uhb.fr\fR>.
Mise a\*` jour (5.8.8)\ : Paul Gaborit <paul.gaborit at enstimac.fr>.
.Sh "Relecture"
.IX Subsection "Relecture"
Personne pour l'instant.
.SH "POD ERRORS"
.IX Header "POD ERRORS"
Hey! \fBThe above document had some coding errors, which are explained below:\fR
.IP "Around line 984:" 4
.IX Item "Around line 984:"
You can't have =items (as at line 988) unless the first thing after the =over is an =item