.\" 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 "PERLFUNC 1"
.TH PERLFUNC 1 "2006-03-25" "DocFr" "User Contributed Perl Documentation"
.SH "NAME/NOM"
.IX Header "NAME/NOM"
perlfunc \- Fonctions Perl pre\*'de\*'finies
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
Les fonctions de cette section peuvent e\*^tre utilise\*'es en tant que termes dans
une expression. Elles se se\*'parent en deux cate\*'gories principales\ : les
ope\*'rateurs de listes et les ope\*'rateurs unaires nomme\*'s. Ceux-ci diffe\*`rent dans
leurs relations de priorite\*' avec la virgule qui les suit. (Cf. la table de
priorite\*' dans perlop.) Les ope\*'rateurs de liste prennent plusieurs
arguments alors que les ope\*'rateurs unaires n'en prennent jamais plus d'un. Une
virgule termine alors l'argument d'un ope\*'rateur unaire mais se\*'pare les
arguments d'un ope\*'rateur de liste. Un ope\*'rateur unaire fournit en ge\*'ne\*'ral un
contexte scalaire a\*` son argument, alors qu'un ope\*'rateur de liste fournit un
contexte, soit scalaire, soit de liste, pour ses arguments. S'il propose les
deux, les arguments scalaires seront les premiers et la liste d'arguments
suivra. (Notez qu'il ne peut y avoir qu'une seule liste d'arguments.) Par
exemple, \fIsplice()\fR a trois arguments scalaires suivis d'une liste alors que
\&\fIgethostbyname()\fR a quatre arguments scalaires.
.PP
Dans la description syntaxique qui suit, les ope\*'rateurs de liste qui attendent
une liste (et fournissent un contexte de liste pour les e\*'le\*'ments de cette
liste) ont pour argument \s-1LISTE\s0. Une telle liste peut e\*^tre constitue\*'e de toute
combinaison de valeurs d'arguments scalaires ou de listes\ ; les valeurs de
listes seront incluses dans la liste comme si chaque e\*'le\*'ment individuel e\*'tait
interpole\*' a\*` cet emplacement de la liste, formant ainsi la valeur d'une longue
liste unidimensionnelle. Les e\*'le\*'ments de \s-1LISTE\s0 doivent e\*^tre se\*'pare\*'s par des
virgules.
.PP
Toute fonction de la liste ci-dessous peut e\*^tre utilise\*'e avec ou sans
parenthe\*`ses autour de ses arguments. (Les descriptions syntaxiques les
omettent) Si vous utilisez les parenthe\*`ses, la simple (mais parfois
surprenante) re\*`gle est la suivante\ : c\*,a \fI\s-1RESSEMBLE\s0\fR a\*` une fonction, donc
c'\fI\s-1EST\s0\fR une fonction, et la priorite\*' importe peu. Sinon, c'est un ope\*'rateur
de liste ou un ope\*'rateur unaire et la priorite\*' a son importance. Les
espaces entre la fonction et les parenthe\*`ses ne comptent pas, vous devez donc
faire parfois tre\*`s attention\ :
.PP
.Vb 5
\&    print 1+2+4;        # affiche 7.
\&    print(1+2) + 4;     # affiche 3.
\&    print (1+2)+4;      # affiche aussi 3 !
\&    print +(1+2)+4;     # affiche 7.
\&    print ((1+2)+4);    # affiche 7.
.Ve
.PP
Si vous exe\*'cutez Perl avec l'option \fB\-w\fR, vous pourrez en e\*^tre
averti. Par exemple, la troisie\*`me ligne ci-dessus ge\*'ne\*`re\ :
.PP
.Vb 2
\&    print (...) interpreted as function at \- line 1.
\&    Useless use of integer addition in void context at \- line 1.
.Ve
.PP
Quelques rares fonctions ne prennent aucun argument et ne sont donc ni des
ope\*'rateurs unaires ni des ope\*'rateurs de liste. Cela inclut des fonctions
telles que \f(CW\*(C`time\*(C'\fR et \f(CW\*(C`endpwent\*(C'\fR. Par exemple, \f(CW\*(C`time+86_400\*(C'\fR signifie
toujours \f(CW\*(C`time() + 86_400\*(C'\fR.
.PP
Pour les fonctions qui peuvent e\*^tre utilise\*'es dans un contexte
scalaire ou de liste, une erreur non fatale est ge\*'ne\*'ralement indique\*'e
dans un contexte scalaire en retournant la valeur inde\*'finie, et dans
un contexte de liste en retournant la liste nulle.
.PP
Rappelez-vous de l'importante re\*`gle suivante\ : il n'y a \fBaucune re\*`gle\fR qui
lie le comportement d'une expression dans un contexte de liste a\*` son
comportement dans un contexte scalaire, et re\*'ciproquement. Cela peut ge\*'ne\*'rer
deux re\*'sultats comple\*`tement diffe\*'rents. Chaque ope\*'rateur et chaque fonction
choisit le type de valeur qui semble le plus approprie\*' de retourner dans un
contexte scalaire. Certains ope\*'rateurs retournent la longueur de la liste qui
aurait e\*'te\*' retourne\*'e dans un contexte de liste. D'autres ope\*'rateurs retournent
la premie\*`re valeur. D'autres encore retournent la dernie\*`re valeur. D'autres
enfin retournent le nombre d'ope\*'rations re\*'ussies. En ge\*'ne\*'ral, ils font ce que
vous souhaitez, a\*` moins que vous ne vouliez de la consistance.
.PP
Un tableau nomme\*' en contexte scalaire est assez diffe\*'rent de ce qui
apparai\*^trait au premier coup d'oeil comme une liste dans un contexte
scalaire. Vous ne pouvez pas transformer une liste comme \f(CW\*(C`(1,2,3)\*(C'\fR dans un
contexte scalaire, car le compilateur connai\*^t le contexte a\*` la compilation. Il
ge\*'ne\*'rerait ici l'ope\*'rateur scalaire virgule, et non pas la version
construction de liste de la virgule. Ce qui signifie que c\*,a n'a jamais e\*'te\*'
conside\*'re\*' comme une liste avec laquelle travailler.
.PP
En ge\*'ne\*'ral, les fonctions en Perl qui encapsulent les appels syste\*`me du me\*^me
nom (comme \fIchown\fR\|(2), \fIfork\fR\|(2), \fIclosedir\fR\|(2), etc.) retournent toutes vrai quand
elles re\*'ussissent et \f(CW\*(C`undef\*(C'\fR sinon, comme c'est souvent mentionne\*'
ci\-dessous. C'est diffe\*'rent des interfaces\ C qui retournent \f(CW\*(C`\-1\*(C'\fR en cas
d'erreur. Les exceptions a\*` cette re\*`gle sont \f(CW\*(C`wait\*(C'\fR, \f(CW\*(C`waitpid()\*(C'\fR et
\&\f(CW\*(C`syscall()\*(C'\fR. Les appels syste\*`me positionnent aussi la variable spe\*'ciale \f(CW$!\fR
en cas d'erreur. Les autres fonctions ne le font pas, sauf de manie\*`re
accidentelle.
.Sh "Fonctions Perl par cate\*'gories"
.IX Subsection "Fonctions Perl par cate'gories"
Voici les fonctions Perl (y compris ce qui ressemble a\*` des fonctions, comme
certains mots\-cle\*'s et les ope\*'rateurs nomme\*'s) trie\*'es par cate\*'gorie. Certaines
fonctions apparaissent dans plusieurs cate\*'gories a\*` la fois.
.IP "Fonctions lie\*'es aux scalaires ou aux chai\*^nes de caracte\*`res" 4
.IX Item "Fonctions lie'es aux scalaires ou aux chai^nes de caracte`res"
\&\f(CW\*(C`chomp\*(C'\fR, \f(CW\*(C`chop\*(C'\fR, \f(CW\*(C`chr\*(C'\fR, \f(CW\*(C`crypt\*(C'\fR, \f(CW\*(C`hex\*(C'\fR, \f(CW\*(C`index\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`lcfirst\*(C'\fR,
\&\f(CW\*(C`length\*(C'\fR, \f(CW\*(C`oct\*(C'\fR, \f(CW\*(C`ord\*(C'\fR, \f(CW\*(C`pack\*(C'\fR, \f(CW\*(C`q/CHAINE/\*(C'\fR, \f(CW\*(C`qq/CHAINE/\*(C'\fR, \f(CW\*(C`reverse\*(C'\fR,
\&\f(CW\*(C`rindex\*(C'\fR, \f(CW\*(C`sprintf\*(C'\fR, \f(CW\*(C`substr\*(C'\fR, \f(CW\*(C`tr///\*(C'\fR, \f(CW\*(C`uc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, \f(CW\*(C`y///\*(C'\fR
.IP "Expressions rationnelles et reconnaissances de motifs" 4
.IX Item "Expressions rationnelles et reconnaissances de motifs"
\&\f(CW\*(C`m//\*(C'\fR, \f(CW\*(C`pos\*(C'\fR, \f(CW\*(C`quotemeta\*(C'\fR, \f(CW\*(C`s///\*(C'\fR, \f(CW\*(C`split\*(C'\fR, \f(CW\*(C`study\*(C'\fR, \f(CW\*(C`qr//\*(C'\fR
.IP "Fonctions nume\*'riques" 4
.IX Item "Fonctions nume'riques"
\&\f(CW\*(C`abs\*(C'\fR, \f(CW\*(C`atan2\*(C'\fR, \f(CW\*(C`cos\*(C'\fR, \f(CW\*(C`exp\*(C'\fR, \f(CW\*(C`hex\*(C'\fR, \f(CW\*(C`int\*(C'\fR, \f(CW\*(C`log\*(C'\fR, \f(CW\*(C`oct\*(C'\fR, \f(CW\*(C`rand\*(C'\fR,
\&\f(CW\*(C`sin\*(C'\fR, \f(CW\*(C`sqrt\*(C'\fR, \f(CW\*(C`srand\*(C'\fR
.ie n .IP "Fonctions lie\*'es aux ve\*'ritables @tableaux" 4
.el .IP "Fonctions lie\*'es aux ve\*'ritables \f(CW@tableaux\fR" 4
.IX Item "Fonctions lie'es aux ve'ritables @tableaux"
\&\f(CW\*(C`pop\*(C'\fR, \f(CW\*(C`push\*(C'\fR, \f(CW\*(C`shift\*(C'\fR, \f(CW\*(C`splice\*(C'\fR, \f(CW\*(C`unshift\*(C'\fR
.IP "Fonctions aux listes de donne\*'es" 4
.IX Item "Fonctions aux listes de donne'es"
\&\f(CW\*(C`grep\*(C'\fR, \f(CW\*(C`join\*(C'\fR, \f(CW\*(C`map\*(C'\fR, \f(CW\*(C`qw/CHAINE/\*(C'\fR, \f(CW\*(C`reverse\*(C'\fR, \f(CW\*(C`sort\*(C'\fR, \f(CW\*(C`unpack\*(C'\fR
.ie n .IP "Fonctions lie\*'es aux ve\*'ritables %tables de hachage" 4
.el .IP "Fonctions lie\*'es aux ve\*'ritables \f(CW%tables\fR de hachage" 4
.IX Item "Fonctions lie'es aux ve'ritables %tables de hachage"
\&\f(CW\*(C`delete\*(C'\fR, \f(CW\*(C`each\*(C'\fR, \f(CW\*(C`exists\*(C'\fR, \f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`values\*(C'\fR
.IP "Fonctions d'entre\*'e/sortie" 4
.IX Item "Fonctions d'entre'e/sortie"
\&\f(CW\*(C`binmode\*(C'\fR, \f(CW\*(C`close\*(C'\fR, \f(CW\*(C`closedir\*(C'\fR, \f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`die\*(C'\fR, \f(CW\*(C`eof\*(C'\fR,
\&\f(CW\*(C`fileno\*(C'\fR, \f(CW\*(C`flock\*(C'\fR, \f(CW\*(C`format\*(C'\fR, \f(CW\*(C`getc\*(C'\fR, \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`printf\*(C'\fR, \f(CW\*(C`read\*(C'\fR,
\&\f(CW\*(C`readdir\*(C'\fR, \f(CW\*(C`rewinddir\*(C'\fR, \f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`seekdir\*(C'\fR, \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR,
\&\f(CW\*(C`sysread\*(C'\fR, \f(CW\*(C`sysseek\*(C'\fR, \f(CW\*(C`syswrite\*(C'\fR, \f(CW\*(C`tell\*(C'\fR, \f(CW\*(C`telldir\*(C'\fR, \f(CW\*(C`truncate\*(C'\fR,
\&\f(CW\*(C`warn\*(C'\fR, \f(CW\*(C`write\*(C'\fR
.IP "Fonctions pour donne\*'es de longueur fixe ou pour enregistrements" 4
.IX Item "Fonctions pour donne'es de longueur fixe ou pour enregistrements"
\&\f(CW\*(C`pack\*(C'\fR, \f(CW\*(C`read\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR, \f(CW\*(C`sysread\*(C'\fR, \f(CW\*(C`syswrite\*(C'\fR, \f(CW\*(C`unpack\*(C'\fR, \f(CW\*(C`vec\*(C'\fR
.IP "Fonctions de descripteurs de fichiers, de fichiers ou de re\*'pertoires" 4
.IX Item "Fonctions de descripteurs de fichiers, de fichiers ou de re'pertoires"
\&\f(CW\*(C`\-\f(CIX\f(CW\*(C'\fR, \f(CW\*(C`chdir\*(C'\fR, \f(CW\*(C`chmod\*(C'\fR, \f(CW\*(C`chown\*(C'\fR, \f(CW\*(C`chroot\*(C'\fR, \f(CW\*(C`fcntl\*(C'\fR, \f(CW\*(C`glob\*(C'\fR,
\&\f(CW\*(C`ioctl\*(C'\fR, \f(CW\*(C`link\*(C'\fR, \f(CW\*(C`lstat\*(C'\fR, \f(CW\*(C`mkdir\*(C'\fR, \f(CW\*(C`open\*(C'\fR, \f(CW\*(C`opendir\*(C'\fR, \f(CW\*(C`readlink\*(C'\fR,
\&\f(CW\*(C`rename\*(C'\fR, \f(CW\*(C`rmdir\*(C'\fR, \f(CW\*(C`stat\*(C'\fR, \f(CW\*(C`symlink\*(C'\fR, \f(CW\*(C`sysopen\*(C'\fR, \f(CW\*(C`umask\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR,
\&\f(CW\*(C`utime\*(C'\fR
.IP "Mots\-cle\*'s lie\*'s au contro\*^le d'exe\*'cution de votre programme perl" 4
.IX Item "Mots-cle's lie's au contro^le d'exe'cution de votre programme perl"
\&\f(CW\*(C`caller\*(C'\fR, \f(CW\*(C`continue\*(C'\fR, \f(CW\*(C`die\*(C'\fR, \f(CW\*(C`do\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`eval\*(C'\fR, \f(CW\*(C`exit\*(C'\fR,
\&\f(CW\*(C`goto\*(C'\fR, \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, \f(CW\*(C`redo\*(C'\fR, \f(CW\*(C`return\*(C'\fR, \f(CW\*(C`sub\*(C'\fR, \f(CW\*(C`wantarray\*(C'\fR
.IP "Mots\-cle\*'s lie\*'s a\*` la porte\*'e" 4
.IX Item "Mots-cle's lie's a` la porte'e"
\&\f(CW\*(C`caller\*(C'\fR, \f(CW\*(C`import\*(C'\fR, \f(CW\*(C`local\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "Fonctions diverses" 4
.IX Item "Fonctions diverses"
\&\f(CW\*(C`defined\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`eval\*(C'\fR, \f(CW\*(C`formline\*(C'\fR, \f(CW\*(C`local\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`reset\*(C'\fR,
\&\f(CW\*(C`scalar\*(C'\fR, \f(CW\*(C`undef\*(C'\fR, \f(CW\*(C`wantarray\*(C'\fR
.IP "Fonctions de gestion des processus et des groupes de processus" 4
.IX Item "Fonctions de gestion des processus et des groupes de processus"
\&\f(CW\*(C`alarm\*(C'\fR, \f(CW\*(C`exec\*(C'\fR, \f(CW\*(C`fork\*(C'\fR, \f(CW\*(C`getpgrp\*(C'\fR, \f(CW\*(C`getppid\*(C'\fR, \f(CW\*(C`getpriority\*(C'\fR, \f(CW\*(C`kill\*(C'\fR,
\&\f(CW\*(C`pipe\*(C'\fR, \f(CW\*(C`qx/CHAINE/\*(C'\fR, \f(CW\*(C`setpgrp\*(C'\fR, \f(CW\*(C`setpriority\*(C'\fR, \f(CW\*(C`sleep\*(C'\fR, \f(CW\*(C`system\*(C'\fR,
\&\f(CW\*(C`times\*(C'\fR, \f(CW\*(C`wait\*(C'\fR, \f(CW\*(C`waitpid\*(C'\fR
.IP "Mots\-cle\*'s lie\*'s aux modules perl" 4
.IX Item "Mots-cle's lie's aux modules perl"
\&\f(CW\*(C`do\*(C'\fR, \f(CW\*(C`import\*(C'\fR, \f(CW\*(C`no\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`require\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "Mots\-cle\*'s lie\*'s aux classes et a\*` la programmation oriente\*'e objet" 4
.IX Item "Mots-cle's lie's aux classes et a` la programmation oriente'e objet"
\&\f(CW\*(C`bless\*(C'\fR, \f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`package\*(C'\fR, \f(CW\*(C`ref\*(C'\fR, \f(CW\*(C`tie\*(C'\fR, \f(CW\*(C`tied\*(C'\fR,
\&\f(CW\*(C`untie\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.IP "Fonctions de bas niveau lie\*'es aux sockets" 4
.IX Item "Fonctions de bas niveau lie'es aux sockets"
\&\f(CW\*(C`accept\*(C'\fR, \f(CW\*(C`bind\*(C'\fR, \f(CW\*(C`connect\*(C'\fR, \f(CW\*(C`getpeername\*(C'\fR, \f(CW\*(C`getsockname\*(C'\fR,
\&\f(CW\*(C`getsockopt\*(C'\fR, \f(CW\*(C`listen\*(C'\fR, \f(CW\*(C`recv\*(C'\fR, \f(CW\*(C`send\*(C'\fR, \f(CW\*(C`setsockopt\*(C'\fR, \f(CW\*(C`shutdown\*(C'\fR,
\&\f(CW\*(C`socket\*(C'\fR, \f(CW\*(C`socketpair\*(C'\fR
.IP "Fonctions \s-1IPC\s0 (communication inter\-processus) System V" 4
.IX Item "Fonctions IPC (communication inter-processus) System V"
\&\f(CW\*(C`msgctl\*(C'\fR, \f(CW\*(C`msgget\*(C'\fR, \f(CW\*(C`msgrcv\*(C'\fR, \f(CW\*(C`msgsnd\*(C'\fR, \f(CW\*(C`semctl\*(C'\fR, \f(CW\*(C`semget\*(C'\fR, \f(CW\*(C`semop\*(C'\fR,
\&\f(CW\*(C`shmctl\*(C'\fR, \f(CW\*(C`shmget\*(C'\fR, \f(CW\*(C`shmread\*(C'\fR, \f(CW\*(C`shmwrite\*(C'\fR
.IP "Manipulation des informations sur les utilisateurs et les groupes" 4
.IX Item "Manipulation des informations sur les utilisateurs et les groupes"
\&\f(CW\*(C`endgrent\*(C'\fR, \f(CW\*(C`endhostent\*(C'\fR, \f(CW\*(C`endnetent\*(C'\fR, \f(CW\*(C`endpwent\*(C'\fR, \f(CW\*(C`getgrent\*(C'\fR,
\&\f(CW\*(C`getgrgid\*(C'\fR, \f(CW\*(C`getgrnam\*(C'\fR, \f(CW\*(C`getlogin\*(C'\fR, \f(CW\*(C`getpwent\*(C'\fR, \f(CW\*(C`getpwnam\*(C'\fR,
\&\f(CW\*(C`getpwuid\*(C'\fR, \f(CW\*(C`setgrent\*(C'\fR, \f(CW\*(C`setpwent\*(C'\fR
.IP "Manipulation des informations du re\*'seau" 4
.IX Item "Manipulation des informations du re'seau"
\&\f(CW\*(C`endprotoent\*(C'\fR, \f(CW\*(C`endservent\*(C'\fR, \f(CW\*(C`gethostbyaddr\*(C'\fR, \f(CW\*(C`gethostbyname\*(C'\fR,
\&\f(CW\*(C`gethostent\*(C'\fR, \f(CW\*(C`getnetbyaddr\*(C'\fR, \f(CW\*(C`getnetbyname\*(C'\fR, \f(CW\*(C`getnetent\*(C'\fR,
\&\f(CW\*(C`getprotobyname\*(C'\fR, \f(CW\*(C`getprotobynumber\*(C'\fR, \f(CW\*(C`getprotoent\*(C'\fR,
\&\f(CW\*(C`getservbyname\*(C'\fR, \f(CW\*(C`getservbyport\*(C'\fR, \f(CW\*(C`getservent\*(C'\fR, \f(CW\*(C`sethostent\*(C'\fR,
\&\f(CW\*(C`setnetent\*(C'\fR, \f(CW\*(C`setprotoent\*(C'\fR, \f(CW\*(C`setservent\*(C'\fR
.IP "Fonction de date et heure" 4
.IX Item "Fonction de date et heure"
\&\f(CW\*(C`gmtime\*(C'\fR, \f(CW\*(C`localtime\*(C'\fR, \f(CW\*(C`time\*(C'\fR, \f(CW\*(C`times\*(C'\fR
.IP "Nouvelles fonctions de perl5" 4
.IX Item "Nouvelles fonctions de perl5"
\&\f(CW\*(C`abs\*(C'\fR, \f(CW\*(C`bless\*(C'\fR, \f(CW\*(C`chomp\*(C'\fR, \f(CW\*(C`chr\*(C'\fR, \f(CW\*(C`exists\*(C'\fR, \f(CW\*(C`formline\*(C'\fR, \f(CW\*(C`glob\*(C'\fR,
\&\f(CW\*(C`import\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`lcfirst\*(C'\fR, \f(CW\*(C`map\*(C'\fR, \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`no\*(C'\fR, \f(CW\*(C`our\*(C'\fR, \f(CW\*(C`prototype\*(C'\fR,
\&\f(CW\*(C`qx\*(C'\fR, \f(CW\*(C`qw\*(C'\fR, \f(CW\*(C`readline\*(C'\fR, \f(CW\*(C`readpipe\*(C'\fR, \f(CW\*(C`ref\*(C'\fR, \f(CW\*(C`sub*\*(C'\fR, \f(CW\*(C`sysopen\*(C'\fR, \f(CW\*(C`tie\*(C'\fR,
\&\f(CW\*(C`tied\*(C'\fR, \f(CW\*(C`uc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, \f(CW\*(C`untie\*(C'\fR, \f(CW\*(C`use\*(C'\fR
.Sp
* \- \f(CW\*(C`sub\*(C'\fR e\*'tait un mot\-cle\*' dans perl4, mais dans perl5 c'est un
ope\*'rateur qui peut e\*^tre utilise\*' au sein d'expressions.
.IP "Fonctions obsole\*`tes en perl5" 4
.IX Item "Fonctions obsole`tes en perl5"
\&\f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR
.Sh "Portabilite\*'"
.IX Subsection "Portabilite'"
Perl est ne\*' sur Unix et peut, par conse\*'quent, acce\*'der a\*` tous les appels
syste\*`mes Unix courants. Dans des environnements non\-Unix, les fonctionnalite\*'s
de certains appels syste\*`mes Unix peuvent manquer ou diffe\*'rer sur certains
de\*'tails. Les fonctions Perl affecte\*'es par cela sont\ :
.PP
\&\f(CW\*(C`\-X\*(C'\fR, \f(CW\*(C`binmode\*(C'\fR, \f(CW\*(C`chmod\*(C'\fR, \f(CW\*(C`chown\*(C'\fR, \f(CW\*(C`chroot\*(C'\fR, \f(CW\*(C`crypt\*(C'\fR,
\&\f(CW\*(C`dbmclose\*(C'\fR, \f(CW\*(C`dbmopen\*(C'\fR, \f(CW\*(C`dump\*(C'\fR, \f(CW\*(C`endgrent\*(C'\fR, \f(CW\*(C`endhostent\*(C'\fR,
\&\f(CW\*(C`endnetent\*(C'\fR, \f(CW\*(C`endprotoent\*(C'\fR, \f(CW\*(C`endpwent\*(C'\fR, \f(CW\*(C`endservent\*(C'\fR, \f(CW\*(C`exec\*(C'\fR,
\&\f(CW\*(C`fcntl\*(C'\fR, \f(CW\*(C`flock\*(C'\fR, \f(CW\*(C`fork\*(C'\fR, \f(CW\*(C`getgrent\*(C'\fR, \f(CW\*(C`getgrgid\*(C'\fR, \f(CW\*(C`gethostent\*(C'\fR,
\&\f(CW\*(C`getlogin\*(C'\fR, \f(CW\*(C`getnetbyaddr\*(C'\fR, \f(CW\*(C`getnetbyname\*(C'\fR, \f(CW\*(C`getnetent\*(C'\fR,
\&\f(CW\*(C`getppid\*(C'\fR, \f(CW\*(C`getpgrp\*(C'\fR, \f(CW\*(C`getpriority\*(C'\fR, \f(CW\*(C`getprotobynumber\*(C'\fR,
\&\f(CW\*(C`getprotoent\*(C'\fR, \f(CW\*(C`getpwent\*(C'\fR, \f(CW\*(C`getpwnam\*(C'\fR, \f(CW\*(C`getpwuid\*(C'\fR,
\&\f(CW\*(C`getservbyport\*(C'\fR, \f(CW\*(C`getservent\*(C'\fR, \f(CW\*(C`getsockopt\*(C'\fR, \f(CW\*(C`glob\*(C'\fR, \f(CW\*(C`ioctl\*(C'\fR,
\&\f(CW\*(C`kill\*(C'\fR, \f(CW\*(C`link\*(C'\fR, \f(CW\*(C`lstat\*(C'\fR, \f(CW\*(C`msgctl\*(C'\fR, \f(CW\*(C`msgget\*(C'\fR, \f(CW\*(C`msgrcv\*(C'\fR,
\&\f(CW\*(C`msgsnd\*(C'\fR, \f(CW\*(C`open\*(C'\fR, \f(CW\*(C`pipe\*(C'\fR, \f(CW\*(C`readlink\*(C'\fR, \f(CW\*(C`rename\*(C'\fR, \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`semctl\*(C'\fR,
\&\f(CW\*(C`semget\*(C'\fR, \f(CW\*(C`semop\*(C'\fR, \f(CW\*(C`setgrent\*(C'\fR, \f(CW\*(C`sethostent\*(C'\fR, \f(CW\*(C`setnetent\*(C'\fR,
\&\f(CW\*(C`setpgrp\*(C'\fR, \f(CW\*(C`setpriority\*(C'\fR, \f(CW\*(C`setprotoent\*(C'\fR, \f(CW\*(C`setpwent\*(C'\fR,
\&\f(CW\*(C`setservent\*(C'\fR, \f(CW\*(C`setsockopt\*(C'\fR, \f(CW\*(C`shmctl\*(C'\fR, \f(CW\*(C`shmget\*(C'\fR, \f(CW\*(C`shmread\*(C'\fR,
\&\f(CW\*(C`shmwrite\*(C'\fR, \f(CW\*(C`socket\*(C'\fR, \f(CW\*(C`socketpair\*(C'\fR, \f(CW\*(C`stat\*(C'\fR, \f(CW\*(C`symlink\*(C'\fR, \f(CW\*(C`syscall\*(C'\fR,
\&\f(CW\*(C`sysopen\*(C'\fR, \f(CW\*(C`system\*(C'\fR, \f(CW\*(C`times\*(C'\fR, \f(CW\*(C`truncate\*(C'\fR, \f(CW\*(C`umask\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR,
\&\f(CW\*(C`utime\*(C'\fR, \f(CW\*(C`wait\*(C'\fR, \f(CW\*(C`waitpid\*(C'\fR
.PP
Pour de plus amples de\*'tails sur la portabilite\*' de ces fonctions, voir
perlport et toutes les documentations disponibles spe\*'cifiques a\*` la
plate-forme conside\*'re\*'e.
.Sh "Fonctions Perl par ordre alphabe\*'tique"
.IX Subsection "Fonctions Perl par ordre alphabe'tique"
.IP "\fI\-X\fR \s-1DESCRIPTEUR\s0" 8
.IX Item "-X DESCRIPTEUR"
.PD 0
.IP "\fI\-X\fR \s-1EXPR\s0" 8
.IX Item "-X EXPR"
.IP "\fI\-X\fR" 8
.IX Item "-X"
.PD
Un test de fichier ou\*` X est une des lettres pre\*'sente\*'es ci\-dessous. Cet
ope\*'rateur unaire prend soit un argument, soit un nom de fichier, soit un
descripteur de fichier, et teste le fichier associe\*' pour constater si quelque
chose est ve\*'rifie\*' a\*` son sujet. Si l'argument est omis, il teste \f(CW$_\fR, sauf
\&\f(CW\*(C`\-t\*(C'\fR qui teste \s-1STDIN\s0. Sauf indication contraire, il retourne \f(CW1\fR pour \s-1VRAI\s0
et \f(CW''\fR pour \s-1FAUX\s0, ou la valeur inde\*'finie (undef) si le fichier n'existe
pas. Malgre\*' leurs noms originaux, leur priorite\*' est la me\*^me que celle de tout
autre ope\*'rateur unaire nomme\*' et l'argument peut\-e\*^tre mis de me\*^me entre
parenthe\*`ses. L'ope\*'rateur peut e\*^tre\ :
.IX Xref "-r -w -x -o -R -W -X -O -e -z -s -f -d -l -p -S -b -c -t -u -g -k -T -B -M -A -C"
.Sp
.Vb 4
\&    \-r  Le fichier est en lecture par le uid/gid effectif.
\&    \-w  Le fichier est en e\*'criture par le uid/gid effectif.
\&    \-x  Le fichier est exe\*'cutable par le uid/gid effectif.
\&    \-o  Le fichier appartient au uid effectif.
\&
\&    \-R  Le fichier est en lecture par le uid/gid re\*'el.
\&    \-W  Le fichier est en e\*'criture par le uid/gid re\*'el.
\&    \-X  Le fichier est exe\*'cutable par le uid/gid re\*'el.
\&    \-O  Le fichier appartient au uid re\*'el.
\&
\&    \-e  Le fichier existe.
\&    \-z  Le fichier a une taille nulle (il est vide).
\&    \-s  Le fichier n'a pas une taille nulle (retourne sa taille en octets).
\&
\&    \-f  Le fichier est un fichier normal.
\&    \-d  Le fichier est un re\*'pertoire.
\&    \-l  Le fichier est un lien symbolique.
\&    \-p  Le fichier est un tube nomme\*'e (FIFO), ou le descripteur est un pipe.
\&    \-S  Le fichier est une socket.
\&    \-b  Le fichier est un fichier blocs spe\*'cial.
\&    \-c  Le fichier est un fichier caracte\*`res spe\*'cial.
\&    \-t  Le fichier est ouvert sur un tty.
\&
\&    \-u  Le fichier a le bit setuid positionne\*'.
\&    \-g  Le fichier a le bit setgid positionne\*'.
\&    \-k  Le fichier a le sticky bit positionne\*'.
\&
\&    \-T  Le fichier est un fichier texte ASCII (via une heuristique).
\&    \-B  Le fichier est un fichier binaire (le contraire de \-T).
\&
\&    \-M  La date de de\*'marrage du script moins la date de dernie\*`re
\&        modification du fichier (exprime\*' en jours).
\&    \-A  Idem pour le dernier acce\*`s au fichier.
\&    \-C  Idem pour le dernier changement de l'inode du fichier
\&        (Unix peut avoir un comportement diffe\*'rent des autres syste\*`mes).
.Ve
.Sp
Exemple\ :
.Sp
.Vb 5
\&    while (<>) {
\&        chomp;
\&        next unless \-f $_;      # ignore les fichiers spe\*'ciaux
\&        #...
\&    }
.Ve
.Sp
L'interpre\*'tation des ope\*'rateurs de permission sur le fichier \f(CW\*(C`\-r\*(C'\fR, \f(CW\*(C`\-R\*(C'\fR,
\&\f(CW\*(C`\-w\*(C'\fR, \f(CW\*(C`\-W\*(C'\fR, \f(CW\*(C`\-x\*(C'\fR, et \f(CW\*(C`\-X\*(C'\fR est uniquement base\*'e sur le mode du fichier et
les uids/gids de l'utilisateur. En fait, il peut y avoir d'autres raisons pour
lesquelles vous ne pouvez pas lire, e\*'crire ou exe\*'cuter le fichier. Par
exemple, le contro\*^le d'acce\*`s aux syste\*`mes de fichiers re\*'seau (\s-1NFS\s0), les listes
de contro\*^les d'acce\*`s (\s-1ACL\s0), les syste\*`mes de fichiers en lecture seule et les
formats d'exe\*'cutable non reconnus.
.Sp
Notez aussi que, pour le super\-utilisateur, \f(CW\*(C`\-r\*(C'\fR, \f(CW\*(C`\-R\*(C'\fR, \f(CW\*(C`\-w\*(C'\fR, et \f(CW\*(C`\-W\*(C'\fR
retournent toujours \f(CW1\fR, et \f(CW\*(C`\-x\*(C'\fR ainsi que \f(CW\*(C`\-X\*(C'\fR retournent \f(CW1\fR si l'un des
bits d'exe\*'cution est positionne\*' dans le mode. Les scripts exe\*'cute\*'s par le
super-utilisateur peuvent donc ne\*'cessiter un appel \f(CW\*(C`stat()\*(C'\fR pour de\*'terminer
exactement les droits du fichier ou alors effectuer un changement temporaire
d'uid.
.Sp
Si vous utilisez les \s-1ACL\s0 (listes de contro\*^les d'acce\*`s), il existe un pragma
appele\*' \f(CW\*(C`filetest\*(C'\fR qui peut produire des re\*'sultats plus pre\*'cis que les
informations minimales des bits de permissions fournies par \fIstat()\fR. Lorsque
vous faites \f(CW\*(C`use filetest 'access'\*(C'\fR, les tests sur fichiers susnomme\*'s
utiliseront les appels syste\*`mes de la famille \fIaccess()\fR. Notez aussi que dans
ce cas, les tests \f(CW\*(C`\-x\*(C'\fR et \f(CW\*(C`\-X\*(C'\fR peuvent retourner \s-1VRAI\s0 me\*^me si aucun bit
d'exe\*'cution n'est positionne\*' (que ce soit les bits normaux ou ceux des
ACLs). Ce comportement e\*'trange est du\*^ a\*` la de\*'finition des appels syste\*`mes
sous\-jacents. Lisez la documentation du pragma \f(CW\*(C`filetest\*(C'\fR pour de plus amples
informations.
.Sp
Notez que \f(CW\*(C`\-s/a/b/\*(C'\fR n'effectue pas une substitution ne\*'gative. Toutefois,
e\*'crire \f(CW\*(C`\-exp($foo)\*(C'\fR fonctionne toujours comme pre\*'vu \*(-- seule une lettre
isole\*'e apre\*`s un tiret est interpre\*'te\*'e comme un test de fichier.
.Sp
Les tests \f(CW\*(C`\-T\*(C'\fR et \f(CW\*(C`\-B\*(C'\fR fonctionnent de la manie\*`re suivante. Le premier bloc
du fichier est examine\*', a\*` la recherche de caracte\*`res spe\*'ciaux tels que des
codes de contro\*^le ou des octets avec un bit de poids fort. Si trop de
caracte\*`res spe\*'ciaux (>\ 30\ %) sont rencontre\*'s, c'est un fichier \f(CW\*(C`\-B\*(C'\fR,
sinon c'est un fichier \f(CW\*(C`\-T\*(C'\fR. De plus, tout fichier contenant un octet nul
dans le premier bloc est conside\*'re\*' comme binaire. Si \f(CW\*(C`\-T\*(C'\fR ou \f(CW\*(C`\-B\*(C'\fR est
utilise\*' sur un descripteur de fichier, le tampon stdio courant est examine\*' a\*`
la place du premier bloc. \f(CW\*(C`\-T\*(C'\fR et \f(CW\*(C`\-B\*(C'\fR retournent tous les deux \s-1VRAI\s0 sur un
fichier nul, ou une fin de fichier s'il s'agit d'un descripteur. Comme vous
devez lire un fichier pour effectuer le test \f(CW\*(C`\-T\*(C'\fR, la plupart du temps, vous
devriez d'abord utiliser un \f(CW\*(C`\-f\*(C'\fR sur le fichier, comme dans \f(CW\*(C`next unless \-f
$file && \-T $file\*(C'\fR.
.Sp
Si le descripteur spe\*'cial, constitue\*' d'un seul underscore (N.d.T.\ :
caracte\*`re souligne\*'), est fourni comme argument d'un test de fichier (ou aux
ope\*'rateurs \f(CW\*(C`stat()\*(C'\fR et \f(CW\*(C`lstat()\*(C'\fR), alors c'est la structure stat du dernier
fichier traite\*' par un test (ou ope\*'rateur) qui est utilise\*'e, e\*'pargnant ainsi un
appel syste\*`me. (Ceci ne fonctionne pas avec \f(CW\*(C`\-t\*(C'\fR et n'oubliez pas que \fIlstat()\fR
et \f(CW\*(C`\-l\*(C'\fR laisseront dans la structure stat des informations lie\*'es au fichier
symbolique et non au fichier re\*'el.)  (Notez aussi que si des informations
issues d'un appel a\*` \f(CW\*(C`lstat\*(C'\fR e\*'taient dans le buffer stat alors \f(CW\*(C`\-T\*(C'\fR et \f(CW\*(C`\-B\*(C'\fR
les remplaceront par le re\*'sultat de \f(CW\*(C`stat _\*(C'\fR.) Exemple\ :
.Sp
.Vb 1
\&    print "Can do.\en" if \-r $a || \-w _ || \-x _;
\&
\&    stat($filename);
\&    print "Readable\en" if \-r _;
\&    print "Writable\en" if \-w _;
\&    print "Executable\en" if \-x _;
\&    print "Setuid\en" if \-u _;
\&    print "Setgid\en" if \-g _;
\&    print "Sticky\en" if \-k _;
\&    print "Text\en" if \-T _;
\&    print "Binary\en" if \-B _;
.Ve
.IP "abs \s-1VALEUR\s0" 8
.IX Item "abs VALEUR"
.PD 0
.IP "abs" 8
.IX Item "abs"
.PD
Retourne la valeur absolue de son argument.
Si \s-1VALEUR\s0 est omis, utilise \f(CW$_\fR.
.IP "accept \s-1NOUVELLESOCKET\s0,GENERIQUESOCKET" 8
.IX Item "accept NOUVELLESOCKET,GENERIQUESOCKET"
Accepte une connexion entrante de socket, tout comme l'appel syste\*`me
\&\fIaccept\fR\|(2). Retourne l'adresse compacte en cas de succe\*`s, \s-1FAUX\s0 sinon.
Voir l'exemple de \*(L"Sockets : communication client/serveur\*(R" in perlipc.
.Sp
Sur les syste\*`mes qui supportent le drapeau fermeture\-a\*`\-l\-exe\*'cution
(close\-on\-exec) sur les fichiers, ce drapeau sera positionne\*' pour de nouveaux
descripteurs de fichier en fonction de la valeur de $^F. Voir \*(L"$^F\*(R" in perlvar.
.IP "alarm \s-1SECONDES\s0" 8
.IX Item "alarm SECONDES"
.PD 0
.IP "alarm" 8
.IX Item "alarm"
.PD
S'arrange pour qu'un \s-1SIGALRM\s0 soit de\*'livre\*' au processus apre\*`s que le nombre
spe\*'cifie\*' de secondes se soient e\*'coule\*'es. Si \s-1SECONDES\s0 est omis, la valeur de
\&\f(CW$_\fR est utilise\*'e. (Sur certaines machines, malheureusement, le temps e\*'coule\*'
peut e\*^tre jusqu'a\*` une seconde de plus ou de moins que celui spe\*'cifie\*', en
fonction de la fac\*,on dont les secondes sont compte\*'es. De plus, la partage du
temps entre les diffe\*'rents processus peut entrai\*^ner un retard supple\*'mentaire.)
.Sp
Il n'est pas possible d'activer plusieurs de\*'comptes temporels a\*` la
fois. Chaque appel annule le de\*'compte pre\*'ce\*'dent. La valeur \f(CW0\fR peut e\*^tre
fournie pour annuler le de\*'compte pre\*'ce\*'dent sans en cre\*'er un nouveau. La valeur
retourne\*'e est le temps restant de de\*'compte pre\*'ce\*'dent.
.Sp
Pour des de\*'lais d'une pre\*'cision infe\*'rieure a\*` la seconde, vous pouvez utiliser
soit la version Perl a\*` quatre parame\*`tres de \fIselect()\fR en laissant les trois
premiers inde\*'finis soit l'interface \f(CW\*(C`syscall()\*(C'\fR de Perl pour acce\*'der a\*`
\&\fIsetitimer\fR\|(2) si votre syste\*`me le supporte. Le module Time::HiRes (qui fait
partie de Perl depuis la version 5.8 ou disponible sur \s-1CPAN\s0 sinon) peut aussi
s'ave\*'rer utile.
.Sp
C'est souvent une erreur de me\*'langer des appels a\*` \f(CW\*(C`alarm()\*(C'\fR avec des appels a\*`
\&\f(CW\*(C`sleep()\*(C'\fR (\f(CW\*(C`sleep\*(C'\fR peut\-e\*^tre imple\*'mente\*' via des appels internes a\*` \f(CW\*(C`alarm\*(C'\fR
sur votre syste\*`me.)
.Sp
Si vous souhaitez utiliser \f(CW\*(C`alarm()\*(C'\fR pour contro\*^ler la dure\*'e d'un appel
syste\*`me, il vous faut utiliser le couple \f(CW\*(C`eval()\*(C'\fR/\f(CW\*(C`die()\*(C'\fR. Vous ne pouvez
pas compter sur l'alarme qui de\*'clenche l'e\*'chec de l'appel syste\*`me avec \f(CW$!\fR
positionne\*' a\*` \f(CW\*(C`EINTR\*(C'\fR car Perl met en place des descripteurs de signaux pour
rede\*'marrer ces appels sur certains syste\*`mes. Utiliser \f(CW\*(C`eval()\*(C'\fR/\f(CW\*(C`die()\*(C'\fR
fonctionne toujours sous re\*'serve de l'avertissement signale\*' dans
\&\*(L"Signaux\*(R" in perlipc.
.Sp
.Vb 10
\&    eval {
\&        local $SIG{ALRM} = sub { die "alarm\en" }; # N.B. : \en obligatoire
\&        alarm $timeout;
\&        $nread = sysread SOCKET, $buffer, $size;
\&        alarm 0;
\&    };
\&    if ($@) {
\&        die unless $@ eq "alarm\en";   # propage des erreurs inattendues
\&        # de\*'lai de\*'passe\*' : time out
\&    }
\&    else {
\&        # de\*'lai non de\*'passe\*'
\&    }
.Ve
.IP "atan2 Y,X" 8
.IX Item "atan2 Y,X"
Retourne l'arc\-tangente de Y/X dans l'intervalle \-PI a\*` \s-1PI\s0.
.Sp
Pour l'ope\*'ration tangente, vous pouvez utiliser la fonction
\&\f(CW\*(C`POSIX::tan()\*(C'\fR ou la relation habituelle\ :
.Sp
.Vb 1
\&    sub tan { sin($_[0]) / cos($_[0])  }
.Ve
.IP "bind \s-1SOCKET\s0,NOM" 8
.IX Item "bind SOCKET,NOM"
Associe une adresse re\*'seau a\*` une socket, tout comme l'appel syste\*`me
bind. Retourne \s-1VRAI\s0 en cas de succe\*`s, \s-1FAUX\s0 sinon. \s-1NOM\s0 doit e\*^tre une adresse
compacte\*'e (par \fIpack()\fR) du type approprie\*' pour la socket. Voir les exemples de
\&\*(L"Sockets\ : communication client/serveur\*(R" in perlipc.
.IP "binmode \s-1DESCRIPTEUR\s0, \s-1FILTRE\s0" 8
.IX Item "binmode DESCRIPTEUR, FILTRE"
.PD 0
.IP "binmode \s-1DESCRIPTEUR\s0" 8
.IX Item "binmode DESCRIPTEUR"
.PD
Positionne \s-1DESCRIPTEUR\s0 pour e\*^tre lu ou e\*'crit en mode \*(L"binaire\*(R" ou en mode
\&\*(L"texte\*(R" sur les syste\*`mes d'exploitation qui font la distinction entre fichiers
texte et binaire. Si \s-1DESCRIPTEUR\s0 est une expression, sa valeur est utilise\*'e
comme nom du descripteur. Retourne vrai en cas de succe\*`s ou \f(CW\*(C`undef\*(C'\fR en cas
d'e\*'chec.
.Sp
Si \s-1FILTRE\s0 est omis ou s'il vaut \f(CW\*(C`:raw\*(C'\fR, le \s-1DESCRIPTEUR\s0 est positionne\*' pour
passer des donne\*'es binaires. Cela inclut la de\*'sactivation d'une e\*'ventuelle
traduction des \s-1CRLF\s0 et passe en mode octets (a\*` opposer a\*` des caracte\*`res
Unicode). Notez bien que, en de\*'pit de ce qui est dit dans \fI\*(L"Programming
Perl\*(R"\fR (le Camel) ou ailleurs, \f(CW\*(C`:raw\*(C'\fR \fIn\fR'est \fIpas\fR l'inverse de \f(CW\*(C`:crlf\*(C'\fR
\&\*(-- toute autre filtre (\s-1FILTRE\s0 ou \s-1LAYER\s0 en anglais) qui pourrait modifier la
nature binaire du flot est \fIaussi\fR de\*'sactive\*'e. Voir PerlIO, perlrun et
tout ce qui est dit de la variable d'environnement \s-1PERLIO\s0.
.Sp
\&\fILe parame\*`tre \s-1FILTRE\s0 de la fonction \fIbinmode()\fI est appele\*' \*(L"\s-1DISCIPLINE\s0\*(R" dans
\&\*(L"Programming Perl, 3rd Edition\*(R". Mais, depuis la publication de ce livre connu
sous le nom de \*(L"Camel \s-1III\s0\*(R", un consensus pour le nommage de ce parame\*`tre est
passe\*' de \*(L"discipline\*(R" a\*` \*(L"filtre\*(R" (layer en anglais). Toute la documentation de
cette version de Perl se re\*'fe\*`re donc maintenant a\*` \*(L"layer\*(R" pluto\*^t qu'a\*`
\&\*(L"discipline\*(R". Revenons maintenant a\*` la documentation...\fR
.Sp
Sur certains syste\*`mes (en ge\*'ne\*'ral les syste\*`mes \s-1DOS\s0 et ceux base\*'s sur Windows),
\&\fIbinmode()\fR est ne\*'cessaire lorsque vous ne travaillez pas avec des fichiers
texte. Pour assurer la portabilite\*', c'est une bonne ide\*'e de toujours
l'utiliser lorsque c'est approprie\*' et de ne jamais l'utiliser dans les autres
cas.
.Sp
En d'autres termes : inde\*'pendamment de la plate\-forme, utilisez \fIbinmode()\fR sur
les fichier binaires et n'utilisez pas \fIbinmode()\fR sur les fichiers textes.
.Sp
Si \s-1FILTRE\s0 est pre\*'sent, il doit e\*^tre une seule chai\*^ne de caracte\*`res mais il
peut contenir plusieurs directives. Ces directives modifient le comportement
du \s-1DESCRIPTEUR\s0. L'utilisation de \s-1FILTRE\s0 via \fIbinmode()\fR sur des fichiers texte a
un sens.
.Sp
Pour marquer un \s-1DESCRIPTEUR\s0 comme \s-1UTF\-8\s0, utilisez \f(CW\*(C`:utf8\*(C'\fR.
.Sp
Les directives comme \f(CW\*(C`:bytes\*(C'\fR, \f(CW\*(C`:crlf\*(C'\fR, \f(CW\*(C`:utf8\*(C'\fR ou de la forme \f(CW\*(C`:...\*(C'\fR sont
appele\*'es des \fIfiltres\fR I/O (filtres d'entre\*'e/sortie). La directive \f(CW\*(C`open\*(C'\fR
peut e\*^tre utilise\*'e pour spe\*'cifier les filtres d'I/O par de\*'faut. Voir open.
.Sp
En ge\*'ne\*'ral, \fIbinmode()\fR devrait e\*^tre appele\*' apre\*`s \fIopen()\fR et avant n'importe
quelle ope\*'ration d'entre\*'e/sortie. L'appel a\*` \fIbinmode()\fR videra tous les tampons
de donne\*'es en attente de sortie (ou d'entre\*'e). La seule exception est le
filtre \f(CW\*(C`:encoding\*(C'\fR qui change l'encodage par de\*'faut du \s-1DESCRIPTEUR\s0. Voir
open. L'appel au filtre \f(CW\*(C`:encoding\*(C'\fR est parfois ne\*'cessaire en cours de
flot\ : il ne vide pas les tampons.
.Sp
Le syste\*`me d'exploitation, les pilotes de pe\*'riphe\*'riques, les bibliothe\*`ques C
et l'interpre\*'teur de Perl coope\*`rent afin de permettre au programmeur de
conside\*'rer une fin de ligne comme un seul caracte\*`re (\f(CW\*(C`\en\*(C'\fR) et cela,
inde\*'pendamment de sa repre\*'sentation externe. Sur la plupart des syste\*`mes
d'exploitation, la repre\*'sentation utilise\*'e par les fichiers textes natifs
correspond a\*` la repre\*'sentation interne mais sur certaines plates-formes la
repre\*'sentation externe de \f(CW\*(C`\en\*(C'\fR est constitue\*'e de plus d'un caracte\*`re.
.Sp
Mac \s-1OS\s0, toutes les variantes d'\s-1UNIX\s0 et les Stream_LF de \s-1VMS\s0 utilisent un seul
caracte\*`re pour repre\*'senter une fin de ligne dans leur repre\*'sentation externe
des textes (me\*^me si ce caracte\*`re unique est un \s-1RETOUR\s0 \s-1CHARIOT\s0 sur Mac \s-1OS\s0 et un
\&\s-1SAUT\s0 \s-1DE\s0 \s-1LIGNE\s0 sur Unix et dans la plupart des fichiers \s-1VMS\s0). Sur d'autres
syste\*`mes tels que \s-1VMS\s0, MS-DOS et les diffe\*'rentes versions de MS\-Windows, votre
programme voit un \f(CW\*(C`\en\*(C'\fR comme un simple \f(CW\*(C`\ecJ\*(C'\fR mais ce qui est re\*'ellement
stocke\*' dans les fichiers textes est le couple de caracte\*`res \f(CW\*(C`\ecM\ecJ\*(C'\fR. Cela
signifie que, si vous n'utilisez pas \fIbinmode()\fR sur ces syste\*`mes, les se\*'quences
\&\f(CW\*(C`\ecM\ecJ\*(C'\fR sur disque seront converties en \f(CW\*(C`\en\*(C'\fR en entre\*'e et que tous les
\&\f(CW\*(C`\en\*(C'\fR produits par votre programme seront reconvertis en \f(CW\*(C`\ecM\ecJ\*(C'\fR a\*` la
sortie. C'est ce que vous voulez pour les fichiers textes mais cela peut e\*^tre
de\*'sastreux pour un fichier binaire.
.Sp
Autre conse\*'quence de l'utilisation de \fIbinmode()\fR (sur certains syste\*`mes)\ : les
marqueurs spe\*'ciaux de fin de fichiers seront vus comme faisant partie du flux
de donne\*'es. Pour les syste\*`mes de la famille Microsoft, cela signifie que, si
vos donne\*'es binaires contiennent un \f(CW\*(C`\ecZ\*(C'\fR, le syste\*`me d'entre\*'e/sortie le
conside\*'rera comme une fin de fichier a\*` moins que vous n'utilisiez \fIbinmode()\fR.
.Sp
\&\fIbinmode()\fR est important non seulement pour les ope\*'rations \fIreadline()\fR et
\&\fIprint()\fR mais aussi lorsque vous utilisez \fIread()\fR, \fIseek()\fR, \fIsysread()\fR, \fIsyswrite()\fR
et \fItell()\fR (voir perlport pour plus d'informations). Voir aussi \f(CW$/\fR et
\&\f(CW\*(C`$\e\*(C'\fR dans perlvar pour savoir comment fixer manuellement les se\*'quences de
fin de lignes en entre\*'e et en sortie.
.IP "bless \s-1REF\s0,NOMCLASSE" 8
.IX Item "bless REF,NOMCLASSE"
.PD 0
.IP "bless \s-1REF\s0" 8
.IX Item "bless REF"
.PD
Cette fonction pre\*'cise a\*` la chose re\*'fe\*'rence\*'e par \s-1REF\s0 qu'elle est de\*'sormais un
objet du paquetage \s-1NOMCLASSE\s0 \*(-- ou le paquetage courant si aucun \s-1NOMCLASSE\s0
n'est spe\*'cifie\*', ce qui est souvent le cas. E\*'tant donne\*' que l'appel a\*`
\&\f(CW\*(C`bless()\*(C'\fR est souvent la dernie\*`re instruction d'un constructeur, cette
fonction retourne la re\*'fe\*'rence elle\-me\*^me. Utilisez toujours la version a\*` deux
arguments si la fonction effectuant la \*(L"be\*'ne\*'diction\*(R" \f(CW\*(C`bless()\*(C'\fR peut e\*^tre
he\*'rite\*'e par une classe de\*'rive\*'e. Cf. perltoot et perlobj pour de plus
amples informations sur la be\*'ne\*'diction (et les be\*'ne\*'dictions) d'objets.
.Sp
Ne blessez des objets qu'avec des NOMCLASSEs me\*'langeant des majuscules et des
minuscules. Les espaces de nommages entie\*`rement en minuscule sont re\*'serve\*'s
pour les directives (pragmas) Perl. Les types pre\*'de\*'finis utilisent les noms
entie\*`rement en majuscule. Donc, pour e\*'viter toute confusion, vous devez e\*'viter
ces deux types de nommage. Soyez su\*^r que \s-1NOMCLASSE\s0 est une valeur vraie.
.Sp
Voir \*(L"Modules Perl\*(R" in perlmod.
.IP "caller \s-1EXPR\s0" 8
.IX Item "caller EXPR"
.PD 0
.IP "caller" 8
.IX Item "caller"
.PD
Retourne le contexte de l'appel de subroutine courant. Dans un contexte
scalaire, retourne le nom du paquetage de l'appelant, s'il existe,
c'est\-a\*`\-dire si nous sommes dans une subroutine, un \f(CW\*(C`eval()\*(C'\fR ou un
\&\f(CW\*(C`require()\*(C'\fR, et retourne la valeur inde\*'finie (undef) sinon. En contexte de
liste, retourne
.Sp
.Vb 1
\&    ($package, $filename, $line) = caller;
.Ve
.Sp
Avec \s-1EXPR\s0, il retourne des informations supple\*'mentaires que le de\*'bogueur
utilise pour afficher un historique de la pile. La valeur de \s-1EXPR\s0 donne le
nombre de contextes d'appels a\*` examiner au-dessus de celui en cours.
.Sp
.Vb 2
\&    ($package, $filename, $line, $subroutine, $hasargs,
\&    $wantarray, $evaltext, $is_require, $hints, $bitmask) = caller($i);
.Ve
.Sp
Ici, \f(CW$subroutine\fR peut e\*^tre \f(CW"(eval)"\fR si le cadre n'est pas un appel de
routine mais un \f(CW\*(C`eval()\*(C'\fR. Dans un tel cas, les e\*'le\*'ments supple\*'mentaires
\&\f(CW$evaltext\fR et \f(CW$is_require\fR sont positionne\*'s\ : \f(CW$is_require\fR est vrai
si le contexte est cre\*'e\*' par un \f(CW\*(C`require\*(C'\fR ou un \f(CW\*(C`use\*(C'\fR, \f(CW$evaltext\fR contient
le texte de l'instruction \f(CW\*(C`eval EXPR\*(C'\fR. En particulier, pour une instruction
\&\f(CW\*(C`eval BLOC\*(C'\fR, \f(CW$filename\fR vaut \f(CW"(eval)"\fR mais \f(CW$evaltext\fR est
inde\*'fini. (Notez aussi que chaque instruction \f(CW\*(C`use\*(C'\fR cre\*'e un contexte
\&\f(CW\*(C`require\*(C'\fR a\*` l'inte\*'rieur d'un contexte \f(CW\*(C`eval EXPR\*(C'\fR.) \f(CW$subroutine\fR peut
aussi e\*^tre \f(CW\*(C`(unknown)\*(C'\fR si cette subroutine particulie\*`re a disparu de la table
des symboles. \f(CW$hasargs\fR est vrai si une nouvelle instance de \f(CW@_\fR a e\*'te\*'
cre\*'e\*' pour ce contexte. Les valeurs de \f(CW$hints\fR et de \f(CW$bitmask\fR risquent de
changer d'une version de Perl a\*` une autre. Elles n'ont donc aucun inte\*'re\*^t pour
une utilisation externe.
.Sp
De plus, s'il est appele\*' depuis le paquetage \s-1DB\s0, \f(CW\*(C`caller\*(C'\fR retourne plus de
de\*'tails\ : il affecte a\*` la liste de variables \f(CW@DB::args\fR les arguments
avec lesquels la routine a e\*'te\*' appele\*'e.
.Sp
Prenez garde a\*` l'optimiseur qui a pu optimiser des contextes d'appel avant que
\&\f(CW\*(C`caller()\*(C'\fR ait une chance de re\*'cupe\*'rer les informations. Ce qui signifie que
\&\f(CWcaller(N)\fR pourrait ne pas retourner les informations concernant le contexte
d'appel que vous attendez, pour \f(CW\*(C`N > 1\*(C'\fR. En particulier, \f(CW@DB::args\fR
peut contenir des informations relatives a\*` un appel pre\*'ce\*'dent de \f(CW\*(C`caller()\*(C'\fR.
.IP "chdir \s-1EXPR\s0" 8
.IX Item "chdir EXPR"
Change le re\*'pertoire courant a\*` \s-1EXPR\s0, si c'est possible. Si \s-1EXPR\s0 est omis,
change vers le re\*'pertoire spe\*'cifie\*' par la variable \f(CW$ENV{HOME}\fR si elle est
de\*'finie\ ; sinon, c'est le re\*'pertoire spe\*'cifie\*' par la variable
\&\f(CW$ENV{LOGDIR}\fR qui est utilise\*'. (Sous \s-1VMS\s0, la variable \f(CW$ENV{SYS$LOGIN}\fR est
aussi regarde\*'e et utilise\*'e si elle est de\*'finie.) Si aucune de ces variables
n'est de\*'finie, \f(CW\*(C`chdir\*(C'\fR seul ne fait rien. Retourne \s-1VRAI\s0 en cas de succe\*`s,
\&\s-1FAUX\s0 sinon. Cf. exemple de \f(CW\*(C`die()\*(C'\fR.
.IP "chmod \s-1LISTE\s0" 8
.IX Item "chmod LISTE"
Change les permissions d'une liste de fichiers. Le premier e\*'le\*'ment de la liste
doit e\*^tre le mode nume\*'rique, qui devrait e\*^tre un nombre en octal et \fInon\fR une
chai\*^ne de chiffres en octal\ : \f(CW0644\fR est correct, mais pas
\&\f(CW'0644'\fR. Retourne le nombre de fichiers dont les permissions ont e\*'te\*'
change\*'es avec succe\*`s. Voir aussi \*(L"oct\*(R", si vous ne disposez que d'une chai\*^ne
de chiffres.
.Sp
.Vb 6
\&    $cnt = chmod 0755, 'foo', 'bar';
\&    chmod 0755, @executables;
\&    $mode = '0644'; chmod $mode, 'foo';      # !!! fixe le mode a\*`
\&                                             # \-\-w\-\-\-\-r\-T
\&    $mode = '0644'; chmod oct($mode), 'foo'; # ceci est mieux
\&    $mode = 0644;   chmod $mode, 'foo';      # cela est le meilleur
.Ve
.Sp
Vous pouvez aussi importer les constantes symboliques \f(CW\*(C`S_I*\*(C'\fR du module
Fcntl\ :
.Sp
.Vb 1
\&    use Fcntl ':mode';
\&
\&    chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @executables;
\&    # Identique au chmod 0755 de l'exemple pre\*'ce\*'dent.
.Ve
.IP "chomp \s-1VARIABLE\s0" 8
.IX Item "chomp VARIABLE"
.PD 0
.IP "chomp( \s-1LISTE\s0 )" 8
.IX Item "chomp( LISTE )"
.IP "chomp" 8
.IX Item "chomp"
.PD
Cette version su\*^re de \*(L"chop\*(R" supprime toute fin de ligne correspondant a\*` la
valeur courante de \f(CW$/\fR (connue aussi sous le nom de \f(CW$INPUT_RECORD_SEPARATOR\fR
dans le module \f(CW\*(C`English\*(C'\fR). Elle retourne le nombre total de caracte\*`res
efface\*'s de tous ses arguments. Elle est souvent utilise\*'e pour effacer le saut
de ligne de la fin d'une entre\*'e quand vous vous souciez que l'enregistrement
final pourrait ne pas avoir ce saut de ligne. En mode paragraphe (\f(CW\*(C`$/ = ""\*(C'\fR),
elle efface tous les sauts de ligne a\*` la fin de la chai\*^ne de caracte\*`res. En
mode XslurpX (\f(CW\*(C`$/ = undef\*(C'\fR) ou en mode enregistrement de taille fixe (\f(CW$/\fR
est une re\*'fe\*'rence vers un entier ou similaire, voir perlvar) \fIchomp()\fR ne
supprime rien du tout. Si \s-1VARIABLE\s0 est omis, elle tronque \f(CW$_\fR. Exemple\ :
.Sp
.Vb 5
\&    while (<>) {
\&        chomp;  # e\*'vite le \en du dernier champ
\&        @array = split(/:/);
\&        # ...
\&    }
.Ve
.Sp
Vous pouvez en fait tronquer tout ce qui est une lvalue, y compris les
affectations\ :
.Sp
.Vb 2
\&    chomp($cwd = `pwd`);
\&    chomp($answer = <STDIN>);
.Ve
.Sp
Si vous tronquez une liste, chaque e\*'le\*'ment est tronque\*' et le nombre total de
caracte\*`res efface\*'s est retourne\*'.
.Sp
Notez que les parenthe\*`ses sont ne\*'cessaires lorsque vous voulez \*(L"chomp\*(R"\-er
quelque chose qui n'est pas une simple variable. C'est parce que \f(CW\*(C`chomp $cwd
= `pwd`;\*(C'\fR est interpre\*'te\*' comme \f(CW\*(C`(chomp $cwd) = `pwd`;\*(C'\fR pluto\*^t que comme
\&\f(CW\*(C`chomp( $cwd = `pwd` );\*(C'\fR. De me\*^me dans le cas de \f(CW\*(C`chomp $a, $b\*(C'\fR qui est
interpre\*'te\*' comme \f(CW\*(C`chomp($a), $b\*(C'\fR pluto\*^t que comme \f(CW\*(C`chomp($a, $b)\*(C'\fR.
.IP "chop \s-1VARIABLE\s0" 8
.IX Item "chop VARIABLE"
.PD 0
.IP "chop( \s-1LISTE\s0 )" 8
.IX Item "chop( LISTE )"
.IP "chop" 8
.IX Item "chop"
.PD
Efface le dernier caracte\*`re d'une chai\*^ne et le retourne. Cet ope\*'rateur est
utilise\*' pour effacer le saut de ligne de la fin d'une entre\*'e car il est plus
efficace que \f(CW\*(C`s/\en//\*(C'\fR e\*'tant donne\*' qu'il ne scanne ni ne copie la chai\*^ne. Si
\&\s-1VARIABLE\s0 est omis, tronque \f(CW$_\fR. Exemple\ :
.Sp
.Vb 5
\&    while (<>) {
\&        chop;   # e\*'vite \en du dernier champ
\&        @array = split(/:/);
\&        #...
\&    }
.Ve
.Sp
Vous pouvez en fait tronquer tout ce qui est une lvalue, y compris les
affectations\ :
.Sp
.Vb 2
\&    chop($cwd = `pwd`);
\&    chop($answer = <STDIN>);
.Ve
.Sp
Si vous tronquez une liste, chaque e\*'le\*'ment est tronque\*'. Seul la valeur
du dernier \f(CW\*(C`chop()\*(C'\fR est retourne\*'e.
.Sp
Notez que \f(CW\*(C`chop()\*(C'\fR retourne le dernier caracte\*`re. Pour retourner tout
sauf le dernier caracte\*`re, utilisez \f(CW\*(C`substr($string, 0, \-1)\*(C'\fR.
.Sp
Voir aussi \*(L"chomp\*(R".
.IP "chown \s-1LISTE\s0" 8
.IX Item "chown LISTE"
Change le proprie\*'taire (et le groupe) d'une liste de fichiers. Les deux
premiers e\*'le\*'ments de la liste doivent e\*^tre, dans l'ordre, les uid et gid
\&\fInume\*'riques\fR. Une valeur \-1 a\*` l'une de ces positions est interpre\*'te\*'e par la
plupart des syste\*`mes comme une valeur a\*` ne pas modifier. Retourne le nombre de
fichiers modifie\*'s avec succe\*`s.
.Sp
.Vb 2
\&    $cnt = chown $uid, $gid, 'foo', 'bar';
\&    chown $uid, $gid, @filenames;
.Ve
.Sp
Voici un exemple qui cherche les uid non nume\*'riques dans le fichier de mots de
passe\ :
.Sp
.Vb 4
\&    print "User: ";
\&    chop($user = <STDIN>);
\&    print "Files: ";
\&    chop($pattern = <STDIN>);
\&
\&    ($login,$pass,$uid,$gid) = getpwnam($user)
\&        or die "$user not in passwd file";
\&
\&    @ary = glob($pattern);      # expansion des noms de fichiers
\&    chown $uid, $gid, @ary;
.Ve
.Sp
Sur la plupart des syste\*`mes, vous n'e\*^tes pas autorise\*' a\*` changer le
proprie\*'taire d'un fichier a\*` moins d'e\*^tre le super\-utilisateur, me\*^me si avez la
possibilite\*' de changer un groupe en l'un de vos groupes secondaires. Sur les
syste\*`mes non se\*'curise\*'s, ces restrictions peuvent e\*^tre moindres, mais ceci
n'est pas une hypothe\*`se portable. Sur les syste\*`mes \s-1POSIX\s0, vous pouvez de\*'tecter
cette condition de la manie\*`re suivante\ :
.Sp
.Vb 2
\&    use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
\&    $can_chown_giveaway = not sysconf(_PC_CHOWN_RESTRICTED);
.Ve
.IP "chr \s-1NOMBRE\s0" 8
.IX Item "chr NOMBRE"
.PD 0
.IP "chr" 8
.IX Item "chr"
.PD
Retourne le caracte\*`re repre\*'sente\*' par ce \s-1NOMBRE\s0 dans le jeu de caracte\*`res. Par
exemple, \f(CW\*(C`chr(65)\*(C'\fR est \f(CW"A"\fR en \s-1ASCII\s0 ou Unicode et chr(0x263a) est un
visage re\*'joui en Unicode. Notez que les caracte\*`res de 127 a\*` 255 (inclu) ne
sont pas par de\*'faut encode\*'s en Unicode pour des raisons de compatibilite\*'s
(voir encoding).
.Sp
Pour la fonction re\*'ciproque, utilisez \*(L"ord\*(R". Voir perlunicode et
encoding pour en savoir plus sur Unicode.
.Sp
Si \s-1NOMBRE\s0 est omis, utilise \f(CW$_\fR.
.IP "chroot \s-1FICHIER\s0" 8
.IX Item "chroot FICHIER"
.PD 0
.IP "chroot" 8
.IX Item "chroot"
.PD
Cet ope\*'rateur fonctionne comme l'appel syste\*`me du me\*^me nom\ : il
fait du re\*'pertoire spe\*'cifie\*' le nouveau re\*'pertoire racine pour tous
les chemins commenc\*,ant par un \f(CW"/"\fR utilise\*'s par votre processus et
ses enfants. (Ceci n'affecte pas le re\*'pertoire courant qui reste
inchange\*'.) Pour des raisons de se\*'curite\*', cet appel est restreint au
super\-utilisateur. Si \s-1FICHIER\s0 est omis, effectue un \f(CW\*(C`chroot()\*(C'\fR sur \f(CW$_\fR.
.IP "close \s-1DESCRIPTEUR\s0" 8
.IX Item "close DESCRIPTEUR"
.PD 0
.IP "close" 8
.IX Item "close"
.PD
Ferme le fichier ou le tube associe\*' au descripteur de fichier, en retournant
\&\s-1VRAI\s0 si et seulement si les tampons d'entre\*'e/sortie ont e\*'te\*' correctement vide\*'s
et si le descripteur a e\*'te\*' correctement ferme\*'. Ferme le descripteur courant si
l'argument est omis.
.Sp
Vous n'avez pas a\*` fermer le \s-1DESCRIPTEUR\s0 si vous allez imme\*'diatement refaire un
\&\f(CW\*(C`open()\*(C'\fR sur celui\-ci, car \f(CW\*(C`open()\*(C'\fR le fermera pour vous. (voir \f(CW\*(C`open()\*(C'\fR.)
Toutefois, un \f(CW\*(C`close()\*(C'\fR explicite sur un fichier d'entre\*'e re\*'initialise le
compteur de lignes (\f(CW$.\fR) alors que la fermeture implicite par un \f(CW\*(C`open()\*(C'\fR ne
le fait pas.
.Sp
Si le descripteur vient d'un tube ouvert, \f(CW\*(C`close()\*(C'\fR va de plus retourner \s-1FAUX\s0
si un des autres appels syste\*`me implique\*'s e\*'choue ou si le programme se
termine avec un statut non nul. (Si le seul proble\*`me rencontre\*' est une
terminaison de programme non nulle, \f(CW$!\fR sera a\*` \f(CW0\fR.) De me\*^me, la fermeture
d'un tube attend que le programme exe\*'cute\*' sur le tube soit acheve\*', au cas ou\*`
vous souhaiteriez voir la sortie du tube apre\*`s coup, et positionne
implicitement la valeur du statut de sortie de la commande dans \f(CW$?\fR.
.Sp
La fermeture pre\*'mature\*'e d'une extre\*'mite\*' de lecture d'un tube (c'est\-a\*`\-dire
avant que le processus qui e\*'crit a\*` l'autre extre\*'mite\*' l'ait ferme\*') aura pour
conse\*'quence l'envoi d'un signal \s-1SIGPIPE\s0 au processus e\*'crivain. Si l'autre
extre\*'mite\*' n'est pas pre\*'vue pour ge\*'rer cela, soyez su\*^r d'avoir lu toutes les
donne\*'es avant de fermer le tube.
.Sp
Exemple\ :
.Sp
.Vb 8
\&    open(OUTPUT, '|sort >foo')  # tube vers sort
\&        or die "Can't start sort: $!";
\&    #...                        # imprime des trucs sur la sortie
\&    close OUTPUT                # attend la fin de sort
\&        or warn $! ? "Error closing sort pipe: $!"
\&                   : "Exit status $? from sort";
\&    open(INPUT, 'foo')          # recupere les resultats de sort
\&        or die "Can't open 'foo' for input: $!";
.Ve
.Sp
Le \s-1DESCRIPTEUR\s0 peut e\*^tre une expression dont la valeur peut e\*^tre utilise\*'e en
tant que descripteur indirect, habituellement le ve\*'ritable nom du descripteur.
.IP "closedir \s-1REPDESCRIPTEUR\s0" 8
.IX Item "closedir REPDESCRIPTEUR"
Ferme un re\*'pertoire ouvert par \f(CW\*(C`opendir()\*(C'\fR et retourne le re\*'sultat de
cet appel syste\*`me.
.Sp
Le \s-1REPDESCRIPTEUR\s0 peut e\*^tre une expression dont la valeur peut e\*^tre utilise\*'e
comme un descripteur indirect de re\*'pertoire, habituellement le ve\*'ritable nom
du descripteur de re\*'pertoire.
.IP "connect \s-1SOCKET\s0,NOM" 8
.IX Item "connect SOCKET,NOM"
Tente une connexion sur une socket distante, tout comme le fait l'appel
syste\*`me du me\*^me nom. Retourne \s-1VRAI\s0 en cas de succe\*`s, \s-1FAUX\s0 sinon. Le \s-1NOM\s0 doit
e\*^tre une adresse compacte\*'e (par \fIpack()\fR) du type approprie\*' correspondant a\*` la
socket. Voir les exemples de \*(L"Sockets : communication
Client/Serveur\*(R" in perlipc.
.IP "continue \s-1BLOC\s0" 8
.IX Item "continue BLOC"
En fait, c'est une instruction de contro\*^le d'exe\*'cution pluto\*^t qu'une
fonction. S'il y a un \s-1BLOC\s0 \f(CW\*(C`continue\*(C'\fR rattache\*' a\*` un \s-1BLOC\s0 (typiquement dans un
\&\f(CW\*(C`while\*(C'\fR ou un \f(CW\*(C`foreach\*(C'\fR), il est toujours exe\*'cute\*' juste avant le test a\*`
e\*'valuer a\*` nouveau, tout comme la troisie\*`me partie d'une boucle \f(CW\*(C`for\*(C'\fR en C. Il
peut donc e\*^tre utilise\*' pour incre\*'menter une variable de boucle, me\*^me si la
boucle a e\*'te\*' continue\*'e par l'instruction \f(CW\*(C`next\*(C'\fR (qui est similaire a\*`
l'instruction \f(CW\*(C`continue\*(C'\fR en C).
.Sp
\&\f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR, ou \f(CW\*(C`redo\*(C'\fR peuvent apparai\*^tre dans un bloc
\&\f(CW\*(C`continue\*(C'\fR. \f(CW\*(C`last\*(C'\fR et \f(CW\*(C`redo\*(C'\fR vont se comporter comme s'ils avaient e\*'te\*'
exe\*'cute\*'s dans le bloc principal. De me\*^me pour \f(CW\*(C`next\*(C'\fR, mais comme il va
exe\*'cuter un bloc \f(CW\*(C`continue\*(C'\fR, il peut s'ave\*'rer encore plus divertissant.
.Sp
.Vb 9
\&    while (EXPR) {
\&        ### redo vient toujours ici
\&        do_something;
\&    } continue {
\&        ### next vient toujours ici
\&        do_something_else;
\&        # puis retour au sommet pour reve\*'rifier EXPR
\&    }
\&    ### last vient toujours ici
.Ve
.Sp
Omettre la section \f(CW\*(C`continue\*(C'\fR est se\*'mantiquement e\*'quivalent a\*` en
utiliser une vide, de manie\*`re assez logique. Dans ce cas, \f(CW\*(C`next\*(C'\fR retourne
directement ve\*'rifier la condition au sommet de la boucle.
.IP "cos \s-1EXPR\s0" 8
.IX Item "cos EXPR"
Retourne le cosinus de \s-1EXPR\s0 (exprime\*' en radians). Si \s-1EXPR\s0 est omis,
calcule le cosinus de \f(CW$_\fR.
.Sp
Pour la fonction re\*'ciproque, vous pouvez utiliser la fonction
\&\f(CW\*(C`Math:;Trig::acos()\*(C'\fR ou alors utiliser cette relation\ :
.Sp
.Vb 1
\&    sub acos { atan2( sqrt(1 \- $_[0] * $_[0]), $_[0] ) }
.Ve
.IP "crypt \s-1TEXTE\s0,SEL" 8
.IX Item "crypt TEXTE,SEL"
Crypte une chai\*^ne de caracte\*`res exactement comme la fonction \fIcrypt\fR\|(3) de la
bibliothe\*`que C (en supposant que vous en avez une version dont elle n'a pas
e\*'te\*' extirpe\*'e en tant que munition potentielle). Ceci peut s'ave\*'rer utile,
entre autres choses, pour ve\*'rifier le fichier de mots de passe a\*` la recherche
de mots de passe bancals. Seuls les types portant un chapeau blanc devraient
faire c\*,a.
.Sp
Notez que \f(CW\*(C`crypt()\*(C'\fR est conc\*,u pour e\*^tre une fonction a\*` sens unique, un peu
comme les oeufs qu'on casse pour faire une omelette. Il n'y a aucune fonction
(connue) pour de\*'crypter (donc \fIcrypt()\fR est une fonction de hachage a\*` sens
unique). Par conse\*'quent, cette fonction n'est pas du tout utile pour de la
cryptographie. (Pour c\*,a, voyez pluto\*^t votre miroir \s-1CPAN\s0 le plus proche.)
.Sp
Pour ve\*'rifier une chai\*^ne crypte\*'e, vous devriez utiliser cette chai\*^ne crypte\*'e
comme \s-1SEL\s0 (comme dans \f(CW\*(C`crypt($plain, $crypted) eq $crypted\*(C'\fR). Cela permet a\*`
votre script de fonctionner aussi bien avec le \f(CW\*(C`crypt\*(C'\fR standard qu'avec des
imple\*'mentations plus exotiques. En d'autres termes, vous ne pouvez rien
supposer sur le contenu de la chai\*^ne produite ou sur la taille de la chai\*^ne
ainsi chiffre\*'e.
.Sp
Traditionnellement, le re\*'sultat est une chai\*^ne de 13 octets\ : les deux
premiers octets du \s-1SEL\s0, suivis de 11 octets pris dans l'ensemble
\&\f(CW\*(C`[./0\-9A\-Za\-z]\*(C'\fR et seul les huit premiers octets de la chai\*^ne a\*` encrypter
comptent. Mais des me\*'thodes de hachages alternatives (comme \s-1MD5\s0) ou un niveau
de se\*'curite\*' plus haut (comme C2) ou des imple\*'mentations sur des plateformes
non-UNIX peuvent produire d'autres types de chai\*^nes.
.Sp
Lorsque vous choisissez un nouveau \s-1SEL\s0 constitue\*' de deux caracte\*`res
ale\*'atoires, ces caracte\*`res doivent provenir de l'ensemble \f(CW\*(C`[./0\-9A\-Za\-z]\*(C'\fR
(Exemple \f(CW\*(C`join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]\*(C'\fR).
.Sp
Voici un exemple qui garantit que quiconque lance ce programme connai\*^t son
propre mot de passe\ :
.Sp
.Vb 2
\&    $pwd = (getpwuid($<))[1];
\&    $salt = substr($pwd, 0, 2);
\&
\&    system "stty \-echo";
\&    print "Password: ";
\&    chop($word = <STDIN>);
\&    print "\en";
\&    system "stty echo";
\&
\&    if (crypt($word, $salt) ne $pwd) {
\&        die "Sorry...\en";
\&    } else {
\&        print "ok\en";
\&    }
.Ve
.Sp
Bien e\*'videmment, donner votre mot de passe a\*` quiconque vous le demande
est tre\*`s peu recommande\*'.
.Sp
La fonction \f(CW\*(C`crypt\*(C'\fR n'est pas utilisable pour chiffrer de grande quantite\*'
d'information de\*'ja\*` parce que vous ne pouvez pas retrouver l'information
initiale. Regardez les re\*'pertoires \fIby\-module/Crypt\fR et \fIby\-module/PGP\fR sur
votre miroir \s-1CPAN\s0 pre\*'fe\*'re\*' pour y trouver des modules plus pratiques.
.Sp
Si vous utilisez \fIcrypt()\fR sur une chai\*^ne Unicode (qui contient
\&\fIe\*'ventuellement\fR des caracte\*`res dont l'encodage est supe\*'rieur a\*` 255), Perl
essaie de se sortir de cette situation en de\*'gradant une copie de la chai\*^ne
vers un encodage sur 8 bits avant d'appeler \fIcrypt()\fR sur cette copie. Si cela
fonctionne, tout est bon. Sinon, \fIcrypt()\fR meurt (die) avec les message \f(CW\*(C`Wide
character in crypt\*(C'\fR.
.IP "dbmclose \s-1HASH\s0" 8
.IX Item "dbmclose HASH"
[Cette fonction a e\*'te\*' remplace\*'e par la fonction \f(CW\*(C`untie()\*(C'\fR.]
.Sp
Rompt le lien entre un fichier \s-1DBM\s0 et une table de hachage.
.IP "dbmopen \s-1HASH\s0,DBNOM,MODE" 8
.IX Item "dbmopen HASH,DBNOM,MODE"
[Cette fonction a e\*'te\*' remplace\*'e par la fonction \f(CW\*(C`tie()\*(C'\fR.]
.Sp
Cette fonction lie un fichier \fIdbm\fR\|(3), \fIndbm\fR\|(3), \fIsdbm\fR\|(3), \fIgdbm\fR\|(3), ou Berkeley
\&\s-1DB\s0 a\*` une table de hachage. \s-1HASH\s0 est le nom de la table de hachage. (A\*` la
diffe\*'rence du \f(CW\*(C`open()\*(C'\fR normal, le premier argument n'est \fIpas\fR un
descripteur de fichier, me\*^me s'il en a l'air). \s-1DBNOM\s0 est le nom de la base de
donne\*'es (sans l'extension \fI.dir\fR ou \fI.pag\fR, le cas e\*'che\*'ant). Si la base de
donne\*'es n'existe pas, elle est cre\*'e\*'e avec les droits spe\*'cifie\*'s par \s-1MODE\s0 (et
modifie\*'s par \f(CW\*(C`umask\*(C'\fR). Si votre syste\*`me supporte uniquement les anciennes
fonctions \s-1DBM\s0, vous ne pouvez exe\*'cuter qu'un seul \f(CW\*(C`dbmopen()\*(C'\fR dans votre
programme. Dans les anciennes versions de Perl, si votre syste\*`me n'avait ni
\&\s-1DBM\s0 ni ndbm, l'appel a\*` \f(CW\*(C`dbmopen()\*(C'\fR produisait une erreur fatale\ ; il
utilise maintenant \fIsdbm\fR\|(3).
.Sp
Si vous n'avez pas les droits d'e\*'criture sur le fichier \s-1DBM\s0, vous pouvez
seulement lire les variables de la table de hachage, vous ne pouvez pas y
e\*'crire. Si vous souhaitez tester si vous pouvez y e\*'crire, faites un test sur
le fichier ou essayez d'e\*'crire une entre\*'e bidon dans la table de hachage, a\*`
l'inte\*'rieur d'un \f(CW\*(C`eval()\*(C'\fR, qui interceptera l'erreur.
.Sp
Notez que les fonctions telles que \f(CW\*(C`keys()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR peuvent retourner
des listes gigantesques si elles sont utilise\*'es sur de gros fichiers \s-1DBM\s0. Vous
devriez pre\*'fe\*'rer la fonction \f(CW\*(C`each()\*(C'\fR pour parcourir des fichiers \s-1DBM\s0
volumineux. Exemple\ :
.Sp
.Vb 6
\&    # imprime en sortie les index du fichier d'historiques
\&    dbmopen(%HIST,'/usr/lib/news/history',0666);
\&    while (($key,$val) = each %HIST) {
\&        print $key, ' = ', unpack('L',$val), "\en";
\&    }
\&    dbmclose(%HIST);
.Ve
.Sp
Voir aussi AnyDBM_File pour une description plus ge\*'ne\*'rale des avantages et
inconve\*'nients des diffe\*'rentes approches dbm ainsi que DB_File pour une
imple\*'mentation particulie\*`rement riche.
.Sp
Vous pouvez contro\*^ler la bibliothe\*`que \s-1DBM\s0 utilise\*' en chargeant cette
bibliothe\*`que avant l'appel a\*` \fIdbmopen()\fR\ :
.Sp
.Vb 3
\&    use DB_File;
\&    dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db")
\&        or die "Can't open netscape history file: $!";
.Ve
.IP "defined \s-1EXPR\s0" 8
.IX Item "defined EXPR"
.PD 0
.IP "defined" 8
.IX Item "defined"
.PD
Retourne une valeur boole\*'enne exprimant si \s-1EXPR\s0 a une valeur autre que
la valeur inde\*'finie \f(CW\*(C`undef\*(C'\fR. Si \s-1EXPR\s0 est absent, \f(CW$_\fR sera ve\*'rifie\*'e
de la sorte.
.Sp
De nombreuses ope\*'rations retournent \f(CW\*(C`undef\*(C'\fR pour signaler un e\*'chec, la fin
d'un fichier, une erreur syste\*`me, une variable non initialise\*'e et d'autres
conditions exceptionnelles. Cette fonction vous permet de distinguer \f(CW\*(C`undef\*(C'\fR
des autres valeurs. (Un simple test boole\*'en ne distinguera pas \f(CW\*(C`undef\*(C'\fR, ze\*'ro,
la chai\*^ne de caracte\*`res vide et <\*(L"0\*(R">, qui repre\*'sentent tous faux.) Notez que
puisque \f(CW\*(C`undef\*(C'\fR est un scalaire valide, sa pre\*'sence n'indique pas
\&\fIne\*'cessairement\fR une condition exceptionnelle\ : \f(CW\*(C`pop()\*(C'\fR retourne \f(CW\*(C`undef\*(C'\fR
quand son argument est un tableau vide \fIou\fR quand l'e\*'le\*'ment a\*` retourner a la
valeur \f(CW\*(C`undef\*(C'\fR.
.Sp
Vous pouvez aussi utiliser \f(CW\*(C`defined(&func)\*(C'\fR pour ve\*'rifier si la subroutine
\&\f(CW&func\fR a de\*'ja\*` e\*'te\*' de\*'finie. La valeur retourne\*'e ne sera pas affecte\*'e par une
de\*'claration pre\*'alable de \f(CW&func\fR.
.Sp
L'utilisation de \f(CW\*(C`defined()\*(C'\fR sur des agre\*'gats (tables de hachage et
tableaux) est de\*'pre\*'cie\*'e. C'e\*'tait utilise\*' pour savoir si de la me\*'moire avait
de\*'ja\*` e\*'te\*' alloue\*'e pour cet agre\*'gat. Ce comportement pourrait disparai\*^tre
dans une future version de Perl. Vous devriez utiliser un simple test de
taille a\*` la place\ :
.Sp
.Vb 2
\&    if (@an_array) { print "has array elements\en" }
\&    if (%a_hash)   { print "has hash members\en"   }
.Ve
.Sp
Utilise\*' sur un e\*'le\*'ment de table de hachage, il vous indique si la valeur est
de\*'finie, mais pas si la cle\*' existe dans la table. Utilisez \*(L"exists\*(R" dans ce
but.
.Sp
Exemples\ :
.Sp
.Vb 6
\&    print if defined $switch{'D'};
\&    print "$val\en" while defined($val = pop(@ary));
\&    die "Can't readlink $sym: $!"
\&        unless defined($value = readlink $sym);
\&    sub foo { defined &$bar ? &$bar(@_) : die "No bar"; }
\&    $debugging = 0 unless defined $debugging;
.Ve
.Sp
Note\ : de nombreuses personnes ont tendance a\*` trop utiliser \f(CW\*(C`defined()\*(C'\fR et
sont donc surprises de de\*'couvrir que le nombre \f(CW0\fR et \f(CW""\fR (la chai\*^ne de
caracte\*`res vide) sont, en fait, des valeurs de\*'finies. Par exemple, si vous
e\*'crivez\ :
.Sp
.Vb 1
\&    "ab" =~ /a(.*)b/;
.Ve
.Sp
La recherche de motif re\*'ussit et \f(CW$1\fR est de\*'finie, malgre\*' le fait
qu'il ne correspond a\*` \*(L"rien\*(R". Mais elle n'a pas ve\*'ritablement rien
trouve\*' \*(-- elle a pluto\*^t trouve\*' quelque chose qui s'est ave\*'re\*' e\*^tre
d'une longueur de \f(CW0\fR caracte\*`res. Tout ceci reste tre\*`s loyal et
honne\*^te. Quand une fonction retourne une valeur inde\*'finie, il est
admis qu'elle ne pourrait pas vous donner une re\*'ponse honne\*^te. Vous
devriez donc utiliser \f(CW\*(C`defined()\*(C'\fR uniquement lorsque vous vous posez
des questions sur l'inte\*'grite\*' de ce que vous tentez de faire. Sinon,
une simple comparaison avec \f(CW0\fR ou \f(CW""\fR est ce que vous voulez.
.Sp
Voir aussi \*(L"undef\*(R", \*(L"exists\*(R", \*(L"ref\*(R".
.IP "delete \s-1EXPR\s0" 8
.IX Item "delete EXPR"
A\*` partir d'une expression \s-1EXPR\s0 qui spe\*'cifie un e\*'le\*'ment ou un ensemble
d'e\*'le\*'ments (slice) d'une table de hachage ou d'un tableau, supprime le(s)
e\*'le\*'ment(s) spe\*'cifie\*'(s) de la table de hachage ou du tableau. Dans le cas d'un
tableau, si les e\*'le\*'ments supprime\*'s se trouvent a\*` la fin du tableau, la taille
du tableau est re\*'duite a\*` l'indice le plus grand de tous les indices des
e\*'le\*'ments restants qui donnent une valeur vraie lorsqu'on teste leur existence
via \fIexists()\fR (ou 0 si aucun e\*'le\*'ment n'existe).
.Sp
Retourne tous les e\*'le\*'ments ainsi supprime\*'s ou la valeur inde\*'finie (undef) si
aucun e\*'le\*'ment n'a e\*'te\*' supprime\*'. Supprimer des e\*'le\*'ments dans \f(CW$ENV{}\fR modifie
les variables d'environnement. Supprimer des e\*'le\*'ments d'une table de hachage
lie\*'e a\*` un fichier \s-1DBM\s0 supprime ces e\*'le\*'ments du fichier. Supprimer des e\*'le\*'ments
d'une table de hachage ou d'un tableau lie\*' ne retourne pas ne\*'cessairement
quelque chose.
.Sp
Supprimer un e\*'le\*'ment d'un tableau re\*'initialise effectivement cet emplacement a\*`
sa valeur inde\*'finie initiale. En conse\*'quence, un test d'existence sur cet
e\*'le\*'ment via \fIexists()\fR retournera faux. Notez bien que supprimer des e\*'le\*'ments au
milieu d'un tableau ne de\*'cale pas vers le bas les indices des e\*'le\*'ments
suivants \*(-- utiliser \fIsplice()\fR pour cela. Voir \*(L"exists\*(R".
.Sp
Le code suivant supprime (de manie\*`re inefficace) toutes les valeurs de \f(CW%HASH\fR
et de \f(CW@TABLEAU\fR\ :
.Sp
.Vb 3
\&    foreach $key (keys %HASH) {
\&        delete $HASH{$key};
\&    }
\&
\&    foreach $index (0 .. $#TABLEAU) {
\&        delete $TABLEAU[$index];
\&    }
.Ve
.Sp
De me\*^me que le code suivant\ :
.Sp
.Vb 1
\&    delete @HASH{keys %HASH}
\&
\&    delete @TABLEAU[0 .. $#TABLEAU];
.Ve
.Sp
Ces deux me\*'thodes restent toutefois beaucoup plus lentes que la simple
assignation de la liste vide ou l'utilisation de \f(CW\*(C`undef()\*(C'\fR sur \f(CW%HASH\fR ou
\&\f(CW@TABLEAU\fR\ :
.Sp
.Vb 2
\&    %HASH = ();         # vider comple\*`tement %HASH
\&    undef %HASH;        # oublier que %HASH a existe\*'
\&
\&    @TABLEAU = ();      # vider comple\*`tement @TABLEAU
\&    undef @TABLEAU;     # oublier que @TABLEAU a existe\*'
.Ve
.Sp
Notez que \s-1EXPR\s0 peut e\*^tre arbitrairement complique\*'e tant que l'ope\*'ration finale
se re\*'fe\*`re a\*` un e\*'le\*'ment ou une partie d'une table de hachage ou d'un tableau\ :
.Sp
.Vb 2
\&    delete $ref\->[$x][$y]{$key};
\&    delete @{$ref\->[$x][$y]}{$key1, $key2, @morekeys};
\&
\&    delete $ref\->[$x][$y][$index];
\&    delete @{$ref\->[$x][$y]}[$index1, $index2, @moreindices];
.Ve
.IP "die \s-1LISTE\s0" 8
.IX Item "die LISTE"
En dehors d'un \f(CW\*(C`eval()\*(C'\fR, affiche les valeur de la \s-1LISTE\s0 sur \f(CW\*(C`STDERR\*(C'\fR et
quitte avec la valeur actuelle de \f(CW$!\fR (nume\*'ro d'erreur errno). Si \f(CW$!\fR est
\&\f(CW0\fR, sort avec la valeur \f(CW\*(C`($? >> 8)\*(C'\fR (statut d'une `commande` entre
simples apostrophes inverses). Si \f(CW\*(C`($? >> 8)\*(C'\fR est \f(CW0\fR, sort avec
\&\f(CW255\fR. A\*` l'inte\*'rieur d'un \f(CW\*(C`eval()\*(C'\fR, le message d'erreur est mis dans \f(CW$@\fR
et le \f(CW\*(C`eval()\*(C'\fR s'ache\*`ve sur la valeur inde\*'finie. Ce qui fait de \f(CW\*(C`die()\*(C'\fR la
fac\*,on de soulever une exception.
.Sp
Exemples e\*'quivalents\ :
.Sp
.Vb 2
\&    die "Can't cd to spool: $!\en" unless chdir '/usr/spool/news';
\&    chdir '/usr/spool/news' or die "Can't cd to spool: $!\en"
.Ve
.Sp
Si la dernie\*`re valeur de \s-1LISTE\s0 ne se termine pas par un saut de ligne, le
nume\*'ro de la ligne actuelle du script et le nume\*'ro de la ligne d'entre\*'e (le
cas e\*'che\*'ant) sont aussi affiche\*'s et un saut de ligne est ajoute\*'. Notez que \*(L"le
nume\*'ro de la ligne d'entre\*'e\*(R" (mieux connu sous le nom de \*(L"chunk\*(R") est
de\*'pendant de la notion de \*(L"ligne\*(R" courante et est disponible dans la variable
spe\*'ciale \f(CW$.\fR. Voir \*(L"$/\*(R" in perlvar et \*(L"$.\*(R" in perlvar.
.Sp
Astuce\ : parfois, la concate\*'nation de \f(CW", stopped"\fR a\*` votre message le
rendra plus sense\*' lorsque la chai\*^ne de caracte\*`res \f(CW"at foo line 123"\fR sera
ajoute\*'e. Supposez que vous exe\*'cutiez le script \*(L"canasta\*(R".
.Sp
.Vb 2
\&    die "/etc/games is no good";
\&    die "/etc/games is no good, stopped";
.Ve
.Sp
va respectivement produire
.Sp
.Vb 2
\&    /etc/games is no good at canasta line 123.
\&    /etc/games is no good, stopped at canasta line 123.
.Ve
.Sp
Voir aussi \f(CW\*(C`exit()\*(C'\fR et \f(CW\*(C`warn()\*(C'\fR et le module Carp.
.Sp
Si la \s-1LISTE\s0 est vide et que \f(CW$@\fR contient de\*'ja\*` une valeur (typiquement
provenant d'une e\*'valuation pre\*'ce\*'dente), cette valeur est re\*'utilise\*'e apre\*`s la
concate\*'nation de \f(CW"\et...propagated"\fR. Ceci est utile pour propager des
exceptions\ :
.Sp
.Vb 2
\&    eval { ... };
\&    die unless $@ =~ /Expected exception/;
.Ve
.Sp
Si \s-1LISTE\s0 est vide et que \f(CW$@\fR contient une re\*'fe\*'rence vers un objet qui a une
me\*'thode \f(CW\*(C`PROPAGATE\*(C'\fR, cette me\*'thode sera appele\*'e avec comme argument le nom du
fichier et le nume\*'ro de ligne. La valeur retourne\*'e remplacera la valeur dans
\&\f(CW$@\fR (comme si \f(CW\*(C`<$@ = eval { $@\-\*(C'\fR\s-1PROPAGATE\s0(_\|_FILE_\|_, _\|_LINE_\|_) };>> e\*'tait
appele\*').
.Sp
Si \f(CW$@\fR est vide, alors la chai\*^ne de caracte\*`res \f(CW"Died"\fR est utilise\*'e.
.Sp
L'argument de \fIdie()\fR peut aussi e\*^tre une re\*'fe\*'rence. Lorsque cela arrive a\*`
l'inte\*'rieur d'un \fIeval()\fR alors $@ contiendra cette re\*'fe\*'rence. Ce comportement
autorise une imple\*'mentation plus e\*'labore\*'e de la gestion des exceptions
utilisant des objets contenant une description arbitraire de la nature de
l'exception. Une telle utilisation est parfois pre\*'fe\*'rable a\*` la reconnaissance
d'un motif particulier par une expression rationnelle applique\*'e la valeur de
$@. Voici un exemple\ :
.Sp
.Vb 9
\&    eval { ... ; die Some::Module::Exception\->new( FOO => "bar" ) };
\&    if ($@) {
\&        if (ref($@) && UNIVERSAL::isa($@,"Some::Module::Exception")) {
\&            # gestion de Some::Module::Exception
\&        }
\&        else {
\&            # gestion de toutes les autres exceptions
\&        }
\&    }
.Ve
.Sp
E\*'tant donne\*' que perl transformera en chai\*^ne toutes les exceptions non capte\*'es
avant de les afficher, vous voudrez peut\-e\*^tre surcharger l'ope\*'ration de
transformation en chai\*^ne de tous vos objets repre\*'sentant des
exceptions. Regardez overload pour faire cela.
.Sp
Vous pouvez vous arranger pour qu'une subroutine (de callback) soit appele\*'e
juste apre\*`s le \f(CW\*(C`die()\*(C'\fR en l'attachant a\*` \f(CW$SIG{_\|_DIE_\|_}\fR. La subroutine
associe\*'e sera appele\*'e avec le texte de l'erreur et peut changer le message de
l'erreur, le cas e\*'che\*'ant, en appelant \f(CW\*(C`die()\*(C'\fR a\*` nouveau.  Voir
\&\*(L"$SIG{expr}\*(R" in perlvar pour les de\*'tails sur l'assignation des entre\*'es de
\&\f(CW%SIG\fR et \*(L"eval \s-1BLOC\s0\*(R" pour des exemples. Bien que cette fonctionnalite\*'
ait e\*'te\*' conc\*,ue afin d'e\*^tre utilise\*'e juste au moment ou\*` votre script se
termine, ce n'est pas le cas \*(-- la subroutine attache\*'e a\*` \f(CW$SIG{_\|_DIE_\|_}\fR peut
aussi e\*^tre appele\*'e lors de l'\fIeval()\fRuation d'un bloc ou d'une chai\*^ne\ ! Si
vous voulez que votre subroutine ne fasse rien dans ce cas, utilisez\ :
.Sp
.Vb 1
\&        die @_ if $^S;
.Ve
.Sp
comme premie\*`re ligne de votre subroutine (Voir \*(L"$^S\*(R" in perlvar). E\*'tant donne\*'
que cela peut engendrer des choses e\*'tranges, ce comportement contre-intuitif
devrait e\*^tre change\*' dans une prochaine version.
.IP "do \s-1BLOC\s0" 8
.IX Item "do BLOC"
Pas vraiment une fonction. Retourne la valeur de la dernie\*`re commande dans la
suite de commandes contenues dans \s-1BLOC\s0. Lorsque modifie\*' par un modificateur de
boucle, exe\*'cute le \s-1BLOC\s0 une fois avant le test de la condition de
boucle. (Dans les autres cas, le modificateur de boucle teste la condition
d'abord.)
.Sp
\&\f(CW\*(C`do BLOC\*(C'\fR n'est \fIpas\fR conside\*'re\*' comme une boucle et donc les instructions de
contro\*^le de boucle \f(CW\*(C`next\*(C'\fR, \f(CW\*(C`last\*(C'\fR et \f(CW\*(C`redo\*(C'\fR ne peuvent pas e\*^tre utilise\*'es
pour quitter ou rede\*'marrer le bloc. Voir perlsyn pour des strate\*'gies
alternatives.
.IP "do \s-1ROUTINE\s0(\s-1LISTE\s0)" 8
.IX Item "do ROUTINE(LISTE)"
Forme de\*'pre\*'cie\*'e d'appel de routine. Voir perlsub.
.IP "do \s-1EXPR\s0" 8
.IX Item "do EXPR"
Utilise la valeur de \s-1EXPR\s0 comme nom de fichier et exe\*'cute le contenu de ce
fichier en tant que script Perl. Son utilite\*' premie\*`re est d'inclure les
subroutines d'une bibliothe\*`ques de subroutines Perl.
.Sp
.Vb 1
\&    do 'stat.pl';
.Ve
.Sp
est identique a\*`
.Sp
.Vb 1
\&    eval `cat stat.pl`;
.Ve
.Sp
sauf que c'est plus efficace et concis, qu'une trace du fichier courant est
garde\*'e pour les messages d'erreur, que la recherche du fichier a lieu dans
dans tous les re\*'pertoires de \f(CW@INC\fR et que, si le fichier est trouve\*', \f(CW%INC\fR
est mis a\*` jour. Voir \*(L"Noms pre\*'de\*'finis\*(R" in perlvar pour ces variables. De plus,
les variables lexicales visibles lors de l'appel ne sont pas vues par \f(CW\*(C`do
NOMFICHIER\*(C'\fR alors qu'elle le sont par \f(CW\*(C`eval CHAINE\*(C'\fR. En revanche, dans les
deux cas, le fichier est retraite\*' a\*` chaque fois que vous l'appeler ce qui
n'est probablement pas ce que vous voudriez faire a\*` l'inte\*'rieur d'une boucle.
.Sp
Si \f(CW\*(C`do\*(C'\fR ne peut pas lire le fichier, il retourne undef et assigne l'erreur a\*`
\&\f(CW$!\fR. Si \f(CW\*(C`do\*(C'\fR peut lire le fichier mais non le compiler, il retourne undef
et assigne une message d'erreur a\*` \f(CW$@\fR. Si le fichier est compile\*' avec
succe\*`s, \f(CW\*(C`do\*(C'\fR retourne la valeur de la dernie\*`re expression e\*'value\*'e.
.Sp
Notez que l'inclusion de modules de bibliothe\*`ques est mieux faite par les
ope\*'rateurs \f(CW\*(C`use()\*(C'\fR et \f(CW\*(C`require()\*(C'\fR qui effectuent aussi une ve\*'rification
automatique des erreurs et soule\*`vent une exception s'il y a le moindre
proble\*`me.
.Sp
Vous pourriez aimer utiliser \f(CW\*(C`do\*(C'\fR pour lire le fichier de configuration d'un
programme. La ve\*'rification manuelle d'erreurs peut e\*^tre effectue\*'e de la fac\*,on
suivante\ :
.Sp
.Vb 9
\&    # lecture des fichiers : d'abord le syste\*`me puis l'utilisateur
\&    for $file ("/share/prog/defaults.rc",
\&               "$ENV{HOME}/.someprogrc") {
\&        unless ($return = do $file) {
\&            warn "couldn't parse $file: $@" if $@;
\&            warn "couldn't do $file: $!"    unless defined $return;
\&            warn "couldn't run $file"       unless $return;
\&        }
\&    }
.Ve
.IP "dump \s-1LABEL\s0" 8
.IX Item "dump LABEL"
Ceci provoque imme\*'diatement la cre\*'ation de l'image me\*'moire du programme (core
dump). Voir aussi l'option de ligne de commande \fB\-u\fR dans perlrun qui fait
la me\*^me chose. Au de\*'part, ceci permet d'utiliser le programme \fBundump\fR (non
fourni) pour convertir votre image me\*'moire en un programme binaire exe\*'cutable
apre\*`s avoir initialise\*' toutes vos variables au de\*'but du programme. Quand le
nouveau binaire est exe\*'cute\*', il va commencer par exe\*'cuter un \f(CW\*(C`goto LABEL\*(C'\fR
(avec toutes les restrictions dont souffre \f(CW\*(C`goto\*(C'\fR). Pensez-y comme un
branchement goto avec l'intervention d'une image me\*'moire et une
re\*'incarnation. Si \f(CW\*(C`LABEL\*(C'\fR est omis, relance le programme au
de\*'but.
.Sp
\&\s-1ATTENTION\s0\ : tout fichier ouvert au moment de la copie ne sera \s-1PAS\s0 ouvert a\*`
nouveau quand le programme sera re\*'incarne\*', avec pour re\*'sultat une confusion
possible sur la portion de Perl.
.Sp
Cet ope\*'rateur est tre\*`s largement obsole\*`te, en partie parce qu'il est tre\*`s
difficile de convertir un fichier d'image me\*'moire (core) en exe\*'cutable mais
aussi parce que le ve\*'ritable compilateur perl-en-C l'a surpasse\*'. C'est
pourquoi vous devez maintenant l'appeler par \f(CW\*(C`CORE::dump()\*(C'\fR si vous ne voulez
pas recevoir un message d'avertissement au sujet d'une erreur de frappe
possible.
.Sp
Si vous projetez d'utiliser dump pour augmenter la vitesse de votre
programme, essayez donc de produire du pseudo-code (ou bytecode) ou du C natif
comme cela est de\*'crit dans perlcc. Si vous essayez juste d'acce\*'le\*'rer un
script \s-1CGI\s0, regardez donc du co\*^te\*' de l'extension \f(CW\*(C`mod_perl\*(C'\fR de \fBApache\fR ou
de celui du module CGI::Fast sur \s-1CPAN\s0. Vous pouvez aussi envisager
l'autochargement (autoloading ou selfloading) qui donnera au moins la
\&\fIsensation\fR que votre programme va plus vite.
.IP "each \s-1HASH\s0" 8
.IX Item "each HASH"
Appele\*' dans un contexte de liste, retourne une liste de deux e\*'le\*'ments
constitue\*'e de la cle\*' et de la valeur du prochain e\*'le\*'ment d'une table de
hachage, de sorte que vous puissiez ite\*'rer sur celle\-ci. Appele\*' dans un
contexte scalaire, retourne uniquement la cle\*' de l'e\*'le\*'ment suivant de la table
de hachage.
.Sp
Les entre\*'es sont apparemment retourne\*'es dans un ordre ale\*'atoire. Cet ordre
ale\*'atoire re\*'el pourrait changer dans les versions futures de perl mais vous
avez la garantie que cet ordre sera le me\*^me, que vous utilisiez la fonction
\&\f(CW\*(C`keys\*(C'\fR ou la fonction \f(CW\*(C`values\*(C'\fR sur une me\*^me table de hachage (non modifie\*'e).
.Sp
Quand la table de hachage est entie\*`rement lue, un tableau nul est retourne\*'
dans un contexte de liste (qui, lorsqu'il est assigne\*', produit une valeur
\&\s-1FAUSSE\s0 \f(CW0\fR), et \f(CW\*(C`undef\*(C'\fR dans un contexte scalaire. Le prochain appel a\*`
\&\f(CW\*(C`each\*(C'\fR apre\*`s cela rede\*'marrera une nouvelle ite\*'ration. Il y a un seul
ite\*'rateur pour chaque table de hachage, partage\*' par tous les appels a\*` \f(CW\*(C`each\*(C'\fR,
\&\f(CW\*(C`keys\*(C'\fR ou \f(CW\*(C`values\*(C'\fR du programme\ ; il peut e\*^tre re\*'initialise\*' en lisant
tous les e\*'le\*'ments de la table ou en e\*'valuant \f(CW\*(C`keys HASH\*(C'\fR ou \f(CW\*(C`values HASH\*(C'\fR.
Si vous ajoutez ou supprimez des e\*'le\*'ments d'une table de hachage pendant que
vous ite\*'rez sur celle\-ci, vous pourriez avoir des entre\*'es ignore\*'es ou
duplique\*'es, donc ne le faites pas.
.Sp
Le code suivant affiche votre environnement comme le fait le programme
\&\fIprintenv\fR\|(1), mais dans un ordre diffe\*'rent\ :
.Sp
.Vb 3
\&    while (($key,$value) = each %ENV) {
\&        print "$key=$value\en";
\&    }
.Ve
.Sp
Voir aussi \f(CW\*(C`keys()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR.
.IP "eof \s-1DESCRIPTEUR\s0" 8
.IX Item "eof DESCRIPTEUR"
.PD 0
.IP "eof ()" 8
.IX Item "eof ()"
.IP "eof" 8
.IX Item "eof"
.PD
Retourne 1 si la prochaine lecture sur un \s-1DESCRIPTEUR\s0 de fichier va
retourner une fin de fichier, ou si le \s-1DESCRIPTEUR\s0 n'est pas
ouvert. Le \s-1DESCRIPTEUR\s0 peut e\*^tre une expression dont la valeur donne
un ve\*'ritable descripteur de fichier. (Notez que cette fonction lit en
fait un caracte\*`re puis le retire comme \f(CW\*(C`ungetc()\*(C'\fR, elle n'est donc
pas vraiment utile dans un contexte interactif.) Ne faites pas de
lecture sur un fichier d'un terminal (ou d'appel a\*` \f(CW\*(C`eof(DESCRIPTEUR)\*(C'\fR
sur celui\-ci) apre\*`s qu'une fin de fichier soit atteinte. Les types de
fichiers comme les terminaux peuvent perdre la condition de fin de
fichier si vous le faites.
.Sp
Un \f(CW\*(C`eof\*(C'\fR sans un argument utilise le dernier fichier lu comme
argument. Utiliser \f(CW\*(C`eof()\*(C'\fR avec des parenthe\*`ses vides est tre\*`s diffe\*'rent. Il
se re\*'fe\*`re alors au pseudo fichier forme\*' par les fichiers liste\*'s sur la ligne
de commande et lu par l'ope\*'rateur \f(CW\*(C`<>\*(C'\fR. Puisque \f(CW\*(C`<>\*(C'\fR n'est pas
explicitement ouvert comme l'est un descripteur de fichier normal,
l'utilisation de \f(CW\*(C`eof()\*(C'\fR avant celle de \f(CW\*(C`<>\*(C'\fR de\*'clenchera l'examen de
\&\f(CW@ARGV\fR pour voir si une entre\*'e est disponible. De manie\*`re similaire, un
\&\f(CW\*(C`eof()\*(C'\fR apre\*`s que \f(CW\*(C`<>\*(C'\fR a retourne\*' la condition fin-de-fichier supposera
que vous traitez un autre fichier de la liste \f(CW@ARGV\fR ou que vous lisez
depuis \f(CW\*(C`STDIN\*(C'\fR. Voir \*(L"Les ope\*'rateurs d'E/S\*(R" in perlop.
.Sp
Dans une boucle \f(CW\*(C`while (<>)\*(C'\fR \f(CW\*(C`eof(ARGV)\*(C'\fR ou \f(CW\*(C`eof\*(C'\fR peuvent e\*^tre
utilise\*'s pour tester la fin de \fI\s-1CHAQUE\s0\fR fichier alors que \f(CW\*(C`eof()\*(C'\fR ne
de\*'tectera que la fin du tout dernier fichier. Exemple\ :
.Sp
.Vb 7
\&    # re\*'initialise le nume\*'rotage des lignes sur chaque fichier d'entre\*'e
\&    while (<>) {
\&        next if /^\es*#/;        # saute les commentaires
\&        print "$.\et$_";
\&    } continue {
\&        close ARGV  if eof;     # ce n'est pas eof() !
\&    }
\&
\&    # inse\*`re des tirets juste avant la dernie\*`re ligne du dernier fichier
\&    while (<>) {
\&        if (eof()) {            # ve\*'rifie la fin du fichier courant
\&            print "\-\-\-\-\-\-\-\-\-\-\-\-\-\-\en";
\&            close(ARGV);        # ferme ou s'arre\*^te ; ne\*'cessaire en cas
\&                                # de lecture sur le terminal
\&        }
\&        print;
\&    }
.Ve
.Sp
Astuce pratique\ : vous n'avez presque jamais besoin d'utiliser \f(CW\*(C`eof\*(C'\fR en
Perl parce que les ope\*'rateurs d'entre\*'e retournent la valeur \f(CW\*(C`undef\*(C'\fR quand ils
n'ont plus d'informations a\*` lire ou s'il y a eu une erreur.
.IP "eval \s-1EXPR\s0" 8
.IX Item "eval EXPR"
.PD 0
.IP "eval \s-1BLOC\s0" 8
.IX Item "eval BLOC"
.PD
Dans sa premie\*`re forme, la valeur retourne\*'e par \s-1EXPR\s0 est parcourue puis
exe\*'cute\*'e comme un petit programme Perl. La valeur de l'expression (qui est
elle\-me\*^me de\*'termine\*'e dans un contexte scalaire) est d'abord parcourue puis,
s'il n'y a pas eu d'erreurs, exe\*'cute\*'e dans le contexte du programme courant,
de telle sorte que toute assignation de variable, et toute de\*'finition de
subroutine ou de format perdure apre\*`s cette exe\*'cution. Notez que la valeur est
parcourue a\*` chaque exe\*'cution d'e\*'valuation. Si \s-1EXPR\s0 est omis, e\*'value
\&\f(CW$_\fR. Cette forme est typiquement utilise\*'e pour repousser la compilation et
l'exe\*'cution du texte contenu dans \s-1EXPR\s0 jusqu'a\*` l'exe\*'cution du programme.
.Sp
Dans sa seconde forme, le code a\*` l'inte\*'rieur du \s-1BLOC\s0 est parcouru une seule
fois \*(-- au me\*^me moment que la compilation du code entourant l'e\*'valuation \*(-- et
exe\*'cute\*' dans le contexte du programme Perl courant. Cette forme est
typiquement utilise\*'e pour intercepter des exceptions plus efficacement que la
premie\*`re (voir ci\-dessous), en fournissant aussi le be\*'ne\*'fice d'une
ve\*'rification du code dans le \s-1BLOC\s0 lors de la compilation.
.Sp
Le point-virgule final, le cas e\*'che\*'ant, peut e\*^tre omis dans \s-1EXPR\s0 ou a\*`
l'inte\*'rieur du \s-1BLOC\s0.
.Sp
Dans les deux formes, la valeur retourne\*'e est la valeur de la dernie\*`re
expression e\*'value\*'e a\*` l'inte\*'rieur du mini-programme\ ; il est aussi aussi
possible d'utiliser un retour explicite (via return), exactement comme pour
les routines. L'expression fournissant la valeur de retour est e\*'value\*'e en
contexte vide, scalaire ou de liste, en fonction du contexte de l'e\*'valuation
elle\-me\*^me. Voir \*(L"wantarray\*(R" pour de plus amples informations sur la fac\*,on
dont le contexte d'e\*'valuation peut e\*^tre de\*'termine\*'.
.Sp
En cas d'erreur de syntaxe ou d'exe\*'cution ou si une instruction \f(CW\*(C`die()\*(C'\fR est
exe\*'cute\*'e, une valeur inde\*'finie (undef) est retourne\*'e par \f(CW\*(C`eval()\*(C'\fR et le
message d'erreur est assigne\*' a\*` \f(CW$@\fR. S'il n'y a pas d'erreur, vous avez la
garantie que la valeur de \f(CW$@\fR sera une chai\*^ne de caracte\*`res vide. Prenez
garde au fait qu'utiliser \f(CW\*(C`eval()\*(C'\fR ne dispense Perl ni d'afficher des
messages d'alerte (warnings) sur \s-1STDERR\s0 ni d'assigner ses messages d'alerte
dans \f(CW$@\fR. Pour ce faire, il vous faut utiliser les capacite\*'s de
\&\f(CW$SIG{_\|_WARN_\|_}\fR ou de\*'sactiver les messages d'avertissement dans le \s-1BLOC\s0 ou
l'\s-1EXPR\s0 en utilisant \f(CW\*(C`no\ warnings\ 'all'\*(C'\fR. Voir \*(L"warn\*(R", perlvar,
warnings et perllexwarn.
.Sp
E\*'tant donne\*' que \f(CW\*(C`eval()\*(C'\fR intercepte les erreurs non fatales, c'est tre\*`s
pratique pour de\*'terminer si une fonctionnalite\*' (telle que \f(CW\*(C`socket()\*(C'\fR ou
\&\f(CW\*(C`symlink()\*(C'\fR) est supporte\*'e. C'est aussi le me\*'canisme d'interception
d'exception de Perl lorsque l'ope\*'rateur die est utilise\*' pour les soulever.
.Sp
Si le code a\*` exe\*'cuter ne varie pas, vous devriez utiliser la seconde forme
avec un \s-1BLOC\s0 pour intercepter les erreurs d'exe\*'cution sans supporter
l'inconve\*'nient de le recompiler a\*` chaque fois. L'erreur, le cas e\*'che\*'ant, est
toujours retourne\*'e dans \f(CW$@\fR.  Exemples\ :
.Sp
.Vb 2
\&    # rend une division par ze\*'ro non fatale
\&    eval { $answer = $a / $b; }; warn $@ if $@;
\&
\&    # me\*^me chose, mais moins efficace
\&    eval '$answer = $a / $b'; warn $@ if $@;
\&
\&    # une erreur de compilation
\&    eval { $answer = };                 # MAUVAIS
\&
\&    # une erreur d'exe\*'cution
\&    eval '$answer =';   # sets $@
.Ve
.Sp
En utilisant la forme \f(CW\*(C`eval{}\*(C'\fR pour une interception d'exception dans des
bibliothe\*`ques, vous pourriez souhaiter ne pas exe\*'cuter une e\*'ventuelle
subroutine attache\*'e a\*` \f(CW\*(C`_\|_DIE_\|_\*(C'\fR par le code de l'utilisateur. Dans ce cas,
vous pouvez utiliser la construction \f(CW\*(C`local $SIG{_\|_DIE_\|_}\*(C'\fR comme dans
l'exemple ci-dessous\ :
.Sp
.Vb 3
\&    # une interception d'exception de division par ze\*'ro tre\*`s prive\*'e
\&    eval { local $SIG{'_\|_DIE_\|_'}; $answer = $a / $b; };
\&    warn $@ if $@;
.Ve
.Sp
Ceci est spe\*'cialement significatif, e\*'tant donne\*' que les subroutine attache\*'e a\*`
\&\f(CW\*(C`_\|_DIE_\|_\*(C'\fR peuvent appeler \f(CW\*(C`die()\*(C'\fR a\*` nouveau, ce qui a pour effet de changer
leurs messages d'erreur\ :
.Sp
.Vb 8
\&    # les subroutines attache\*'es a\*` _\|_DIE_\|_
\&    # peuvent modifier les messages d'erreur
\&    {
\&       local $SIG{'_\|_DIE_\|_'} =
\&              sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };
\&       eval { die "foo lives here" };
\&       print $@ if $@;                # affiche "bar lives here"
\&    }
.Ve
.Sp
E\*'tant donne\*' que cela favorise une action a\*` distance, ce comportement
contre-intuitif pourrait changer dans une version future.
.Sp
Avec \f(CW\*(C`eval()\*(C'\fR, vous devriez faire particulie\*`rement attention a\*` ce qui est
examine\*', et quand\ :
.Sp
.Vb 2
\&    eval $x;            # CAS 1
\&    eval "$x";          # CAS 2
\&
\&    eval '$x';          # CAS 3
\&    eval { $x };        # CAS 4
\&
\&    eval "\e$$x++";      # CAS 5
\&    $$x++;              # CAS 6
.Ve
.Sp
Les cas 1 et 2 ci-dessus se comportent de la me\*^me fac\*,on\ : ils exe\*'cutent le
code inclus dans la variable \f(CW$x\fR. (Bien que le cas 2 ait des guillemets qui
font se demander au lecteur ce qui se passe \*(-- re\*'ponse\ : rien.) Les cas 3
et 4 se comportent aussi de la me\*^me fac\*,on\ : ils exe\*'cutent le code \f(CW'$x'\fR
qui ne fait rien que retourner la valeur de \f(CW$x\fR. (Le cas 4 est pre\*'fe\*'rable
pour des raisons purement visuelles mais aussi parce qu'il a l'avantage d'e\*^tre
compile\*' lors de la compilation pluto\*^t que lors de l'exe\*'cution.) Le cas 5 est
un endroit ou\*` vous \fI\s-1DEVRIEZ\s0\fR normalement souhaiter utiliser des guillemets,
sauf que dans ce cas particulier, vous pouvez juste utiliser les re\*'fe\*'rences
symboliques a\*` la place, comme dans le cas 6.
.Sp
Un \f(CW\*(C`eval BLOC\*(C'\fR n'est pas conside\*'re\*' comme une boucle. Par conse\*'quent, les
instructions de contro\*^le de boucles \f(CW\*(C`next\*(C'\fR, \f(CW\*(C`last\*(C'\fR, ou \f(CW\*(C`redo\*(C'\fR ne peuvent
e\*^tre utilise\*'es pour quitter ou refaire le bloc.
.IP "exec \s-1LISTE\s0" 8
.IX Item "exec LISTE"
.PD 0
.IP "exec \s-1PROGRAMME\s0 \s-1LISTE\s0" 8
.IX Item "exec PROGRAMME LISTE"
.PD
La fonction \f(CW\*(C`exec()\*(C'\fR exe\*'cute une commande syste\*`me \fIet ne retourne jamais\fR \*(--
utilisez \f(CW\*(C`system()\*(C'\fR a\*` la place de \f(CW\*(C`exec()\*(C'\fR si vous souhaitez qu'elle
retourne. Elle e\*'choue et retourne \s-1FAUX\s0 si et seulement si la commande n'existe
pas \fIet\fR est exe\*'cute\*'e directement pluto\*^t que par votre interpre\*'teur de
commandes (shell) (cf. ci\-dessous).
.Sp
Comme c'est une erreur courante d'utiliser \f(CW\*(C`exec()\*(C'\fR au lieu de \f(CW\*(C`system()\*(C'\fR,
Perl vous alerte si l'expression suivante n'est pas \f(CW\*(C`die()\*(C'\fR, \f(CW\*(C`warn()\*(C'\fR, ou
\&\f(CW\*(C`exit()\*(C'\fR (si \f(CW\*(C`\-w\*(C'\fR est utilise\*' \*(-- ce que vous faites toujours, e\*'videmment.)
Si vous voulez \fIvraiment\fR faire suivre le \f(CW\*(C`exec()\*(C'\fR d'une autre expression,
vous pouvez utiliser l'une de ces me\*'thodes pour e\*'viter l'avertissement\ :
.Sp
.Vb 2
\&    exec ('foo')   or print STDERR "couldn't exec foo: $!";
\&    { exec ('foo') }; print STDERR "couldn't exec foo: $!";
.Ve
.Sp
S'il y a plus d'un argument dans la \s-1LISTE\s0, ou si la \s-1LISTE\s0 est un tableau de
plus d'une valeur, appelle \fIexecvp\fR\|(3) avec les arguments de la \s-1LISTE\s0. S'il n'y
a qu'un seul argument scalaire ou un tableau a\*` un seul e\*'le\*'ment et que cet
argument contient des me\*'ta\-caracte\*`res du shell, l'argument entier est passe\*' a\*`
l'interpre\*'teur de commandes shell pour son expansion et son exe\*'cution (il
s'agit de \f(CW\*(C`/bin/sh \-c\*(C'\fR sur les plates-formes Unix, mais cela varie en
fonction des plates\-formes.) S'il n'y a aucun me\*'ta\-caracte\*`res du shell dans
l'argument, il est de\*'coupe\*' en mots et passe\*' directement a\*` \f(CW\*(C`execvp()\*(C'\fR qui est
plus efficace. Exemples\ :
.Sp
.Vb 2
\&    exec '/bin/echo', 'Your arguments are: ', @ARGV;
\&    exec "sort $outfile | uniq";
.Ve
.Sp
Si vous ne souhaitez pas vraiment exe\*'cuter le premier argument mais pluto\*^t
l'utiliser pour dissimuler le nom du programme re\*'ellement utilise\*', vous pouvez
spe\*'cifier le vrai programme a\*` exe\*'cuter comme un \*(L"objet indirect\*(R" (sans
virgule) au de\*'but de la \s-1LISTE\s0. (Ceci force toujours l'interpre\*'tation de la
\&\s-1LISTE\s0 comme une liste multivalue\*'e, me\*^me s'il n'y a qu'un seul scalaire
dedans.) Exemple\ :
.Sp
.Vb 2
\&    $shell = '/bin/csh';
\&    exec $shell '\-sh';          # pre\*'tend qu'il s'agit d'un login shell
.Ve
.Sp
ou, plus directement,
.Sp
.Vb 1
\&    exec {'/bin/csh'} '\-sh';    # pre\*'tend qu'il s'agit d'un login shell
.Ve
.Sp
Quand les arguments sont exe\*'cute\*'s par le shell syste\*`me, les re\*'sultats
seront de\*'pendants de ses caprices et de ses capacite\*'s. Voir
\&\*(L"`CHAINE`\*(R" in perlop pour plus de de\*'tails.
.Sp
Utiliser un objet indirect avec \f(CW\*(C`exec()\*(C'\fR ou \f(CW\*(C`system()\*(C'\fR est aussi plus
su\*^r. Cet usage force l'interpre\*'tation des arguments comme une liste
multivalue\*'e, me\*^me si elle ne contient qu'un seul e\*'le\*'ment. De cette fac\*,on,
vous ne risquez rien des jokers du shell ou de la se\*'paration des mots par des
espaces.
.Sp
.Vb 1
\&    @args = ( "echo surprise" );
\&
\&    system @args;               # sujet a\*` des e\*'chappement du shell
\&                                # si @args == 1
\&    system { $args[0] } @args;  # su\*^r me\*^me avec une liste a\*` un seul e\*'le\*'ment
.Ve
.Sp
La premie\*`re version, celle sans l'objet indirect, exe\*'cute le programme
\&\fIecho\fR, en lui passant \f(CW"surprise"\fR comme argument. La seconde
version ne le fait pas \*(-- elle essaie d'exe\*'cuter un programme
litte\*'ralement appele\*' \fI\*(L"echo surprise\*(R"\fR, ne le trouve pas et assigne a\*`
\&\f(CW$?\fR une valeur non nulle indiquant une erreur.
.Sp
Depuis la version v5.6.0, Perl essaie avant d'effectuer le \fIexec()\fRde vider tous
les tampons des fichiers ouverts en e\*'criture mais ce n'est pas le cas sur
toutes les plates-formes (voir perlport). Pour e\*^tre plus su\*^r, vous devriez
positionner la variable \f(CW$|\fR ($AUTOFLUSH en anglais) ou appeler la me\*'thode
\&\f(CW\*(C`autoflush()\*(C'\fR des objets \f(CW\*(C`IO::Handle\*(C'\fR pour chacun des descripteurs ouverts
afin d'e\*'viter toute perte de donne\*'es.
.Sp
Remarquez que \f(CW\*(C`exec()\*(C'\fR n'exe\*'cutera ni vos blocs \f(CW\*(C`END\*(C'\fR ni les me\*'thodes
\&\f(CW\*(C`DESTROY\*(C'\fR de vos objets.
.IP "exists \s-1EXPR\s0" 8
.IX Item "exists EXPR"
Si \s-1EXPR\s0 spe\*'cifie un e\*'le\*'ment d'une table de hachage ou d'un tableau, retourne
\&\s-1VRAI\s0 si cet e\*'le\*'ment existe, me\*^me si la valeur correspondante est
inde\*'finie. L'e\*'le\*'ment n'est pas cre\*'e\*' automagiquement s'il n'existe pas.
.Sp
.Vb 3
\&    print "Exists\en"    if exists $array{$key};
\&    print "Defined\en"   if defined $array{$key};
\&    print "True\en"      if $array{$key};
\&
\&    print "Exists\en"    if exists $hash{$key};
\&    print "Defined\en"   if defined $hash{$key};
\&    print "True\en"      if $hash{$key};
\&
\&    print "Exists\en"    if exists $array[$index];
\&    print "Defined\en"   if defined $array[$index];
\&    print "True\en"      if $array[$index];
.Ve
.Sp
Un e\*'le\*'ment d'une table de hachage ou d'un tableau ne peut e\*^tre \s-1VRAI\s0 que s'il
est de\*'fini, et de\*'fini que s'il existe, mais la re\*'ciproque n'est pas
ne\*'cessairement vraie.
.Sp
Si \s-1EXPR\s0 spe\*'cifie le nom d'une subroutine, retourne \s-1VRAI\s0 si la subroutine
spe\*'cifie\*'e a de\*'ja\*` e\*'te\*' de\*'clare\*'e, me\*^me si elle est toujours inde\*'finie. Utiliser
un nom de subroutine pour tester si elle existe (exists) ou si elle est
de\*'finie (defined) ne compte pas comme une de\*'claration.
.Sp
.Vb 2
\&    print "Exists\en"    if exists &subroutine;
\&    print "Defined\en"   if defined &subroutine;
.Ve
.Sp
Notez que l'expression \s-1EXPR\s0 peut e\*^tre arbitrairement complique\*'e tant qu'au
final, elle de\*'signe une subroutine ou un e\*'le\*'ment d'une table de hachage ou
d'un tableau\ :
.Sp
.Vb 2
\&    if (exists $ref\->{A}\->{B}\->{$key})  { }
\&    if (exists $hash{A}{B}{$key})       { }
\&
\&    if (exists $ref\->{A}\->{B}\->[$ix])   { }
\&    if (exists $hash{A}{B}[$ix])        { }
\&
\&    if (exists &{$ref\->{A}{B}{$key}})   { }
.Ve
.Sp
Bien que l'e\*'le\*'ment le plus profond ne soit pas soudainement cre\*'e\*' juste parce
son existence a e\*'te\*' teste\*'e, les e\*'le\*'ments interme\*'diaires, eux, le seront. Par
conse\*'quent, \f(CW\*(C`$ref\->{"A"}\*(C'\fR et \f(CW\*(C`$ref\->{"A"}\->{"B"}\*(C'\fR seront cre\*'e\*'s a\*`
cause du test d'existence de l'e\*'le\*'ment lie\*' a\*` la cle\*' \f(CW$key\fR ci\-dessus. Cela
arrivera a\*` chaque fois que l'ope\*'rateur fle\*`che est utilise\*', y compris dans le
cas suivant\ :
.Sp
.Vb 3
\&    undef $ref;
\&    if (exists $ref\->{"Some key"})      { }
\&    print $ref;             # affiche HASH(0x80d3d5c)
.Ve
.Sp
Cette ge\*'ne\*'ration spontane\*'e un peu surprenante qui, au premier coup d'oeil (ni
me\*^me au second d'ailleurs), n'est pas dans le contexte d'une lvalue pourrait
e\*^tre supprime\*'e dans une version future.
.Sp
Voir \*(L"Pseudo\-tables de hachage : utiliser un tableau comme table de
hachage\*(R" in perlref pour des informations spe\*'cifiques concernant l'utilisation de
\&\fIexists()\fR sur les pseudo\-hachages.
.Sp
L'utilisation d'un appel a\*` une subroutine a\*` la place du nom de cette
subroutine comme argument de \fIexists()\fR est une erreur.
.Sp
.Vb 2
\&    exists &sub;        # OK
\&    exists &sub();      # Erreur
.Ve
.IP "exit \s-1EXPR\s0" 8
.IX Item "exit EXPR"
E\*'value \s-1EXPR\s0 puis quitte imme\*'diatement avec cette valeur. Exemple\ :
.Sp
.Vb 2
\&    $ans = <STDIN>;
\&    exit 0 if $ans =~ /^[Xx]/;
.Ve
.Sp
Voir aussi \f(CW\*(C`die()\*(C'\fR. Si l'expression \s-1EXPR\s0 est omise, quitte avec le statut
\&\f(CW0\fR. Les seules valeurs universellement reconnues pour \s-1EXPR\s0 sont \f(CW0\fR en cas
de re\*'ussite et \f(CW1\fR en cas d'erreur\ ; toutes les autres valeurs sont sujettes
a\*` des interpre\*'tations impre\*'visibles, en fonction de l'environnement dans
lequel le programme Perl est exe\*'cute\*'. Par exemple, terminer un filtre de
messages entrants de \fIsendmail\fR avec comme valeur 69 (\s-1EX_UNAVAILABLE\s0)
provoquera la non livraison du message, mais ce n'est pas vrai partout.
.Sp
Vous ne devriez pas utiliser \f(CW\*(C`exit()\*(C'\fR pour interrompre une routine s'il
existe une chance pour que quelqu'un souhaite intercepter une erreur qui
arrive. Utilisez \f(CW\*(C`die()\*(C'\fR a\*` la place, qui peut e\*^tre intercepte\*' par un
\&\f(CW\*(C`eval()\*(C'\fR.
.Sp
La fonction \fIexit()\fR ne termine pas toujours le process imme\*'diatement. Elle
appelle d'abord toutes les routines \f(CW\*(C`END\*(C'\fR de\*'finies, mais ces routines \f(CW\*(C`END\*(C'\fR
ne peuvent pas annuler la terminaison. De la me\*^me fac\*,on, tout destructeur
d'objet qui doit e\*^tre appele\*' le sera avant la sortie. Si cela pose proble\*`me,
vous pouvez appele\*' \f(CW\*(C`POSIX:_exit($status)\*(C'\fR pour e\*'viter le traitement des
destructeurs et des subroutine \s-1END\s0. Voir perlmod pour les de\*'tails.
.IP "exp \s-1EXPR\s0" 8
.IX Item "exp EXPR"
.PD 0
.IP "exp" 8
.IX Item "exp"
.PD
Retourne \fIe\fR (la base des logarithmes naturels ou ne\*'pe\*'rien) e\*'leve\*' a\*` la
puissance \s-1EXPR\s0. Si \s-1EXPR\s0 est omis, retourne \f(CW\*(C`exp($_)\*(C'\fR.
.IP "fcntl \s-1DESCRIPTEUR\s0, \s-1FONCTION\s0, \s-1SCALAIRE\s0" 8
.IX Item "fcntl DESCRIPTEUR, FONCTION, SCALAIRE"
Imple\*'mente la fonction \fIfcntl\fR\|(2). Vous devrez probablement d'abord e\*'crire
.Sp
.Vb 1
\&    use Fcntl;
.Ve
.Sp
pour avoir les de\*'finitions de constantes correctes. Le traitement de
l'argument et la valeur de retour se fait exactement de la me\*^me
manie\*`re que \f(CW\*(C`ioctl()\*(C'\fR plus bas.
Par exemple\ :
.Sp
.Vb 3
\&    use Fcntl;
\&    fcntl($filehandle, F_GETFL, $packed_return_buffer)
\&        or die "can't fcntl F_GETFL: $!";
.Ve
.Sp
Vous n'avez pas a\*` ve\*'rifier le re\*'sultat de \f(CW\*(C`fnctl()\*(C'\fR via \f(CW\*(C`defined()\*(C'\fR. Comme
\&\f(CW\*(C`ioctl()\*(C'\fR, elle transforme le retour \f(CW0\fR de l'appel syste\*`me en un "\f(CW\*(C`0 but
true\*(C'\fR" en Perl. Cette chai\*^ne est vraie dans un contexte boole\*'en et vaut \f(CW0\fR
dans un contexte nume\*'rique. Elle est aussi exempte des alertes habituelles de
\&\fB\-w\fR sur les conversions nume\*'riques impropres.
.Sp
Notez que \f(CW\*(C`fcntl()\*(C'\fR produira une erreur fatale si elle est utilise\*'e sur une
machine n'imple\*'mentant pas \fIfcntl\fR\|(2). Voir le module Fcntl ou \fIfcntl\fR\|(2) pour
connai\*^tre les fonctions disponibles sur votre syste\*`me.
.IP "fileno \s-1DESCRIPTEUR\s0" 8
.IX Item "fileno DESCRIPTEUR"
Retourne le nume\*'ro syste\*`me associe\*' a\*` un descripteur de fichier. Ceci est utile
pour construire des vecteurs pour \f(CW\*(C`select()\*(C'\fR et pour les ope\*'rations \s-1POSIX\s0 de
manipulation bas niveau de terminaux tty. Si \s-1DESCRIPTEUR\s0 est une expression,
la valeur est prise comme un descripteur indirect, ge\*'ne\*'ralement son nom.
.Sp
Vous pouvez utiliser ceci pour de\*'terminer si deux descripteurs se re\*'fe\*`rent au
me\*^me nume\*'ro sous-jacent\ :
.Sp
.Vb 3
\&    if (fileno(THIS) == fileno(THAT)) {
\&        print "THIS and THAT are dups\en";
\&    }
.Ve
.Sp
(Les descripteurs connecte\*'s a\*` des objets en me\*'moire via les nouvelles
fonctionnalite\*'s de \f(CW\*(C`open\*(C'\fR peuvent retourner une valeur inde\*'finie bien qu'ils
soient ouverts.)
.IP "flock \s-1DESCRIPTEUR\s0,OPERATION" 8
.IX Item "flock DESCRIPTEUR,OPERATION"
Appelle \fIflock\fR\|(2), ou son e\*'mulation, sur le \s-1DESCRIPTEUR\s0. Retourne \s-1VRAI\s0 en cas
de succe\*`s, \s-1FAUX\s0 en cas d'e\*'chec. Produit une erreur fatale lorsqu'il est
utilise\*' sur une machine n'imple\*'mentant pas \fIflock\fR\|(2), le verrouillage \fIfcntl\fR\|(2),
ou \fIlockf\fR\|(3). \f(CW\*(C`flock()\*(C'\fR est une interface Perl portable de verrouillage de
fichiers, bien qu'il ne verrouille que des fichiers en entier, et non pas des
enregistrements.
.Sp
La se\*'mantique non e\*'vidente mais ne\*'anmoins traditionnelle de \f(CW\*(C`flock\*(C'\fR consiste
a\*` attendre inde\*'finiment jusqu'a\*` la libe\*'ration du verrou. Ce verrou est
\&\fBpurement consultatif\fR. De tels verrous sont plus faciles d'utilisation mais
offrent moins de garantie. Cela signifie que des fichiers verrouille\*'s via
\&\f(CW\*(C`flock\*(C'\fR peuvent e\*^tre modifie\*'s par des programmes n'utilisant pas
\&\f(CW\*(C`flock\*(C'\fR. Voir perlport ou les pages de manuel de votre syste\*`me pour la
documentation plus de\*'taille\*'e. Il vaut mieux faire avec ce comportement
traditionnel si vous visez la portabilite\*'. (Sinon, libre a\*` vous d'utiliser les
fonctionnalite\*'s (\*(L"features\*(R") de votre syste\*`me d'exploitation. Les contraintes
de portabilite\*' ne doivent pas vous empe\*^cher de faire ce que voulez.)
.Sp
\&\s-1OPERATION\s0 peut e\*^tre \s-1LOCK_SH\s0, \s-1LOCK_EX\s0 ou \s-1LOCK_UN\s0, e\*'ventuellement combine\*'e avec
\&\s-1LOCK_NB\s0. Ces constantes ont traditionnellement pour valeurs 1, 2, 8 et 4, mais
vous pouvez utiliser les noms symboliques s'ils sont importe\*'s du module Fcntl,
soit individuellement, soit en tant que groupe en utilisant la balise
\&':flock'. \s-1LOCK_SH\s0 demande un verrou partage\*', \s-1LOCK_EX\s0 demande un verrou
exclusif et \s-1LOCK_UN\s0 libe\*`re un verrou pre\*'ce\*'demment demande\*'. Si \s-1LOCK_NB\s0 est
ajoute\*' a\*` \s-1LOCK_SH\s0 ou \s-1LOCK_EX\s0 (via un 'ou' bit a\*` bit) alors \f(CW\*(C`flock()\*(C'\fR
retournera imme\*'diatement pluto\*^t que d'attendre la libe\*'ration du verrou
(ve\*'rifiez le code de retour pour savoir si vous l'avez obtenu).
.Sp
Pour e\*'viter une mauvaise synchronisation, Perl vide le tampon du \s-1DESCRIPTEUR\s0
avant de le (de\*')verrouiller.
.Sp
Notez que l'e\*'mulation construite avec \fIlockf\fR\|(3) ne fournit pas de verrous
partage\*'s et qu'il exige que \s-1DESCRIPTEUR\s0 soit ouvert en e\*'criture. Ce sont les
se\*'mantiques qu'imple\*'mente \fIlockf\fR\|(3). La plupart des syste\*`mes (si ce n'est tous)
imple\*'mentent toutefois \fIlockf\fR\|(3) en termes de verrous \fIfcntl\fR\|(2), la diffe\*'rence
de se\*'mantiques ne devrait dont pas ge\*^ner trop de monde.
.Sp
Notez que l'e\*'mulation de \fIflock\fR\|(3) via \fIfcntl\fR\|(2) implique que \s-1DESCRIPTEUR\s0 soit
ouvert en lecture pour l'utilisation de \s-1LOCK_SH\s0 et en e\*'criture pour
l'utilisation de \s-1LOCK_EX\s0.
.Sp
Notez aussi que certaines versions de \f(CW\*(C`flock()\*(C'\fR ne peuvent pas verrouiller
des choses a\*` travers le re\*'seau, vous devriez utilisez des appels a\*` \f(CW\*(C`fcntl()\*(C'\fR
plus spe\*'cifiques au syste\*`me dans ce but. Si vous le souhaitez, vous pouvez
contraindre Perl a\*` ignorer la fonction \fIflock\fR\|(2) de votre syste\*`me et lui
fournir ainsi sa propre e\*'mulation base\*'e sur \fIfcntl\fR\|(2), en passant le flag
\&\f(CW\*(C`\-Ud_flock\*(C'\fR au programme \fIConfigure\fR lors de la configuration de perl.
.Sp
Voici un empilage de mails pour les syste\*`mes \s-1BSD\s0.
.Sp
.Vb 1
\&    use Fcntl ':flock'; # import des constantes LOCK_*
\&
\&    sub lock {
\&        flock(MBOX,LOCK_EX);
\&        # et, si quelqu'un ajoute
\&        # pendant notre attente...
\&        seek(MBOX, 0, 2);
\&    }
\&
\&    sub unlock {
\&        flock(MBOX,LOCK_UN);
\&    }
\&
\&    open(MBOX, ">>/usr/spool/mail/$ENV{'USER'}")
\&            or die "Can't open mailbox: $!";
\&
\&    lock();
\&    print MBOX $msg,"\en\en";
\&    unlock();
.Ve
.Sp
Sur les syste\*`mes qui posse\*`dent un vrai \fIflock()\fR, les verrous sont he\*'rite\*'s a\*`
travers les appels a\*` \fIfork()\fR alors que ceux qui s'appuient sur la fonction
\&\fIfcntl()\fR plus capricieuse perdent les verrous, rendant ainsi l'e\*'criture de
serveur plus difficile.
.Sp
Voir aussi DB_File pour d'autres exemples avec \fIflock()\fR.
.IP "fork" 8
.IX Item "fork"
Effectue un appel syste\*`me \fIfork\fR\|(2) pour cre\*'er un nouveau processus exe\*'cutant le
me\*^me programme au me\*^me point. Retourne l'identifiant (pid) de l'enfant au
processus pe\*`re, \f(CW0\fR au processus fils ou \f(CW\*(C`undef\*(C'\fR en cas d'e\*'chec. Les
descripteurs de fichiers (et parfois les verrous pose\*'s sur ces descripteurs)
sont partage\*'s sinon tout le reste est recopie\*'. Sur la plupart des syste\*`mes qui
supportent l'appel syste\*`me \fIfork()\fR, une grande attention a e\*'te\*' porte\*'e pour
qu'il soit extre\*^mement efficient (par exemple en utilisant la me\*'thode de
copie\-a\*`\-l\-e\*'criture sur les pages me\*'moires contenant des donne\*'es). C'est donc
la paradigme dominant pour la gestion du multi\-ta\*^ches durant les dernie\*`res
de\*'cennies.
.Sp
Depuis la version v5.6.0, Perl tente de vider les tampons de tous les fichiers
ouverts en e\*'criture avant d'effectuer le \fIfork()\fR mais cela n'est pas supporte\*'
sur toutes les plates-formes (voir perlport). Pour e\*^tre plus su\*^r, vous
devriez positionner la variable \f(CW$|\fR ($AUTOFLUSH en anglais) ou appeler la
me\*'thode \f(CW\*(C`autoflush()\*(C'\fR des objets \f(CW\*(C`IO::Handle\*(C'\fR pour chacun des descripteurs
ouverts afin d'e\*'viter toute duplication de donne\*'es.
.Sp
Si vous dupliquez avec \f(CW\*(C`fork()\*(C'\fR sans attendre votre fils, vous allez
accumuler des zombis. Sur certains syste\*`mes, vous pouvez e\*'viter cela en
positionnant \f(CW$SIG{CHLD}\fR a\*` \f(CW"IGNORE"\fR. Voir aussi perlipc pour des
exemples d'utilisation de \fIfork()\fR et de suppression d'enfants moribonds.
.Sp
Notez que si votre fils duplique\*' he\*'rite de descripteurs de fichier syste\*`mes,
tels que \s-1STDIN\s0 et \s-1STDOUT\s0, qui sont en fait connecte\*'s par un tube ou une
socket, me\*^me si vous sortez du programme, alors le serveur distant (disons
tels que httpd ou rsh) ne saura pas que vous avez termine\*'. Vous devriez les
re\*'ouvrir vers \fI/dev/null\fR en cas de proble\*`me.
.IP "format" 8
.IX Item "format"
De\*'clare un format visuel utilisable par la fonction \f(CW\*(C`write()\*(C'\fR. Par
exemple\ :
.Sp
.Vb 4
\&    format Something =
\&        Test: @<<<<<<<< @||||| @>>>>>
\&              $str,     $%,    '$' . int($num)
\&    .
\&
\&    $str = "widget";
\&    $num = $cost/$quantity;
\&    $~ = 'Something';
\&    write;
.Ve
.Sp
Voir perlform pour de nombreux de\*'tails et exemples.
.IP "formline \s-1IMAGE\s0,LISTE" 8
.IX Item "formline IMAGE,LISTE"
C'est une fonction interne utilise\*'e par les formats (\f(CW\*(C`format\*(C'\fR), bien que
vous puissiez aussi l'appeler. Elle formate (voir perlform) une liste de
valeurs selon le contenu de \s-1IMAGE\s0, plac\*,ant la sortie dans l'accumulateur du
format de sortie \f(CW$^A\fR (ou \f(CW$ACCUMULATOR\fR en anglais). Finalement, lorsqu'un
\&\f(CW\*(C`write()\*(C'\fR est effectue\*', le contenu de \f(CW$^A\fR est e\*'crit dans un descripteur de
fichier, mais vous pouvez aussi lire \f(CW$^A\fR vous\-me\*^me et re\*'assigner \f(CW""\fR a\*`
\&\f(CW$^A\fR. Notez qu'un format typique appelle \f(CW\*(C`formline\*(C'\fR une fois par ligne du
formulaire mais la fonction \f(CW\*(C`formline\*(C'\fR elle\-me\*^me ne se pre\*'occupe pas du
nombre de passage a\*` la ligne inclus dans l'\s-1IMAGE\s0. Ceci signifie que \f(CW\*(C`~\*(C'\fR et
\&\f(CW\*(C`~~\*(C'\fR traiteront l'\s-1IMAGE\s0 comple\*`te comme une seule ligne. Vous pouvez donc
utiliser de multiples formline pour imple\*'menter un seul format
d'enregistrement, tout comme le compilateur de format.
.Sp
Faites attention si vous utilisez des guillemets autour de l'image, car un
caracte\*`re "\f(CW\*(C`@\*(C'\fR" pourrait e\*^tre pris pour le de\*'but d'un nom de
tableau. \f(CW\*(C`formline()\*(C'\fR retourne toujours \s-1VRAI\s0. Cf. perlform pour d'autres
exemples.
.IP "getc \s-1DESCRIPTEUR\s0" 8
.IX Item "getc DESCRIPTEUR"
.PD 0
.IP "getc" 8
.IX Item "getc"
.PD
Retourne le prochain caracte\*`re du fichier d'entre\*'e attache\*' au \s-1DESCRIPTEUR\s0 ou
la valeur inde\*'finie (undef) a\*` la fin du fichier ou en cas d'e\*'chec. Si le
\&\s-1DESCRIPTEUR\s0 est omis, utilise \s-1STDIN\s0. Ce n'est pas particulie\*`rement
efficace. De plus, ce n'est pas utilisable tel quel pour obtenir des
caracte\*`res sans que l'utilisateur presse \s-1ENTER\s0. Pour c\*,a, essayez quelque chose
comme\ :
.Sp
.Vb 6
\&    if ($BSD_STYLE) {
\&        system "stty cbreak </dev/tty >/dev/tty 2>&1";
\&    }
\&    else {
\&        system "stty", '\-icanon', 'eol', "\e001";
\&    }
\&
\&    $key = getc(STDIN);
\&
\&    if ($BSD_STYLE) {
\&        system "stty \-cbreak </dev/tty >/dev/tty 2>&1";
\&    }
\&    else {
\&        system "stty", 'icanon', 'eol', '^@'; # ASCII null
\&    }
\&    print "\en";
.Ve
.Sp
De\*'terminer la valeur de \f(CW$BSD_STYLE\fR est laisse\*' en exercice au lecteur.
.Sp
La fonction \f(CW\*(C`POSIX::getattr()\*(C'\fR peut faire ceci de fac\*,on plus portable sur des
syste\*`mes compatibles \s-1POSIX\s0. Voir aussi le module \f(CW\*(C`Term::ReadKey\*(C'\fR de votre
site \s-1CPAN\s0 le plus proche. Les de\*'tails sur \s-1CPAN\s0 peuvent e\*^tre trouve\*'s dans
\&\*(L"\s-1CPAN\s0\*(R" in perlmodlib.
.IP "getlogin" 8
.IX Item "getlogin"
Imple\*'mente la fonction de la bibliothe\*`que C portant le me\*^me nom et qui, sur la
plupart des syste\*`mes, retourne le login courant a\*` partir de \fI/etc/utmp\fR, si
il existe. Si l'appel retourne null, utilisez \f(CW\*(C`getpwuid()\*(C'\fR.
.Sp
.Vb 1
\&    $login = getlogin || getpwuid($<) || "Kilroy";
.Ve
.Sp
N'utilisez pas \f(CW\*(C`getlogin()\*(C'\fR pour de l'authentification\ : ce n'est pas aussi
su\*^r que \f(CW\*(C`getpwuid()\*(C'\fR.
.IP "getpeername \s-1SOCKET\s0" 8
.IX Item "getpeername SOCKET"
Renvoie l'adresse sockaddr compacte\*'e (voir \fIpack()\fR) de l'autre extre\*'mite\*' de la
connexion \s-1SOCKET\s0.
.Sp
.Vb 5
\&    use Socket;
\&    $hersockaddr    = getpeername(SOCK);
\&    ($port, $iaddr) = unpack_sockaddr_in($hersockaddr);
\&    $herhostname    = gethostbyaddr($iaddr, AF_INET);
\&    $herstraddr     = inet_ntoa($iaddr);
.Ve
.IP "getpgrp \s-1PID\s0" 8
.IX Item "getpgrp PID"
Renvoie le groupe courant du processus dont on fournit le \s-1PID\s0. Utilisez le \s-1PID\s0
\&\f(CW0\fR pour obtenir le groupe courant du processus courant. Cela engendra une
exception si on l'utilise sur une machine qui n'imple\*'mente pas \fIgetpgrp\fR\|(2). Si
\&\s-1PID\s0 est omis, renvoie le groupe du processus courant. Remarquez que la version
\&\s-1POSIX\s0 de \f(CW\*(C`getpgrp()\*(C'\fR ne prend pas d'argument \s-1PID\s0 donc seul \f(CW\*(C`PID==0\*(C'\fR est
re\*'ellement portable.
.IP "getppid" 8
.IX Item "getppid"
Renvoie l'id du processus parent.
.IP "getpriority \s-1WHICH\s0,WHO" 8
.IX Item "getpriority WHICH,WHO"
Renvoie la priorite\*' courant d'un processus, d'un groupe ou d'un
utilisateur. (Voir \fIgetpriority\fR\|(2).) Cela engendra une exception si on
l'utilise sur une machine qui n'imple\*'mente pas \fIgetpriority\fR\|(2).
.IP "getpwnam \s-1NAME\s0" 8
.IX Item "getpwnam NAME"
.PD 0
.IP "getgrnam \s-1NAME\s0" 8
.IX Item "getgrnam NAME"
.IP "gethostbyname \s-1NAME\s0" 8
.IX Item "gethostbyname NAME"
.IP "getnetbyname \s-1NAME\s0" 8
.IX Item "getnetbyname NAME"
.IP "getprotobyname \s-1NAME\s0" 8
.IX Item "getprotobyname NAME"
.IP "getpwuid \s-1UID\s0" 8
.IX Item "getpwuid UID"
.IP "getgrgid \s-1GID\s0" 8
.IX Item "getgrgid GID"
.IP "getservbyname \s-1NAME\s0,PROTO" 8
.IX Item "getservbyname NAME,PROTO"
.IP "gethostbyaddr \s-1ADDR\s0,ADDRTYPE" 8
.IX Item "gethostbyaddr ADDR,ADDRTYPE"
.IP "getnetbyaddr \s-1ADDR\s0,ADDRTYPE" 8
.IX Item "getnetbyaddr ADDR,ADDRTYPE"
.IP "getprotobynumber \s-1NUMBER\s0" 8
.IX Item "getprotobynumber NUMBER"
.IP "getservbyport \s-1PORT\s0,PROTO" 8
.IX Item "getservbyport PORT,PROTO"
.IP "getpwent" 8
.IX Item "getpwent"
.IP "getgrent" 8
.IX Item "getgrent"
.IP "gethostent" 8
.IX Item "gethostent"
.IP "getnetent" 8
.IX Item "getnetent"
.IP "getprotoent" 8
.IX Item "getprotoent"
.IP "getservent" 8
.IX Item "getservent"
.IP "setpwent" 8
.IX Item "setpwent"
.IP "setgrent" 8
.IX Item "setgrent"
.IP "sethostent \s-1STAYOPEN\s0" 8
.IX Item "sethostent STAYOPEN"
.IP "setnetent \s-1STAYOPEN\s0" 8
.IX Item "setnetent STAYOPEN"
.IP "setprotoent \s-1STAYOPEN\s0" 8
.IX Item "setprotoent STAYOPEN"
.IP "setservent \s-1STAYOPEN\s0" 8
.IX Item "setservent STAYOPEN"
.IP "endpwent" 8
.IX Item "endpwent"
.IP "endgrent" 8
.IX Item "endgrent"
.IP "endhostent" 8
.IX Item "endhostent"
.IP "endnetent" 8
.IX Item "endnetent"
.IP "endprotoent" 8
.IX Item "endprotoent"
.IP "endservent" 8
.IX Item "endservent"
.PD
Ces routines re\*'alisent exactement les me\*^mes fonctions que leurs homologues de
la bibliothe\*`que syste\*`me. Dans un contexte de liste, les valeurs retourne\*'es par
les diffe\*'rentes routines sont les suivantes\ :
.Sp
.Vb 7
\&    ($name,$passwd,$uid,$gid,
\&       $quota,$comment,$gcos,$dir,$shell,$expire) = getpw*
\&    ($name,$passwd,$gid,$members) = getgr*
\&    ($name,$aliases,$addrtype,$length,@addrs) = gethost*
\&    ($name,$aliases,$addrtype,$net) = getnet*
\&    ($name,$aliases,$proto) = getproto*
\&    ($name,$aliases,$port,$proto) = getserv*
.Ve
.Sp
(Si une entre\*'e n'existe pas, vous re\*'cupe\*'rerez une liste vide.)
.Sp
La signification exacte du champ \f(CW$gcos\fR varie mais contient habituellement le
nom re\*'el de l'utilisateur (au contraire du nom de login) et d'autres
informations pertinentes pour cet utilisateur. Par contre, sachez que sur de
nombreux syste\*`mes, les utilisateurs peuvent changer eux\-me\*^mes ces
informations. Ce n'est donc pas une information de confiance. Par conse\*'quent
\&\f(CW$gcos\fR est souille\*'e (voir perlsec). Les champs \f(CW$passwd\fR, \f(CW$shell\fR ainsi que
l'interpre\*'teur de commandes (login shell) et le mot de passe crypte\*' sont aussi
souille\*'s pour les me\*^mes raisons.
.Sp
Dans un contexte scalaire, vous obtenez le nom sauf lorsque la fonction fait
une recherche par nom auquel cas vous re\*'cupe\*'rerez autre chose. (Si une
entre\*'e n'existe pas vous re\*'cupe\*'rerez la valeur undef.) Par exemple\ :
.Sp
.Vb 7
\&    $uid   = getpwnam($name);
\&    $name  = getpwuid($num);
\&    $name  = getpwent();
\&    $gid   = getgrnam($name);
\&    $name  = getgrgid($num;
\&    $name  = getgrent();
\&    #etc.
.Ve
.Sp
Dans \fIgetpw*()\fR, les champs \f(CW$quota\fR, \f(CW$comment\fR et \f(CW$expire\fR sont des cas
spe\*'ciaux dans le sens ou\*` ils ne sont pas supporte\*'s sur de nombreux
syste\*`mes. Si \f(CW$quota\fR n'est pas supporte\*', c'est un scalaire vide. Si il est
supporte\*', c'est habituellement le quota disque. Si le champ \f(CW$comment\fR n'est
pas supporte\*', c'est un scalaire vide. Si il est supporte\*', c'est habituellement
le commentaire X\ administratif\ X associe\*' a\*` l'utilisateur. Sur certains
syste\*`mes, le champ \f(CW$quota\fR peut e\*^tre \f(CW$change\fR ou \f(CW$age\fR, des champs qui
sont en rapport avec le vieillissement du mot de passe. Sur certains syste\*`mes,
le champ \f(CW$comment\fR peut e\*^tre \f(CW$class\fR. Le champ \f(CW$expire\fR, s'il est
pre\*'sent, exprime la pe\*'riode d'expiration du compte ou du mot de passe. Pour
connai\*^tre la disponibilite\*' et le sens exact de tous ces champs sur votre
syste\*`me, consultez votre documentation de \fIgetpwnam\fR\|(3) et le fichier
\&\fIpwd.h\fR. A\*` partir de Perl, vous pouvez trouver le sens de vos champs
\&\f(CW$quota\fR et \f(CW$comment\fR et savoir si vous avez le champ \f(CW$expire\fR en
utilisant le module \f(CW\*(C`Config\*(C'\fR pour lire les valeurs de \f(CW\*(C`d_pwquota\*(C'\fR,
\&\f(CW\*(C`d_pwage\*(C'\fR, \f(CW\*(C`d_pwchange\*(C'\fR, \f(CW\*(C`d_pwcomment\*(C'\fR et \f(CW\*(C`d_pwexpire\*(C'\fR. Les fichiers de
mots de passe cache\*'s (shadow password) ne sont supporte\*'s que si
l'imple\*'mentation de votre syste\*`me est faite telle que les appels aux fonctions
normales de la bibliothe\*`que C acce\*`dent a\*` ces fichiers lorsque vos privile\*`ges
vous y autorisent. Toute autre imple\*'mentation incorrecte via des appels a\*` une
bibliothe\*`que se\*'pare\*'e n'est pas supporte\*'e.
.Sp
La valeur \f(CW$members\fR renvoye\*'e par les fonctions \fIgetgr*()\fR est la liste des
noms de login des membres du groupe se\*'pare\*'s par des espaces.
.Sp
Pour les fonctions \fIgethost*()\fR, si la variable \f(CW\*(C`h_errno\*(C'\fR est supporte\*'e en
C, sa valeur sera retourne\*'e via \f(CW$?\fR si l'appel a\*` la fonction e\*'choue. La
valeur de \f(CW@addrs\fR qui est retourne\*'e en cas de succe\*`s est une liste
d'adresses a\*` plat telle que retourne\*'e par l'appel syste\*`me correspondant. Dans
le domaine Internet, chaque adresse fait quatre octets de long et vous pouvez
la de\*'compacter en disant quelque chose comme :
.Sp
.Vb 1
\&    ($a,$b,$c,$d) = unpack('C4',$addr[0]);
.Ve
.Sp
Si vous e\*^tes fatigue\*' de devoir vous souvenir que tel e\*'le\*'ment de la liste
retourne\*'e correspond a\*` telle valeur, des interfaces par nom sont fournies par
les modules \f(CW\*(C`File::stat\*(C'\fR, \f(CW\*(C`Net::hostent\*(C'\fR, \f(CW\*(C`Net::netent\*(C'\fR, \f(CW\*(C`Net::protoent\*(C'\fR,
\&\f(CW\*(C`Net::servent\*(C'\fR, \f(CW\*(C`Time::gmtime\*(C'\fR, \f(CW\*(C`Time::localtime\*(C'\fR et \f(CW\*(C`User::grent\*(C'\fR. Ils
remplacent les appels internes normaux par des versions qui renvoient des
objets ayant le nom approprie\*' pour chaque champ. Par exemple\ :
.Sp
.Vb 3
\&   use File::stat;
\&   use User::pwent;
\&   $is_his = (stat($filename)\->uid == pwent($whoever)\->uid);
.Ve
.Sp
Bien que les deux appels se ressemblent (appel a\*` la me\*'thode 'uid'), ce n'est
pas la me\*^me chose car l'objet \f(CW\*(C`File::stat\*(C'\fR est diffe\*'rent de l'objet
\&\f(CW\*(C`User::pwent\*(C'\fR.
.IP "getsockname \s-1SOCKET\s0" 8
.IX Item "getsockname SOCKET"
Renvoie l'adresse sockaddr compacte\*'e de cette extre\*'mite\*' de la connexion \s-1SOCKET\s0
si vous ne connaissez pas cette adresse car vous avez diffe\*'rentes adresses \s-1IP\s0
utilisables pour e\*'tablir cette connexion.
.Sp
.Vb 6
\&    use Socket;
\&    $mysockaddr = getsockname(SOCK);
\&    ($port, $myaddr) = sockaddr_in($mysockaddr);
\&    printf "Connect to %s [%s]\en", 
\&       scalar gethostbyaddr($myaddr, AF_INET),
\&       inet_ntoa($myaddr);
.Ve
.IP "getsockopt \s-1SOCKET\s0,LEVEL,OPTNAME" 8
.IX Item "getsockopt SOCKET,LEVEL,OPTNAME"
Renvoie l'option demande\*'e de \s-1SOCKET\s0 ou undef en cas d'erreur.
.IP "glob \s-1EXPR\s0" 8
.IX Item "glob EXPR"
.PD 0
.IP "glob" 8
.IX Item "glob"
.PD
Dans un contexte de liste, retourne la liste (e\*'ventuellement vide) des
fichiers correspondants a\*` l'expansion de la valeur de \s-1EXPR\s0 telle que le shell
standard Unix \fI/bin/csh\fR la ferait. Dans un contexte scalaire, glob produit
les e\*'le\*'ments de cette liste un par un jusqu'a\*` l'e\*'puiser puis il retourne
undef. C'est la fonction interne qui imple\*'mente l'ope\*'rateur \f(CW\*(C`<*.c>\*(C'\fR mais
vous pouvez l'utiliser directement. Si \s-1EXPR\s0 est omis, \f(CW$_\fR est utilise\*' a\*` la
place. L'ope\*'rateur \f(CW\*(C`<*.c>\*(C'\fR est pre\*'sente\*' plus en de\*'tail dans \*(L"Les
ope\*'rateurs d'E/S\*(R" in perlop.
.Sp
Depuis la version v5.6.0, cet ope\*'rateur est imple\*'mente\*' via l'extension
standard \f(CW\*(C`File::Glob\*(C'\fR. Voir File::Glob pour plus de de\*'tails.
.IP "gmtime \s-1EXPR\s0" 8
.IX Item "gmtime EXPR"
Convertit une date telle que celle retourne\*'e par la fonction time en un
tableau de 9 e\*'le\*'ments avec la date lie\*'e au fuseau horaire du me\*'ridien de
Greenwich standard. On l'utilise typiquement de la manie\*`re suivante\ :
.Sp
.Vb 3
\&    #  0    1    2      3      4      5      6      7      8
\&    ($sec,$min,$heure,$mjour,$mois,$annee,$sjour,$ajour,$isdst) =
\&                                            gmtime(time);
.Ve
.Sp
Tous les e\*'le\*'ments du tableau sont nume\*'riques et restent tels qu'ils
apparaissent dans la structure 'struct tm'. \f(CW$sec\fR, \f(CW$min\fR et \f(CW$heure\fR sont
les secondes, les minutes et l'heure de l'instant spe\*'cifie\*'. \f(CW$mjour\fR est le
quantie\*`me du mois et \f(CW$mois\fR est le mois lui\-me\*^me, dans l'intervalle \f(CW0..11\fR
avec 0 pour janvier et 11 pour de\*'cembre. \f(CW$annee\fR est le nombre d'anne\*'es
depuis 1900 et donc \f(CW$annee\fR vaut \f(CW123\fR en l'an 2023. \f(CW$sjour\fR est le jour
de la semaine avec 0 pour le dimanche et 3 pour le mercredi. \f(CW$ajour\fR est le
jour de l'anne\*'e dans l'intervalle \f(CW1..365\fR (ou \f(CW1..366\fR pour les anne\*'es
bissextiles.) \f(CW$isdst\fR est vrai si l'heure d'e\*'te\*' est en cours a\*` la date
spe\*'cifie\*'e et faux sinon.
.Sp
Remarquez bien que \f(CW$annee\fR n'est pas que les deux derniers chiffres de
l'anne\*'e. Si vous supposez cela, vous cre\*'ez des programmes non compatible an
2000 \*(-- et vous ne voulez pas faire cela, n'est\-ce pas\ ?
.Sp
La bonne me\*'thode pour obtenir une anne\*'e comple\*`te sur 4 chiffres est tout
simplement\ :
.Sp
.Vb 1
\&        $annee += 1900;
.Ve
.Sp
Et pour obtenir les deux derniers chiffres de l'anne\*'e (e.g. '01' en 2001):
.Sp
.Vb 1
\&        $annee = sprintf("%02d", $annee % 100);
.Ve
.Sp
Si \s-1EXPR\s0 est omis, calcule \f(CW\*(C`gmtime(time)\*(C'\fR.
.Sp
Dans un contexte scalaire, retourne la valeur de \fIctime\fR\|(3) :
.Sp
.Vb 1
\&    $now_string = gmtime;  # e.g., "Thu Oct 13 04:54:34 1994"
.Ve
.Sp
Voir aussi la fonction \f(CW\*(C`timegm()\*(C'\fR fournit par le module \f(CW\*(C`Time::Local\*(C'\fR et la
fonction \fIstrftime\fR\|(3) disponible via le module \s-1POSIX\s0.
.Sp
La valeur scalaire n'est \fBpas\fR de\*'pendante du locale, voir perllocale, mais
est construite en interne par Perl. Voir aussi le module \f(CW\*(C`Time::Local\*(C'\fR et les
fonctions \fIstrftime\fR\|(3) et \fImktime\fR\|(3) du module \s-1POSIX\s0. Pour obtenir quelque chose
de similaire mais dont les chai\*^nes de caracte\*`res des dates de\*'pendent du
locale, parame\*'trez vos variables d'environnement lie\*'es au locale (voir
perllocale) et essayez par exemple\ :
.Sp
.Vb 2
\&    use POSIX qw(strftime);
\&    $now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;
.Ve
.Sp
Notez que les se\*'quences \f(CW%a\fR et \f(CW%b\fR qui sont les formes courtes du jour de
la semaine et du mois de l'anne\*'e, n'ont pas obligatoirement 3 caracte\*`res de
long dans tous les locale.
.IP "goto \s-1LABEL\s0" 8
.IX Item "goto LABEL"
.PD 0
.IP "goto \s-1EXPR\s0" 8
.IX Item "goto EXPR"
.IP "goto &NAME" 8
.IX Item "goto &NAME"
.PD
La forme \f(CW\*(C`goto\-LABEL\*(C'\fR trouve la ligne e\*'tiquete\*'e par \s-1LABEL\s0 et continue
l'exe\*'cution a\*` cette ligne. On ne peut pas l'utiliser pour sauter a\*` l'inte\*'rieur
d'une construction qui ne\*'cessite une initialisation telle qu'une subroutine ou
une boucle \f(CW\*(C`foreach\*(C'\fR. On ne peut pas non plus l'utiliser pour aller dans une
construction qui peut e\*^tre optimise\*'e ou pour sortir d'un bloc ou d'une
subroutine donne\*' a\*` \f(CW\*(C`sort()\*(C'\fR. On peut par contre l'utiliser pour aller
n'importe ou\*` dans la porte\*'e actuelle, me\*^me pour sortir des subroutines, bien
qu'il soit meilleur d'utiliser pour cela d'autres constructions telles que
\&\f(CW\*(C`last\*(C'\fR ou \f(CW\*(C`die()\*(C'\fR. L'auteur de Perl n'a jamais ressenti le besoin d'utiliser
cette forme de \f(CW\*(C`goto\*(C'\fR (en Perl bien su\*^r \*(-- en C, c'est une autre histoire).
(La diffe\*'rence avec le C provient du fait que le C n'offre pas le nommage des
boucles couple\*'e aux instructions de contro\*^le de boucles. Cette possibilite\*' de
Perl remplace la quasi totalite\*' des usages structure\*'s du \f(CW\*(C`goto\*(C'\fR dans d'autres
langages.)
.Sp
La forme \f(CW\*(C`goto\-EXPR\*(C'\fR attend un nom d'e\*'tiquette dont la porte\*'e sera re\*'solue
dynamiquement. Cela autorise les \f(CW\*(C`goto\*(C'\fR calcule\*'s a\*` la \s-1FORTRAN\s0 mais ce n'est
pas vraiment recommande\*' si vous vous souciez de la maintenance.
.Sp
.Vb 1
\&    goto ("FOO", "BAR", "GLARCH")[$i];
.Ve
.Sp
La forme \f(CW\*(C`goto\-&NAME\*(C'\fR est vraiment diffe\*'rente des autres formes de
\&\f(CW\*(C`goto\*(C'\fR. En fait, ce n'est pas du tout un goto et il n'a donc pas les
stigmates habituellement associe\*'s aux autres goto. Cette forme substitue
l'appel de la subroutine en cours d'exe\*'cution (en oubliant toutes les
modifications faites par des appels a\*` \fIlocal()\fR) par un appel a\*` la subroutine
donne\*'e en argument. C'est utilise\*' par les routines \f(CW\*(C`AUTOLOAD\*(C'\fR qui de\*'sirent
charger une autre subroutine puis tout faire comme si c'e\*'tait cette autre
subroutine qui avait re\*'ellement e\*'te\*' appele\*'e (sauf que toutes les modifications
faites a\*` \f(CW@_\fR dans la subroutine courante sont propage\*'es a\*` l'autre
subroutine). Apre\*`s le \f(CW\*(C`goto\*(C'\fR, pas me\*^me \f(CW\*(C`caller()\*(C'\fR n'est capable de
s'apercevoir que la subroutine initiale a e\*'te\*' appele\*'e au pre\*'alable.
.Sp
\&\s-1NAME\s0 n'est pas ne\*'cessairement le nom d'une subroutine\ ; cela peut e\*^tre une
variable scalaire contenant une re\*'fe\*'rence a\*` du code ou un bloc dont
l'e\*'valuation produit une re\*'fe\*'rence a\*` du code.
.IP "grep \s-1BLOC\s0 \s-1LISTE\s0" 8
.IX Item "grep BLOC LISTE"
.PD 0
.IP "grep \s-1EXPR\s0,LISTE" 8
.IX Item "grep EXPR,LISTE"
.PD
Cette fonction est similaire dans l'esprit mais pas identique a\*` \fIgrep\fR\|(1) et
tous ses de\*'rive\*'s. En particulier, elle n'est pas limite\*'e a\*` l'utilisation
d'expressions rationnelles.
.Sp
Elle e\*'value le bloc \s-1BLOC\s0 ou l'expression \s-1EXPR\s0 pour chaque e\*'le\*'ment de \s-1LISTE\s0
(qui est localement lie\*' a\*` \f(CW$_\fR) et retourne la liste des valeurs constitue\*'e
des e\*'le\*'ments pour lesquels l'expression est e\*'value\*'e a\*` true (vrai). Dans un
contexte scalaire, retourne le nombre de fois ou\*` l'expression est vraie
(true).
.Sp
.Vb 1
\&    @foo = grep(!/^#/, @bar);    # supprime les commentaires
.Ve
.Sp
ou de manie\*`re e\*'quivalente\ :
.Sp
.Vb 1
\&    @foo = grep {!/^#/} @bar;    # supprime les commentaires
.Ve
.Sp
Remarquez que, puisque \f(CW$_\fR est un re\*'fe\*'rence dans la liste de valeurs, il
peut e\*^tre utilise\*' pour modifier les e\*'le\*'ments du tableau. Bien que ce soit
supporte\*' et parfois pratique, cela peut aboutir a\*` des re\*'sultats bizarres si
\&\s-1LISTE\s0 n'est pas un tableau nomme\*'. De manie\*`re similaire, grep renvoie des alias
de la liste originale exactement comme le fait une variable de boucle for. Et
donc, modifier un e\*'le\*'ment d'une liste retourne\*'e par grep (par exemple dans un
\&\f(CW\*(C`foreach\*(C'\fR, un \f(CW\*(C`map()\*(C'\fR ou un autre \f(CW\*(C`grep()\*(C'\fR) modifie re\*'ellement l'e\*'le\*'ment de
la liste originale.
.Sp
Voir aussi \*(L"map\*(R" pour obtenir un tableau compose\*' des re\*'sultats de \s-1BLOC\s0 ou
\&\s-1EXPR\s0.
.IP "hex \s-1EXPR\s0" 8
.IX Item "hex EXPR"
.PD 0
.IP "hex" 8
.IX Item "hex"
.PD
Interpre\*`te \s-1EXPR\s0 comme une chai\*^ne hexade\*'cimale et retourne la valeur
correspondante. (Pour convertir des chai\*^nes qui commencent soit par 0 soit par
0x voir \*(L"oct\*(R".) Si \s-1EXPR\s0 est omis, c'est \f(CW$_\fR qui est utilise\*'.
.Sp
.Vb 2
\&    print hex '0xAf'; # affiche '175'
\&    print hex 'aF';   # idem
.Ve
.Sp
Les chai\*^nes hexade\*'cimales ne peuvent repre\*'senter que des entiers. Les chai\*^nes
qui provoquent un de\*'passement de la capacite\*' des entiers de\*'clenchent un
avertissement. Au contraire de \fIoct()\fR, les espaces initiaux ne sont pas ignore\*'s.
.IP "import" 8
.IX Item "import"
Il n'existe pas de fonction interne \f(CW\*(C`import()\*(C'\fR. C'est juste une me\*'thode
ordinaire (une subroutine) de\*'finie (ou he\*'rite\*'e) par les modules qui veulent
exporter des noms vers d'autres modules. La fonction \f(CW\*(C`use()\*(C'\fR appelle la
me\*'thode \f(CW\*(C`import()\*(C'\fR du paquetage utilise\*'. Voir aussi \*(L"\fIuse()\fR\*(R", perlmod et
Exporter.
.IP "index \s-1CHAINE\s0,SUBSTR,POSITION" 8
.IX Item "index CHAINE,SUBSTR,POSITION"
.PD 0
.IP "index \s-1CHAINE\s0,SUBSTR" 8
.IX Item "index CHAINE,SUBSTR"
.PD
La fonction \fIindex()\fR recherche une chai\*^ne dans une autre mais sans les
fonctionnalite\*'s ge\*'ne\*'riques de reconnaissance de motifs des expressions
rationnelles. Retourne la position de la premie\*`re occurrence du \s-1SUBSTR\s0 dans
\&\s-1CHAINE\s0 a\*` partir de \s-1POSITION\s0 inclus. Si \s-1POSITION\s0 est omis, le recherche
commence au de\*'but de la chai\*^ne. La valeur retourne\*'e est relative a\*` \f(CW0\fR (ou a\*`
la valeur que vous avez affecte\*'e a\*` la variable \f(CW$[\fR \*(-- mais ce n'est pas a\*`
faire). Si la sous\-chai\*^ne \s-1SUBSTR\s0 n'est pas trouve\*'e, la valeur retourne\*'e est la
valeur de re\*'fe\*'rence moins 1 (habituellement \f(CW\*(C`\-1\*(C'\fR).
.IP "int \s-1EXPR\s0" 8
.IX Item "int EXPR"
.PD 0
.IP "int" 8
.IX Item "int"
.PD
Retourne la partie entie\*`re de \s-1EXPR\s0. Si \s-1EXPR\s0 est omis, c'est \f(CW$_\fR qui est
utilise\*'. Vous ne devriez pas utiliser cette fonction pour faire des arrondis
parce qu'elle tronque la valeur vers \f(CW0\fR et parce que la repre\*'sentation
interne des nombre en virgule flottante produit parfois des re\*'sultats
contre\-intuitifs. Par exemple \f(CW\*(C`int(\-6.725/0.025)\*(C'\fR produit \-268 au lieu de
\&\-269\ ; C'est du\*^ aux erreurs de calcul qui donne un re\*'sultat comme
\&\-268.99999999999994315658. Habituellement \f(CW\*(C`sprintf()\*(C'\fR et \f(CW\*(C`printf()\*(C'\fR ou les
fonctions \f(CW\*(C`POSIX::floor\*(C'\fR et \f(CW\*(C`POSIX::ceil\*(C'\fR vous seront plus utiles que \fIint()\fR.
.IP "ioctl \s-1DESCRIPTEUR\s0,FONCTION,SCALAIRE" 8
.IX Item "ioctl DESCRIPTEUR,FONCTION,SCALAIRE"
Imple\*'mente la fonction \fIioctl\fR\|(2). Vous aurez probablement a\*` dire\ :
.Sp
.Vb 1
\&    require "ioctl.ph"; # probablement dans /usr/local/lib/perl/ioctl.ph
.Ve
.Sp
en premier lieu pour obtenir les de\*'finitions correctes des fonctions. Si
\&\fIioctl.ph\fR n'existe pas ou ne donne pas les de\*'finitions correctes, vous
devrez les fournir vous\-me\*^me en vous basant sur les fichiers d'en\-te\*^te C tels
que \fI<sys/ioctl.h>\fR. (Il existe un script Perl appele\*' \fBh2ph\fR qui
vient avec le kit Perl et qui devrait vous aider a\*` faire cela mais il n'est
pas trivial.) \s-1SCALAIRE\s0 sera lu et/ou modifie\*' selon la fonction \s-1FONCTION\s0 \*(-- un
pointeur sur la valeur alphanume\*'rique de \s-1SCALAIRE\s0 est passe\*' comme troisie\*`me
argument du vrai appel syste\*`me \f(CW\*(C`ioctl()\*(C'\fR. (Si \s-1SCALAIRE\s0 n'a pas de valeur
alphanume\*'rique mais a une valeur nume\*'rique, c'est cette valeur qui sera passe\*'e
pluto\*^t que le pointeur sur la valeur alphanume\*'rique. Pour garantir que c'est
bien ce qui se passera, ajouter \f(CW0\fR au scalaire avant de l'utiliser.) Les
fonction \f(CW\*(C`pack()\*(C'\fR et \f(CW\*(C`unpack()\*(C'\fR permettent de manipuler les diffe\*'rentes
structures utilise\*'es par \f(CW\*(C`ioctl()\*(C'\fR.
.Sp
Les diffe\*'rentes valeurs retourne\*'es par \f(CW\*(C`ioctl\*(C'\fR (et \f(CW\*(C`fcntl\*(C'\fR) sont les
suivantes\ :
.Sp
.Vb 4
\&        si l'OS retourne :      alors Perl retournera :
\&            \-1               la valeur inde\*'finie (undef)
\&             0                  la chai\*^ne "0 but true"
\&        autre nombre                ce nombre
.Ve
.Sp
Ainsi Perl retourne vrai en cas de succe\*`s et faux en cas d'e\*'chec et vous
pouvez encore de\*'terminer la ve\*'ritable valeur retourne\*' par le syste\*`me
d'exploitation\ :
.Sp
.Vb 2
\&    $retval = ioctl(...) || \-1;
\&    printf "System returned %d\en", $retval;
.Ve
.Sp
La chai\*^ne spe\*'ciale "\f(CW0\fR but true" est traite\*'e par \fB\-w\fR comme une exception
qui ne de\*'clenche pas le message d'avertissement concernant les conversions
nume\*'riques incorrectes.
.Sp
Voici un exemple qui rend non bloquant au niveau syste\*`me le descripteur de
fichier \f(CW\*(C`REMOTE\*(C'\fR. En revanche, vous aurez a\*` ge\*'rer vous\-me\*^me le traitement de
\&\f(CW$|\fR.
.Sp
.Vb 1
\&    use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
\&
\&    $flags = fcntl(REMOTE, F_GETFL, 0)
\&                or die "Can't get flags for the socket: $!\en";
\&
\&    $flags = fcntl(REMOTE, F_SETFL, $flags | O_NONBLOCK)
\&                or die "Can't set flags for the socket: $!\en";
.Ve
.IP "join \s-1EXPR\s0,LISTE" 8
.IX Item "join EXPR,LISTE"
Concate\*`ne les diffe\*'rentes chai\*^nes de \s-1LISTE\s0 en une seule chai\*^ne ou\*` les champs
sont se\*'pare\*'s par la valeur de \s-1EXPR\s0 et retourne cette nouvelle
chai\*^ne. Exemple\ :
.Sp
.Vb 1
\&    $_ = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);
.Ve
.Sp
Au contraire de \f(CW\*(C`split\*(C'\fR, \f(CW\*(C`join\*(C'\fR ne prend pas un motif comme premier
argument. A\*` comparer a\*` \*(L"split\*(R".
.IP "keys \s-1HASH\s0" 8
.IX Item "keys HASH"
Retourne une liste constitue\*'e de toutes les cle\*'s (en anglais\ : keys) de la
table de hachage fournie. (Dans un contexte scalaire, retourne le nombre de
cle\*'s.) Les cle\*'s sont produites dans un ordre apparemment ale\*'atoire. Cet ordre
particulier pourrait changer dans une version future mais il est garanti que
ce sera toujours le me\*^me que celui produit par les fonctions \f(CW\*(C`values()\*(C'\fR ou
\&\f(CW\*(C`each()\*(C'\fR (en supposant que la table de hachage n'a pas e\*'te\*' modifie\*'e). Un
effet de bord est la re\*'initialisation de l'ite\*'rateur de \s-1HASH\s0.
.Sp
Voici encore une autre manie\*`re d'afficher votre environnement\ :
.Sp
.Vb 5
\&    @keys = keys %ENV;
\&    @values = values %ENV;
\&    while (@keys) {
\&        print pop(@keys), '=', pop(@values), "\en";
\&    }
.Ve
.Sp
et comment trier tout cela par ordre des cle\*'s :
.Sp
.Vb 3
\&    foreach $key (sort(keys %ENV)) {
\&        print $key, '=', $ENV{$key}, "\en";
\&    }
.Ve
.Sp
Pour trier une table de hachage par valeur, vous aurez a\*` utiliser la fonction
\&\f(CW\*(C`sort()\*(C'\fR. Voici le tri d'une table de hachage par ordre de\*'croissant de ses
valeurs\ :
.Sp
.Vb 3
\&    foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
\&        printf "%4d %s\en", $hash{$key}, $key;
\&    }
.Ve
.Sp
En tant que lvalue (valeur modifiable), \f(CW\*(C`keys()\*(C'\fR vous permet de d'augmenter
le nombre de re\*'ceptacles alloue\*'s pour la table de hachage concerne\*'e. Cela peut
ame\*'liorer les performances lorsque vous savez a\*` l'avance qu'une table va
grossir. (C'est tout a\*` fait similaire a\*` l'augmentation de taille d'un tableau
en affectant une grande valeur a\*` $#tableau.) Si vous dites\ :
.Sp
.Vb 1
\&    keys %hash = 200;
.Ve
.Sp
alors \f(CW%hash\fR aura au moins 200 re\*'ceptacles alloue\*'s \*(-- 256 en fait, puisque
la valeur est arrondie a\*` la puissance de deux imme\*'diatement supe\*'rieure. Ces
re\*'ceptacles seront conserve\*'s me\*^me si vous faites \f(CW\*(C`%hash = ()\*(C'\fR. Utilisez
\&\f(CW\*(C`undef %hash\*(C'\fR si vous voulez re\*'ellement libe\*'rer l'espace alloue\*'. En revanche,
vous ne pouvez pas utiliser cette me\*'thode pour re\*'duire le nombre de
re\*'ceptacles alloue\*'s (n'ayez aucune inquie\*'tude si vous le faites tout de me\*^me
par inadvertance\ : cela n'a aucun effet).
.Sp
Voir aussi \f(CW\*(C`each\*(C'\fR, \f(CW\*(C`values\*(C'\fR et \f(CW\*(C`sort\*(C'\fR.
.IP "kill \s-1SIGNAL\s0, \s-1LISTE\s0" 8
.IX Item "kill SIGNAL, LISTE"
Envoie un signal a\*` une liste de processus. Retourne le nombre de processus qui
ont e\*'te\*' correctement X\ signale\*'s\ X (qui n'est pas ne\*'cessairement le me\*^me que le
nombre de processus a\*` qui le signal a e\*'te\*' envoye\*').
.Sp
.Vb 2
\&    $cnt = kill 1, $child1, $child2;
\&    kill 9, @goners;
.Ve
.Sp
Si \s-1SIGNAL\s0 vaut ze\*'ro, aucun signal n'est envoye\*'. C'est un moyen pratique de
ve\*'rifier qu'un process existe encore et n'a pas change\*' son \s-1UID\s0. Voir
perlport pour ve\*'rifier la portabilite\*' d'une telle construction.
.Sp
Au contraire du shell, en Perl, si \fI\s-1SIGNAL\s0\fR est ne\*'gatif, il X\ kill\ X le
groupe de processus pluto\*^t que les processus. (Sur System V, un nume\*'ro de
\&\fI\s-1PROCESSUS\s0\fR ne\*'gatif X\ kill\ X aussi les groupes de processus mais ce n'est pas
portable.) Cela signifie que vous utiliserez habituellement une valeur
positive comme signal. Vous pouvez aussi utilisez un nom de signal entre
apostrophes. Voir \*(L"Signaux\*(R" in perlipc pour tous les de\*'tails.
.IP "last \s-1LABEL\s0" 8
.IX Item "last LABEL"
.PD 0
.IP "last" 8
.IX Item "last"
.PD
La commande \f(CW\*(C`last\*(C'\fR est comme l'instruction \f(CW\*(C`break\*(C'\fR en C (telle qu'elle est
utilise\*'e dans les boucles)\ ; cela permet de sortir imme\*'diatement de la boucle
en question. En l'absence de \s-1LABEL\s0, la commande se re\*'fe\*`re a\*` la boucle
englobante la plus profonde. Le bloc \f(CW\*(C`continue\*(C'\fR, s'il existe, n'est pas
exe\*'cute\*'\ :
.Sp
.Vb 4
\&    LINE: while (<STDIN>) {
\&        last LINE if /^$/;      # exit when done with header
\&        #...
\&    }
.Ve
.Sp
\&\f(CW\*(C`last\*(C'\fR ne peut pas e\*^tre utilise\*' pour sortir d'un bloc qui doit retourner une
valeur comme \f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR ou \f(CW\*(C`do {}\*(C'\fR et ne devrait pas e\*^tre utilise\*'
pour sortir d'une ope\*'ration \fIgrep()\fR ou \fImap()\fR.
.Sp
Notez qu'un bloc en lui\-me\*^me est se\*'mantiquement e\*'quivalent a\*` une boucle qui ne
s'exe\*'cuterait qu'une seule fois. Par conse\*'quent, \f(CW\*(C`last\*(C'\fR peut e\*^tre utilise\*'
pour sortir pre\*'mature\*'ment d'un tel bloc.
.Sp
Voir aussi \*(L"continue\*(R" pour une illustration du comment marche \f(CW\*(C`last\*(C'\fR,
\&\f(CW\*(C`next\*(C'\fR et \f(CW\*(C`redo\*(C'\fR.
.IP "lc \s-1EXPR\s0" 8
.IX Item "lc EXPR"
.PD 0
.IP "lc" 8
.IX Item "lc"
.PD
Retourne une version de \s-1EXPR\s0 entie\*`rement en minuscules. C'est la fonction
interne qui imple\*'mente le se\*'quence d'e\*'chappement \f(CW\*(C`\eL\*(C'\fR dans les chai\*^nes entre
guillemets. Respecte le locale courant \f(CW\*(C`LC_CTYPE\*(C'\fR si \f(CW\*(C`use locale\*(C'\fR est
actif. Voir perllocale et perlunicode pour des plus amples informations
concernant la gestion des \*(L"locale\*(R" et d'Unicode.
.Sp
En l'absence de \s-1EXPR\s0, s'applique a\*` \f(CW$_\fR.
.IP "lcfirst \s-1EXPR\s0" 8
.IX Item "lcfirst EXPR"
.PD 0
.IP "lcfirst" 8
.IX Item "lcfirst"
.PD
Retourne un version de \s-1EXPR\s0 avec le premier caracte\*`re en minuscule. C'est la
fonction interne qui imple\*'mente le se\*'quence d'e\*'chappement \f(CW\*(C`\el\*(C'\fR dans les
chai\*^nes entre guillemets. Respecte le locale courant \f(CW\*(C`LC_CTYPE\*(C'\fR si \f(CW\*(C`use
locale\*(C'\fR est actif. Voir perllocale et perlunicode pour des plus amples
informations concernant la gestion des \*(L"locale\*(R" et d'Unicode.
.Sp
En l'absence de \s-1EXPR\s0, s'applique a\*` \f(CW$_\fR.
.IP "length \s-1EXPR\s0" 8
.IX Item "length EXPR"
.PD 0
.IP "length" 8
.IX Item "length"
.PD
Retourne la longueur en octets de la valeur de \s-1EXPR\s0. En l'absence de \s-1EXPR\s0,
s'applique a\*` \f(CW$_\fR. Notez que cette fonction ne s'applique ni a\*` un tableau ni
a\*` une table de hachage pour savoir combien d'e\*'le\*'ments ils contiennent. Pour
cela, utilisez respectivement \f(CW\*(C`scalar @tableau\*(C'\fR et \f(CW\*(C`scalar keys %hash\*(C'\fR
.IP "link \s-1OLDFILE\s0,NEWFILE" 8
.IX Item "link OLDFILE,NEWFILE"
Cre\*'er un nouveau fichier \s-1NEWFILE\s0 lie\*' a\*` l'ancien fichier \s-1OLDFILE\s0. Retourne true
(vrai) en cas de succe\*`s ou false (faux) sinon.
.IP "listen \s-1SOCKET\s0,QUEUESIZE" 8
.IX Item "listen SOCKET,QUEUESIZE"
Fait exactement la me\*^me chose que l'appel syste\*`me du me\*^me nom. Retourne true
(vrai) en cas de succe\*`s ou false (faux) sinon. Voir les exemples dans
\&\*(L"Sockets : Communication Client/Serveur\*(R" in perlipc.
.IP "local \s-1EXPR\s0" 8
.IX Item "local EXPR"
Vous devriez certainement utiliser \f(CW\*(C`my()\*(C'\fR a\*` la place car \f(CW\*(C`local()\*(C'\fR n'a pas
la se\*'mantique que la plupart des gens accorde a\*` la notion X\ local\ X. Voir
\&\*(L"Variables Prive\*'es via \fImy()\fR\*(R" in perlsub pour plus de de\*'tails.
.Sp
\&\f(CW\*(C`local()\*(C'\fR modifie les variables liste\*'es pour qu'elles soient locales au
bloc/fichier/eval englobant. Si plus d'une valeur est donne\*'e, la liste doit
e\*^tre place\*'e entre parenthe\*`ses. Voir \*(L"Valeurs Temporaires via
\&\fIlocal()\fR\*(R" in perlsub pour plus de de\*'tails, en particulier tout ce qui touche aux tables
de hachage et aux tableaux lie\*'s (par \fItie()\fR).
.IP "localtime \s-1EXPR\s0" 8
.IX Item "localtime EXPR"
Convertit une date telle que retourne\*'e par la fonction time en un tableau de 9
e\*'le\*'ments avec la date lie\*'e au fuseau horaire local. On l'utilise typiquement
de la manie\*`re suivante\ :
.Sp
.Vb 3
\&    #  0    1    2      3      4      5      6      7      8
\&    ($sec,$min,$heure,$mjour,$mois,$annee,$sjour,$ajour,$isdst) =
\&                                                localtime(time);
.Ve
.Sp
Tous les e\*'le\*'ments du tableau sont nume\*'riques et restent tels qu'ils
apparaissent dans la structure 'struct tm'. \f(CW$sec\fR, \f(CW$min\fR et \f(CW$heure\fR sont
les secondes, les minutes et l'heure de l'instant spe\*'cifie\*'. \f(CW$mjour\fR est le
quantie\*`me du mois et \f(CW$mois\fR est le mois lui\-me\*^me, dans l'intervalle \f(CW0..11\fR
avec 0 pour janvier et 11 pour de\*'cembre. \f(CW$annee\fR est le nombre d'anne\*'es
depuis 1900 et donc \f(CW$annee\fR vaut \f(CW123\fR en l'an 2023. \f(CW$sjour\fR est le jour
de la semaine avec 0 pour le dimanche et 3 pour le mercredi. \f(CW$ajour\fR est le
jour de l'anne\*'e dans l'intervalle \f(CW1..365\fR (ou \f(CW1..366\fR pour les anne\*'es
bissextiles.) \f(CW$isdst\fR est vrai si l'heure d'e\*'te\*' est en cours a\*` la date
spe\*'cifie\*'e et faux sinon.
.Sp
Remarquez bien que \f(CW$annee\fR n'est pas que les deux derniers chiffres de
l'anne\*'e. Si vous supposez cela, vous cre\*'ez des programmes non compatible an
2000 \*(-- et vous ne voulez pas faire cela, n'est\-ce pas\ ?
.Sp
La bonne me\*'thode pour obtenir une anne\*'e comple\*`te sur 4 chiffres est tout
simplement\ :
.Sp
.Vb 1
\&        $annee += 1900;
.Ve
.Sp
Et pour obtenir les deux derniers chiffres de l'anne\*'e (e.g. '01' en 2001):
.Sp
.Vb 1
\&        $annee = sprintf("%02d", $annee % 100);
.Ve
.Sp
En l'absence de \s-1EXPR\s0, \f(CW\*(C`localtime()\*(C'\fR utilise la date courante
(\f(CW\*(C`localtime(time)\*(C'\fR).
.Sp
Dans un contexte scalaire, retourne la valeur de \fIctime\fR\|(3)\ :
.Sp
.Vb 1
\&    $now_string = localtime;  # e.g., "Thu Oct 13 04:54:34 1994"
.Ve
.Sp
La valeur scalaire n'est \fBpas\fR de\*'pendante du locale, voir perllocale, mais
est construite de manie\*`re interne a\*` Perl. Voir aussi le module \f(CW\*(C`Time::Local\*(C'\fR
et les fonctions \fIstrftime\fR\|(3) et \fImktime\fR\|(3) du module \s-1POSIX\s0. Pour obtenir
quelque chose de similaire mais dont les chai\*^nes de caracte\*`res des dates
de\*'pendent du locale, parame\*'trez vos variables d'environnement lie\*'es au locale
(voir perllocale) et essayez par exemple\ :
.Sp
.Vb 2
\&    use POSIX qw(strftime);
\&        $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;
.Ve
.Sp
Notez que \f(CW%a\fR et \f(CW%b\fR, les formes courtes du jour de la semaine et du mois
de l'anne\*'e, n'ont pas obligatoirement 3 caracte\*`res de long.
.IP "lock \s-1TRUC\s0" 8
.IX Item "lock TRUC"
Cette fonction place un verrou coope\*'ratif sur une variable partage\*'e ou sur
l'objet re\*'fe\*'rence\*' par \fI\s-1TRUC\s0\fR pour la dure\*'e de la porte\*'e de ce lock.
.Sp
\&\fIlock()\fR est un X\ mot cle\*' faible\ X\ : cela signifie que si vous de\*'finissez
une fonction par ce nom (avant tout appel a\*` \fIlock()\fR), c'est cette fonction qui
sera appele\*'e. (En revanche, si vous dites \f(CW\*(C`use threads\*(C'\fR alors \fIlock()\fR est
toujours une mot cle\*'.) Voir threads.
.IP "log \s-1EXPR\s0" 8
.IX Item "log EXPR"
.PD 0
.IP "log" 8
.IX Item "log"
.PD
Retourne le logarithme ne\*'pe\*'rien ou naturel (base \fIe\fR) de \s-1EXPR\s0. En l'absence
de \s-1EXPR\s0, retourne le log de \f(CW$_\fR. Pour obtenir le logarithme dans une autre
base, utilisez la proprie\*'te\*' suivante\ : le logarithme en base N d'un nombre
est e\*'gal au logarithme naturel de ce nombre divise\*' par le logarithme naturel
de N. Par exemple\ :
.Sp
.Vb 4
\&    sub log10 {
\&        my $n = shift;
\&        return log($n)/log(10);
\&    }
.Ve
.Sp
Voir \*(L"exp\*(R" pour l'ope\*'ration inverse.
.IP "lstat \s-1EXPR\s0" 8
.IX Item "lstat EXPR"
.PD 0
.IP "lstat" 8
.IX Item "lstat"
.PD
Fait la me\*^me chose que la fonction \f(CW\*(C`stat()\*(C'\fR (y compris de modifier le
descripteur spe\*'cial \f(CW\*(C`_\*(C'\fR) mais fournit les donne\*'es du lien symbolique au lieu
de celles du fichier pointe\*' par le lien. Si les liens symboliques ne sont pas
imple\*'mente\*'s dans votre syste\*`me, un appel normal a\*` \f(CW\*(C`stat()\*(C'\fR est effectue\*'.
.Sp
En l'absence de \s-1EXPR\s0, utilise \f(CW$_\fR.
.IP "m//" 8
.IX Item "m//"
L'ope\*'rateur de correspondance (d'expressions rationnelles). Voir perlop.
.IP "map \s-1BLOC\s0 \s-1LISTE\s0" 8
.IX Item "map BLOC LISTE"
.PD 0
.IP "map \s-1EXPR\s0,LISTE" 8
.IX Item "map EXPR,LISTE"
.PD
E\*'value le bloc \s-1BLOC\s0 ou l'expression \s-1EXPR\s0 pour chaque e\*'le\*'ment de \s-1LISTE\s0 (en
affectant localement chaque e\*'le\*'ment a\*` \f(CW$_\fR) et retourne la liste de valeurs
constitue\*'e de tous les re\*'sultats de ces e\*'valuations. L'e\*'valuation du bloc
\&\s-1BLOC\s0 ou de l'expression \s-1EXPR\s0 a lieu dans un contexte de liste si bien que
chaque e\*'le\*'ment de \s-1LISTE\s0 peut produire ze\*'ro, un ou plusieurs e\*'le\*'ments comme
valeur retourne\*'e.
.Sp
.Vb 1
\&    @chars = map(chr, @nums);
.Ve
.Sp
transcrit une liste de nombres vers les caracte\*`res correspondants. Et\ :
.Sp
.Vb 1
\&    %hash = map { getkey($_) => $_ } @array;
.Ve
.Sp
est juste une manie\*`re rigolote de dire\ :
.Sp
.Vb 4
\&    %hash = ();
\&    foreach $_ (@array) {
\&        $hash{getkey($_)} = $_;
\&    }
.Ve
.Sp
Remarquez que du fait que \f(CW$_\fR est une re\*'fe\*'rence vers la liste de valeurs, il
peut e\*^tre utilise\*' pour modifier les e\*'le\*'ments du tableau. Bien que cela soit
pratique et supporte\*', cela peut produire des re\*'sultats bizarres si \s-1LISTE\s0 n'est
pas un tableau nomme\*'. L'utilisation d'une boucle \f(CW\*(C`foreach\*(C'\fR est plus claire
dans de nombreux cas. Voir aussi \*(L"grep\*(R" pour produire un tableau compose\*' de
tous les e\*'le\*'ments de la liste originale pour lesquels \s-1BLOC\s0 ou \s-1EXPR\s0 est e\*'value\*'
a\*` vrai (true).
.IP "mkdir \s-1FILENAME\s0,MASK" 8
.IX Item "mkdir FILENAME,MASK"
.PD 0
.IP "mkdir" 8
.IX Item "mkdir"
.PD
Cre\*'e le re\*'pertoire dont le nom est spe\*'cifie\*' par \s-1FILENAME\s0 avec les droits
d'acce\*`s spe\*'cifie\*'s par \s-1MASK\s0 (et modifie\*'s par \f(CW\*(C`umask\*(C'\fR). En cas de succe\*`s,
retourne \s-1TRUE\s0 (vrai). Sinon, retourne false (faux) et positionne la variable
\&\f(CW$!\fR (errno). Par de\*'faut, \s-1MASK\s0 vaut 0777.
.Sp
En ge\*'ne\*'ral, il vaut mieux cre\*'er des re\*'pertoires avec un \s-1MASK\s0 permissif et
laisser l'utilisateur modifier cela via son \f(CW\*(C`umask\*(C'\fR que de fournir un \s-1MASK\s0
trop restrictif ne permettant pas a\*` l'utilisateur d'e\*^tre plus
permissif. L'exception a\*` cette re\*`gle concerne les re\*'pertoires ou les fichiers
doivent e\*^tre prive\*'s (fichiers de messagerie par exemple). \*(L"umask\*(R" discute
plus en de\*'tails du choix de \s-1MASK\s0.
.Sp
Notez que, selon la norme \s-1POSIX\s0 1003.1\-1996, \s-1FILENAME\s0 peut se terminer par
ze\*'ro, un ou plusieurs \f(CW\*(C`\e/\*(C'\fR. Certains syste\*`mes d'exploitation ou de fichiers ne
le permettent pas. Donc, pour que tout le monde soit content. Perl enle\*`ve
automatiquement ces caracte\*`res \f(CW\*(C`\e/\*(C'\fR finaux.
.IP "msgctl \s-1ID\s0,CMD,ARG" 8
.IX Item "msgctl ID,CMD,ARG"
Appelle la fonction \fImsgctl\fR\|(2) des \s-1IPC\s0 System V. Vous devrez probablement
dire\ :
.Sp
.Vb 1
\&    use IPC::SysV;
.Ve
.Sp
au pre\*'alable pour avoir les de\*'finitions correctes des constantes. Si \s-1CMD\s0 est
\&\f(CW\*(C`IPC_STAT\*(C'\fR alors \s-1ARG\s0 doit e\*^tre une variable qui pourra contenir la structure
\&\f(CW\*(C`msqid_ds\*(C'\fR retourne\*'e. Renvoie la me\*^me chose que \f(CW\*(C`ioctl()\*(C'\fR\ : la valeur undef
en cas d'erreur, "\f(CW0\fR but true" pour la valeur ze\*'ro ou la ve\*'ritable valeur
dans les autres cas. Voir aussi la documentation de \f(CW\*(C`IPC::SysV\*(C'\fR et
\&\f(CW\*(C`IPC::Semaphore::Msg\*(C'\fR.
.IP "msgget \s-1KEY\s0,FLAGS" 8
.IX Item "msgget KEY,FLAGS"
Appelle la fonction \fImsgget\fR\|(2) des \s-1IPC\s0 System V. Retourne l'id de la queue de
messages ou la valeur undef en cas d'erreur. Voir aussi \f(CW\*(C`IPC::SysV\*(C'\fR et
\&\f(CW\*(C`IPC::SysV::Msg\*(C'\fR.
.IP "msgrcv \s-1ID\s0,VAR,SIZE,TYPE,FLAGS" 8
.IX Item "msgrcv ID,VAR,SIZE,TYPE,FLAGS"
Appelle la fonction msgrcv des \s-1IPC\s0 System V pour recevoir un message a\*` partir
de la queue de message d'identificateur \s-1ID\s0 et le stocker dans la variable \s-1VAR\s0
avec une taille maximale de \s-1SIZE\s0. Remarquez que, si un message est rec\*,u, le
type de message sera la premie\*`re chose dans \s-1VAR\s0 et que la taille maximale de
\&\s-1VAR\s0 est \s-1SIZE\s0 plus la taille du type de message. Ces donne\*'es compacte\*'es peuvent
e\*^tre de\*'compacte\*'es par \f(CW\*(C`unpack("l! a*")\*(C'\fR. Souille la variable \s-1VAR\s0. Retourne
\&\s-1TRUE\s0 (vrai) en cas de succe\*`s ou false (faux) sinon. Voir aussi \f(CW\*(C`IPC::SysV\*(C'\fR et
\&\f(CW\*(C`IPC::SysV::Msg\*(C'\fR.
.IP "msgsnd \s-1ID\s0,MSG,FLAGS" 8
.IX Item "msgsnd ID,MSG,FLAGS"
Appelle la fonction msgsnd des \s-1IPC\s0 System V pour envoyer le message \s-1MSG\s0 dans
la queue de messages d'identificateur \s-1ID\s0. \s-1MSG\s0 doit commencer par l'entier long
natif donnant le type de message suivi de la longueur re\*'elle du message suivi
du message lui\-me\*^me. Cette donne\*'e compacte\*'e peut e\*^tre produite par \f(CW\*(C`pack("l!
a*", $type, $message)\*(C'\fR. Retourne true (vrai) en cas de succe\*`s ou false (faux)
en cas d'erreur. Voir aussi \f(CW\*(C`IPC::SysV\*(C'\fR et \f(CW\*(C`IPC::SysV::Msg\*(C'\fR.
.IP "my \s-1EXPR\s0" 8
.IX Item "my EXPR"
.PD 0
.IP "my \s-1TYPE\s0 \s-1EXPR\s0" 8
.IX Item "my TYPE EXPR"
.IP "my \s-1EXPR\s0 : \s-1ATTRIBUTS\s0" 8
.IX Item "my EXPR : ATTRIBUTS"
.IP "my \s-1TYPE\s0 \s-1EXPR\s0 : \s-1ATTRIBUTS\s0" 8
.IX Item "my TYPE EXPR : ATTRIBUTS"
.PD
\&\f(CW\*(C`my()\*(C'\fR de\*'clare les variables liste\*'es comme e\*'tant locales (lexicalement) au
bloc, fichier ou \f(CW\*(C`eval()\*(C'\fR englobant. Si plus d'une variable est liste\*'e, la
liste doit e\*^tre place\*'e entre parenthe\*`ses.
.Sp
La se\*'mantique exacte et l'interface avec \s-1TYPE\s0 et \s-1ATTRIBUTS\s0 est encore en cours
    d'e\*'volution. \s-1TYPE\s0 est actuellement lie\*' a\*` l'utilisation de la directive
\&\f(CW\*(C`fields\*(C'\fR et les attributs sont ge\*'re\*'s par la directive \f(CW\*(C`attributes\*(C'\fR ou,
depuis la version 5.8.0 de Perl, via le module \f(CW\*(C`Attribute::Handlers\*(C'\fR. Voir
\&\*(L"Variables Prive\*'es via \fImy()\fR\*(R" in perlsub pour plus de de\*'tails ainsi que
fields, attributes et Attribute::Handlers.
.IP "next \s-1LABEL\s0" 8
.IX Item "next LABEL"
.PD 0
.IP "next" 8
.IX Item "next"
.PD
La commande \f(CW\*(C`next\*(C'\fR fonctionne comme l'instruction \f(CW\*(C`continue\*(C'\fR du C\ ; elle
commence la prochaine ite\*'ration d'une boucle\ :
.Sp
.Vb 4
\&    LINE: while (<STDIN>) {
\&        next LINE if /^#/;      # ne pas traiter les commentaires
\&        #...
\&    }
.Ve
.Sp
Si il y avait un bloc \f(CW\*(C`continue\*(C'\fR dans cet exemple, il serait exe\*'cute\*' me\*^me
pour les lignes ignore\*'es. Si \s-1LABEL\s0 est omis, la commande se re\*'fe\*`re au bloc
englobant le plus inte\*'rieur.
.Sp
\&\f(CW\*(C`next\*(C'\fR ne peut pas e\*^tre utilise\*' pour sortir d'un bloc qui doit retourner une
valeur comme \f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR ou \f(CW\*(C`do {}\*(C'\fR et ne devrait pas e\*^tre utilise\*'
pour sortir d'une ope\*'ration \fIgrep()\fR ou \fImap()\fR.
.Sp
Voir aussi \*(L"continue\*(R" pour voir comment \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR et
\&\f(CW\*(C`redo\*(C'\fR fonctionne.
.IP "no Module \s-1VERSION\s0 \s-1LISTE\s0" 8
.IX Item "no Module VERSION LISTE"
.PD 0
.IP "no Module \s-1VERSION\s0" 8
.IX Item "no Module VERSION"
.IP "no Module \s-1LISTE\s0" 8
.IX Item "no Module LISTE"
.IP "no Module" 8
.IX Item "no Module"
.PD
Voir la fonction \*(L"use\*(R" pour laquelle \f(CW\*(C`no\*(C'\fR est le contraire.
.IP "oct \s-1EXPR\s0" 8
.IX Item "oct EXPR"
.PD 0
.IP "oct" 8
.IX Item "oct"
.PD
Interpre\*`te \s-1EXPR\s0 comme une chai\*^ne octale et retourne la valeur
correspondante. (Si il s'ave\*`re que \s-1EXPR\s0 commence par \f(CW\*(C`0x\*(C'\fR, elle sera
interpre\*'te\*'e comme un chai\*^ne hexade\*'cimale. Si \s-1EXPR\s0 commence par \f(CW\*(C`0b\*(C'\fR, elle
sera interpre\*'te\*'e comme une chai\*^ne binaire. Dans tous les cas, les blancs
initiaux sont ignore\*'s) La ligne suivante manipule les chai\*^ne de\*'cimales,
binaires, octales et hexade\*'cimales comme le fait la notation standard Perl ou
C\ :
.Sp
.Vb 1
\&    $val = oct($val) if $val =~ /^0/;
.Ve
.Sp
Si \s-1EXPR\s0 est absent, la commande s'applique a\*` \f(CW$_\fR. Pour re\*'aliser l'ope\*'ration
inverse (produire la repre\*'sentation octale d'un nombre), utilisez \fIsprintf()\fR ou
\&\fIprintf()\fR\ :
.Sp
.Vb 2
\&    $perms = (stat("filename"))[2] & 07777;
\&    $oct_perms = sprintf "%lo", $perms;
.Ve
.Sp
La fonction \fIoct()\fR est couramment utilise\*'e pour convertir une chai\*^ne telle que
\&\f(CW644\fR en un mode d'acce\*`s pour fichier par exemple. (perl convertit
automatiquement les chai\*^nes en nombres si besoin mais en supposant qu'ils sont
en base 10.)
.IP "open \s-1DESCRIPTEUR\s0,EXPR" 8
.IX Item "open DESCRIPTEUR,EXPR"
.PD 0
.IP "open \s-1DESCRIPTEUR\s0,MODE,EXPR" 8
.IX Item "open DESCRIPTEUR,MODE,EXPR"
.IP "open \s-1DESCRIPTEUR\s0,MODE,EXPR,LISTE" 8
.IX Item "open DESCRIPTEUR,MODE,EXPR,LISTE"
.IP "open \s-1DESCRIPTEUR\s0,MODE,REFERENCE" 8
.IX Item "open DESCRIPTEUR,MODE,REFERENCE"
.IP "open \s-1DESCRIPTEUR\s0" 8
.IX Item "open DESCRIPTEUR"
.PD
Ouvre le fichier dont le nom est donne\*' par \s-1EXPR\s0 et l'associe a\*` \s-1DESCRIPTEUR\s0.
.Sp
(La suite de cette section est une description exhaustive de \fIopen()\fR. Pour une
introduction plus douce, vous devriez regarder perlopentut.)
.Sp
Si \s-1DESCRIPTEUR\s0 est une variable lexicale (\f(CW\*(C`my\*(C'\fR) inde\*'finie, cette variable
recevra une re\*'fe\*'rence vers un nouveau descripteur anonyme. Sinon, si
\&\s-1DESCRIPTEUR\s0 est une expression, sa valeur est utilise\*'e en tant que nom du
descripteur a\*` associer. (Ceci est conside\*'re\*' comme une re\*'fe\*'rence symbolique
donc \f(CW\*(C`use strict 'refs'\*(C'\fR ne devrait \fIpas\fR e\*^tre actif.)
.Sp
Si \s-1EXPR\s0 est omis, la variable scalaire du me\*^me nom que le \s-1DESCRIPTEUR\s0 contient
le nom du fichier. (Remarquez que les variables lexicales \*(-- celles de\*'clare\*'es
par \f(CW\*(C`my()\*(C'\fR \*(-- ne fonctionnent pas dans ce cas\ ; donc si vous utilisez
\&\f(CW\*(C`my()\*(C'\fR, spe\*'cifiez \s-1EXPR\s0 dans votre appel a\*` open.)
.Sp
Si au moins trois arguments sont spe\*'cifie\*'s alors le mode d'ouverture et le nom
du fichier sont se\*'pare\*'s.  Si \s-1MODE\s0 est \f(CW'<'\fR ou rien du tout, le fichier
est ouvert en lecture. Si \s-1MODE\s0 est \f(CW'>'\fR, le fichier est tronque\*' puis
ouvert en e\*'criture en e\*'tant cre\*'e\*' si ne\*'cessaire. Si \s-1MODE\s0 est \f(CW'>>'\fR, le
fichier est ouvert en e\*'criture et en mode ajout. La\*` encore, il sera cre\*'e\*' si
ne\*'cessaire.
.Sp
Vous pouvez ajouter un \f(CW'+'\fR devant \f(CW'>'\fR ou \f(CW'<'\fR pour indiquer
que vous voulez a\*` la fois les droits d'e\*'criture et de lecture sur le fichier\ ; Ceci e\*'tant \f(CW'+<'\fR est toujours mieux pour les mises a\*` jour en
lecture/e\*'criture \*(-- le mode \f(CW'+>'\fR e\*'craserait le fichier au
pre\*'alable. Habituellement, il n'est pas possible d'utiliser le mode
lecture/e\*'criture pour des fichiers textes puisqu'ils ont des tailles
d'enregistrements variables. Voir l'option \fB\-i\fR dans perlrun pour une
meilleure approche. Le fichier est cre\*'e\*' avec les droits \f(CW0666\fR modifie\*'s par
la valeur de \f(CW\*(C`umask\*(C'\fR du processus courant.
.Sp
Ces diffe\*'rents pre\*'fixes correspondent aux diffe\*'rents modes d'ouverture de
\&\fIfopen\fR\|(3) : \f(CW'r'\fR, \f(CW'r+'\fR, \f(CW'w'\fR, \f(CW'w+'\fR, \f(CW'a'\fR et \f(CW'a+'\fR.
.Sp
Dans sa forme a\*` 1 ou 2 arguments, le mode et le nom de fichier peuvent e\*^tre
concate\*'ne\*'s (dans cet ordre), e\*'ventuellement se\*'pare\*'s par des espaces. Il est
possible d'omettre le mode si c'est \f(CW'<'\fR.
.Sp
Si le nom de fichier commence par \f(CW'|'\fR, le nom de fichier est interpre\*'te\*'
comme une commande vers laquelle seront dirige\*'es les sorties (via un tube \*(--
en anglais pipe) et si le nom de fichier se termine par \f(CW'|'\fR, le nom de
fichier est interpre\*'te\*' comme une commande dont la sortie sera re\*'cupe\*'re\*'e (via
un tube \*(-- en anglais pipe). Voir \*(L"Utilisation de \fIopen()\fR pour la
\&\s-1CIP\s0\*(R" in perlipc pour des exemples a\*` ce sujet. (Vous ne pouvez pas utiliser \f(CW\*(C`open()\*(C'\fR
pour une commande qui utiliserait un me\*^me tube a\*` la fois pour ses entre\*'es
\&\fIet\fR pour ses sorties mais IPC::Open2, IPC::Open3 et
\&\*(L"Communication Bidirectionnelle avec un autre Processus\*(R" in perlipc proposent
des solutions de remplacement.)
.Sp
Pour les appels avec au moins trois arguments, si \s-1MODE\s0 est \f(CW'|\-'\fR, le nom de
fichier est interpre\*'te\*' comme une commande vers laquelle seront dirige\*'es les
sorties et si le \s-1MODE\s0 est \f(CW'\-|'\fR, le nom de fichier sera interpre\*'te\*' comme une
comme dont la sortie sera re\*'cupe\*'re\*'e (via un tube \*(-- en anglais pipe). Pour
retomber sur une forme a\*` deux arguments, il suffit de remplacer le moins
(\f(CW'\-'\fR) par la commande elle\-me\*^me. Voir \*(L"Utilisation de \fIopen()\fR pour
la \s-1CIP\s0\*(R" in perlipc pour des exemples a\*` ce sujet. (Vous ne pouvez pas utiliser \f(CW\*(C`open()\*(C'\fR
pour une commande qui utiliserait un me\*^me tube a\*` la fois pour ses entre\*'es
\&\fIet\fR pour ses sorties mais IPC::Open2, IPC::Open3 et
\&\*(L"Communication Bidirectionnelle avec un autre Processus\*(R" in perlipc proposent
des solutions de remplacement.)
.Sp
Pour les appels avec au moins trois arguments et faisant au me\*'canisme de tube,
si \s-1LISTE\s0 est spe\*'cifie\*'e (ce sont les arguments apre\*`s la commande) alors \s-1LISTE\s0
devient les arguments de la commande invoque\*'e si la plateforme l'accepte. La
se\*'mantique de \f(CW\*(C`open\*(C'\fR avec plus de trois arguments pour un mode sans tube
n'est pas encore spe\*'cifie\*'e. Des \*(L"filtres\*(R" expe\*'rimentaux peuvent donner un sens
a\*` ces arguments supple\*'mentaires.
.Sp
Dans la forme a\*` un ou deux arguments, ouvrir \f(CW'\-'\fR revient a\*` ouvrir \s-1STDIN\s0
tandis qu'ouvrir \f(CW'>\-'\fR revient a\*` ouvrir \s-1STDOUT\s0.
.Sp
Vous pouvez utiliser la forme a\*` trois arguments en spe\*'cifiant des \*(L"filtres\*(R"
d'entre\*'e/sortie (anciennement appele\*'s \*(L"disciplines\*(R") a\*` appliquer au
descripteur afin de modifier la manie\*`re dont sont traite\*'s les entre\*'es et les
sorties (Voir open et PerlIO pour plus d'informations). Par exemple\ :
.Sp
.Vb 1
\&        open(FH, "<:utf8", "file")
.Ve
.Sp
ouvrira le fichier \*(L"file\*(R" encode\*' en \s-1UTF\-8\s0 et contenant des caracte\*`res
Unicode. Voir perluniintro. (Remarquez que si des filtres sont spe\*'cifie\*'s
dans un appel a\*` au moins trois arguments alors les filtres par de\*'faut fixe\*'s
via la directive \f(CW\*(C`open\*(C'\fR sont ignore\*'s.)
.Sp
Open renvoie une valeur non nulle en cas de succe\*`s et undef sinon. Si
\&\f(CW\*(C`open()\*(C'\fR utilise un tube, la valeur de retour sera le \s-1PID\s0 du sous\-processus.
.Sp
Si vous utilisez Perl sur un syste\*`me qui fait une distinction entre les
fichiers textes et les fichiers binaires alors vous devriez regarder du co\*^te\*'
de \*(L"binmode\*(R" pour connai\*^tre les astuces a\*` ce sujet. La principale diffe\*'rence
entre les syste\*`mes ne\*'cessitant \f(CW\*(C`binmode()\*(C'\fR et les autres re\*'side dans le
format de leurs fichiers textes. Des syste\*`mes tels que Unix, MacOS et Plan9
qui de\*'limitent leurs lignes par un seul caracte\*`re et qui encodent ce caracte\*`re
en C par \f(CW"\en"\fR ne ne\*'cessitent pas \f(CW\*(C`binmode()\*(C'\fR. Les autres en ont besoin.
.Sp
A\*` l'ouverture d'un fichier, c'est ge\*'ne\*'ralement une mauvaise ide\*'e de continuer
l'exe\*'cution normale si la reque\*^te e\*'choue, ce qui explique pourquoi \f(CW\*(C`open()\*(C'\fR
est si fre\*'quemment utilise\*' en association avec \f(CW\*(C`die()\*(C'\fR. Me\*^me si \f(CW\*(C`die()\*(C'\fR
n'est pas ce que voulez faire (par exemple dans un script \s-1CGI\s0 ou\*` vous voulez
re\*'cupe\*'rer un message d'erreur joliment pre\*'sente\*' (il y a des modules qui
peuvent vous aider pour cela)), vous devriez toujours ve\*'rifier la valeur
retourne\*'e par l'ouverture du fichier. L'une des rares exceptions est lorsque
vous voulez travailler sur un descripteur non ouvert.
.Sp
Un appel sous la forme de trois arguments en mode lecture/e\*'criture avec un
troisie\*`me argument inde\*'fini (\f(CW\*(C`undef\*(C'\fR) est un cas spe\*'cial\ :
.Sp
.Vb 1
\&          open(TMP, "+>", undef) or die ...
.Ve
.Sp
ouvrira un descripteur vers un fichier temporaire anonyme.
.Sp
Les descripteurs peuvent e\*^tre ouvert sur des fichiers \*(L"en me\*'moire\*(R" stocke\*'s
dans des scalaires Perl via\ :
.Sp
.Vb 1
\&     open($fh, '>', \e$variable) || ...
.Ve
.Sp
Par contre, si vous essayez de re\*'\-ouvrir \f(CW\*(C`STDOUT\*(C'\fR ou \f(CW\*(C`STDERR\*(C'\fR comme des
fichiers \*(L"en me\*'moire\*(R", vous devez les fermer auparavant\ :
.Sp
.Vb 2
\&         close STDOUT;
\&         open STDOUT, '>', \e$variable or die "Can't open STDOUT: $!";
.Ve
.Sp
Exemples\ :
.Sp
.Vb 3
\&    $ARTICLE = 100;
\&    open ARTICLE or die "Can't find article $ARTICLE: $!\en";
\&    while (<ARTICLE>) {...
\&
\&    open(LOG, '>>/usr/spool/news/twitlog'); # (log is reserved)
\&    # si le open e\*'choue, les sorties sont perdues
\&
\&    open(DBASE, '+<', 'dbase.mine')             # ouverture pour mise a\*` jour
\&        or die "Can't open 'dbase.mine' for update: $!";
\&
\&    open(DBASE, '+<dbase.mine')                 # idem
\&        or die "Can't open 'dbase.mine' for update: $!";
\&
\&    open(ARTICLE, '\-|', "caesar <$article")     # de\*'cryptage de l'article
\&        or die "Can't start caesar: $!";
\&
\&    open(ARTICLE, "caesar <$article |")         # idem
\&        or die "Can't start caesar: $!";
\&
\&    open(EXTRACT, "|sort >/tmp/Tmp$$")          # $$ est notre ID de process
\&        or die "Can't start sort: $!";
\&
\&    # fichiers en me\*'moire
\&    open(MEMORY,'>', \e$var)
\&        or die "Can't open memory file: $!";
\&    print MEMORY "foo!\en";                      # les sorties seront envoye\*'es vers $var
\&        
\&
\&    # traitement de la liste des fichiers fournie en argument
\&
\&    foreach $file (@ARGV) {
\&        process($file, 'fh00');
\&    }
\&
\&    sub process {
\&        my($filename, $input) = @_;
\&        $input++;               # c'est une incre\*'mentation de chai\*^ne
\&        unless (open($input, $filename)) {
\&            print STDERR "Can't open $filename: $!\en";
\&            return;
\&        }
\&
\&        local $_;
\&        while (<$input>) {      # remarquez l'utilisation de l'indirection
\&            if (/^#include "(.*)"/) {
\&                process($1, $input);
\&                next;
\&            }
\&            #...                # ce qu'il faut faire...
\&        }
\&    }
.Ve
.Sp
Vous pouvez aussi, dans la tradition du Bourne shell, spe\*'cifier une expression
\&\s-1EXPR\s0 commenc\*,ant par \f(CW'>&'\fR auquel cas le reste de la chai\*^ne sera
interpre\*'te\*' comme le nom d'un descripteur (ou son nume\*'ro si c'est une valeur
nume\*'rique) a\*` dupliquer puis a\*` ouvrir. Vous pouvez utiliser \f(CW\*(C`&\*(C'\fR apre\*`s
\&\f(CW\*(C`>\*(C'\fR, \f(CW\*(C`>>\*(C'\fR, \f(CW\*(C`<\*(C'\fR, \f(CW\*(C`+>\*(C'\fR, \f(CW\*(C`+>>\*(C'\fR et \f(CW\*(C`+<\*(C'\fR. Le
mode que vous spe\*'cifiez devrait correspondre a\*` celui du descripteur
original. (La duplication d'un descripteur ne prend pas en compte l'e\*'ventuel
contenu des tampons d'entre\*'es/sorties). Si vous utilisez l'appel avec 3
arguments alors vous devez fournir soit un nombre, soit le nom du descripteur
soit une re\*'fe\*'rence globale \*(L"normale\*(R".
.Sp
Voici un script qui sauvegarde, redirige et restaure \f(CW\*(C`STDOUT\*(C'\fR et \f(CW\*(C`STDERR\*(C'\fR de
diffe\*'rentes manie\*`res\ :
.Sp
.Vb 3
\&       #!/usr/bin/perl
\&       open my $oldout, ">&STDOUT"     or die "Can't dup STDOUT: $!";
\&       open OLDERR,     ">&", \e*STDERR or die "Can't dup STDERR: $!";
\&
\&       open STDOUT, '>', "foo.out" or die "Can't redirect STDOUT: $!";
\&       open STDERR, ">&STDOUT"     or die "Can't dup STDOUT: $!";
\&
\&       select STDERR; $| = 1;      # make unbuffered
\&       select STDOUT; $| = 1;      # make unbuffered
\&
\&       print STDOUT "stdout 1\en";  # this works for
\&       print STDERR "stderr 1\en";  # subprocesses too
\&
\&       close STDOUT;
\&       close STDERR;
\&
\&       open STDOUT, ">&", $oldout or die "Can't dup \e$oldout: $!";
\&       open STDERR, ">&OLDERR"    or die "Can't dup OLDERR: $!";
\&
\&       print STDOUT "stdout 2\en";
\&       print STDERR "stderr 2\en";
.Ve
.Sp
Si vous spe\*'cifiez \f(CW'<&=N'\fR, ou\*` \f(CW\*(C`N\*(C'\fR est un nombre, alors Perl fera
l'e\*'quivalent d'un \f(CW\*(C`fdopen()\*(C'\fR en C sur ce descripteur de fichier\ ; c'est
plus e\*'conome en descripteur de fichier. Par exemple\ :
.Sp
.Vb 1
\&    open(DESCRIPTEUR, "<&=$fd")
.Ve
.Sp
ou
.Sp
.Vb 1
\&    open(DESCRIPTEUR, "<&=", $fd)
.Ve
.Sp
Remarquez bien que cette fonctionnalite\*' de\*'pend la fonction \fIfdopen()\fR de votre
bibliothe\*`que C. Sur la plupart des syste\*`mes \s-1UNIX\s0, \fIfdopen()\fR est connu pour
e\*'chouer lorsque le nombre de descripteurs de fichiers de\*'passe une certaine
limite, typiquement 255. Si vous avez besoin de descripteurs de fichiers plus
nombreux, vous devriez examiner la possibilite\*' de recompiler Perl en utilisant
la bibliothe\*`que \f(CW\*(C`PerlIO\*(C'\fR.
.Sp
Vous pouvez savoir si Perl a e\*'te\*' compile\*' avec PerlIO ou non en exe\*'cutant
\&\f(CW\*(C`perl \-V\*(C'\fR et en regardant la ligne \f(CW\*(C`useperlio=\*(C'\fR. Si \f(CW\*(C`useperlio\*(C'\fR est
\&\f(CW\*(C`define\*(C'\fR, vous avez PerlIO.
.Sp
Si vous ouvrez un tube (pipe) sur la commande \f(CW'\-'\fR, i.e. soit \f(CW'|\-'\fR soit
\&\f(CW'\-|'\fR, alors vous faites un fork implicite et la valeur de retour de open
est le \s-1PID\s0 du processus fils pour le processus pe\*`re et \f(CW0\fR pour le processus
fils. (Utilisez \f(CW\*(C`defined($pid)\*(C'\fR pour savoir si le open s'est bien de\*'roule\*'.)
Le descripteur se comporte normalement pour le pe\*`re mais pour le processus
fils, les entre\*'es/sorties sur ce descripteur se font via \s-1STDIN/STDOUT\s0. Dans le
processus fils, le descripteur n'est pas ouvert \*(-- les e\*'changes se font via
les nouveaux \s-1STDIN\s0 ou \s-1STDOUT\s0. Cela s'ave\*`re utile lorsque vous voulez avoir un
contro\*^le plus fin sur la commande exe\*'cute\*'e par exemple lorsque vous avez un
script setuid et que vous ne voulez pas que le shell traite les
me\*'ta\-caracte\*`res dans les commandes. Les lignes suivantes sont quasiment
e\*'quivalentes (trois a\*` trois)\ :
.Sp
.Vb 4
\&    open(FOO, "|tr '[a\-z]' '[A\-Z]'");
\&    open(FOO, '|\-', "tr '[a\-z]' '[A\-Z]'");
\&    open(FOO, "|\-") || exec 'tr', '[a\-z]', '[A\-Z]';
\&    open(FOO, '|\-', "tr", '[a\-z]', '[A\-Z]');
\&
\&    open(FOO, "cat \-n '$file'|");
\&    open(FOO, '\-|', "cat \-n '$file'");
\&    open(FOO, "\-|") || exec 'cat', '\-n', $file;
\&    open(FOO, '\-|', "cat", '\-n', $file);
.Ve
.Sp
Le dernier exemple de chacun des deux blocs montre l'utilisation des tubes
avec le passage de parame\*`tres. Ce n'est pas disponible sur toutes les
plateformes. Si votre plateforme propose un vrai \f(CW\*(C`fork()\*(C'\fR (en d'autres
termes, si vous e\*^tes sur \s-1UNIX\s0) alors vous pouvez utiliser cette syntaxe.
.Sp
Voir \*(L"Ouvertures Su\*^res d'un Tube\*(R" in perlipc pour plus d'exemples a\*` ce sujet.
.Sp
A\*` partir de la version v5.6.0, Perl tente de vider les tampons de tous les
fichiers ouverts en e\*'criture avant toute ope\*'ration impliquant un fork mais ce
n'est pas supporte\*' sur toutes les plates-formes (voir perlport). Pour e\*^tre
plus su\*^r, vous devriez positionner la variable \f(CW$|\fR ($AUTOFLUSH en anglais) ou
appele\*' la me\*'thode \f(CW\*(C`autoflush()\*(C'\fR des objets \f(CW\*(C`IO::Handle\*(C'\fR pour chacun des
descripteurs ouverts afin d'e\*'viter toute perte de donne\*'es.
.Sp
Sur les syste\*`mes qui supportent le drapeau fermeture\-a\*`\-l\-exe\*'cution
(close\-on\-exec) sur les fichiers, ce drapeau sera positionne\*' pour de nouveaux
descripteurs de fichier en fonction de la valeur de $^F. Voir \*(L"$^F\*(R" in perlvar.
.Sp
La fermeture d'un descripteur utilisant un tube (pipe) ame\*`ne le processus pe\*`re
a\*` attendre que son fils se termine puis a\*` retourner la valeur de statut dans
\&\f(CW$?\fR.
.Sp
Le nom de fichier passe\*' a\*` open dans la forme a\*` 1 ou 2 arguments verra ses
e\*'ventuels espaces avant et apre\*`s supprime\*'s et les caracte\*`res de redirection
normaux seront respecte\*'s. Cette fonctionnalite\*', connue sous le nom de
\&\*(L"ouverture magique\*(R", autorise plein de bonnes choses. Un utilisateur peut
spe\*'cifier un nom de fichier tel que \fI\*(L"rsh cat file |\*(R"\fR ou alors vous pouvez
modifier certains noms de fichiers selon vos besoins\ :
.Sp
.Vb 2
\&    $filename =~ s/(.*\e.gz)\es*$/gzip \-dc < $1|/;
\&    open(FH, $filename) or die "Can't open $filename: $!";
.Ve
.Sp
Utilisez la forme a\*` 3 arguments pour ouvrir un fichier dont le nom contient
des caracte\*`res quelconques\ :
.Sp
.Vb 1
\&    open(FOO, '<', $file);
.Ve
.Sp
sinon il est ne\*'cessaire de prote\*'ger les caracte\*`res spe\*'ciaux et tous les
espaces avant et/ou apre\*`s :
.Sp
.Vb 2
\&    $file =~ s#^(\es)#./$1#;
\&    open(FOO, "< $file\e0");
.Ve
.Sp
(cela peut ne pas fonctionner sur certains syste\*`mes de fichier bizarres). Vous
devez choisir consciemment entre la forme magique ou la forme a\*` 3 arguments de
\&\fIopen()\fR\ :
.Sp
.Vb 1
\&    open IN, $ARGV[0];
.Ve
.Sp
autorisera l'utilisateur a\*` spe\*'cifier un argument de la forme \f(CW"rsh cat file
|"\fR mais ne marchera pas avec un nom de fichier contenant des espaces alors
que\ :
.Sp
.Vb 1
\&    open IN, '<', $ARGV[0];
.Ve
.Sp
a exactement les limitation inverses.
.Sp
Si vous voulez un \*(L"vrai\*(R" \f(CW\*(C`open()\*(C'\fR a\*` la C (voir \fIopen\fR\|(2) sur votre syste\*`me)
alors vous devriez utiliser la fonction \f(CW\*(C`sysopen()\*(C'\fR qui ne fait rien de
magique. C'est un autre moyen de prote\*'ger vos noms de fichiers de toute
interpre\*'tation. Par exemple\ :
.Sp
.Vb 7
\&    use IO::Handle;
\&    sysopen(HANDLE, $path, O_RDWR|O_CREAT|O_EXCL)
\&        or die "sysopen $path: $!";
\&    $oldfh = select(HANDLE); $| = 1; select($oldfh);
\&    print HANDLE "stuff $$\en");
\&    seek(HANDLE, 0, 0);
\&    print "File contains: ", <HANDLE>;
.Ve
.Sp
En utilisant le constructeur du paquetage \f(CW\*(C`IO::Handle\*(C'\fR (ou de l'une de ses
sous-classes telles que \f(CW\*(C`IO::File\*(C'\fR ou \f(CW\*(C`IO::Socket\*(C'\fR), vous pouvez ge\*'ne\*'rer des
descripteurs anonymes qui ont la me\*^me porte\*'e que les variables qui gardent une
re\*'fe\*'rence sur eux et qui se ferment automatiquement de\*`s qu'ils sont hors de
porte\*'e\ :
.Sp
.Vb 12
\&    use IO::File;
\&    #...
\&    sub read_myfile_munged {
\&        my $ALL = shift;
\&        my $handle = new IO::File;
\&        open($handle, "myfile") or die "myfile: $!";
\&        $first = <$handle>
\&            or return ();     # Fermeture automatique ici
\&        mung $first or die "mung failed";       # Ou ici.
\&        return $first, <$handle> if $ALL;       # Ou ici.
\&        $first;                                 # Ou ici.
\&    }
.Ve
.Sp
Voir \*(L"\fIseek()\fR\*(R" pour de plus amples informations sur le me\*'lange entre lecture
et e\*'criture.
.IP "opendir \s-1DIRHANDLE\s0,EXPR" 8
.IX Item "opendir DIRHANDLE,EXPR"
Ouvre le re\*'pertoire nomme\*' par \s-1EXPR\s0 pour un traitement par \f(CW\*(C`readdir()\*(C'\fR,
\&\f(CW\*(C`telldir()\*(C'\fR, \f(CW\*(C`seekdir()\*(C'\fR, \f(CW\*(C`rewinddir()\*(C'\fR et \f(CW\*(C`closedir()\*(C'\fR. Retourne true
(vrai) en cas de succe\*`s. Les DIRHANDLEs ont leur propre espace de noms se\*'pare\*'
de celui des DESCRIPTEURs.
.IP "ord \s-1EXPR\s0" 8
.IX Item "ord EXPR"
.PD 0
.IP "ord" 8
.IX Item "ord"
.PD
Retourne la valeur nume\*'rique (dans l'encodage 8\-bit natif comme \s-1ASCII\s0, \s-1EBCDIC\s0
ou Unicode) du premier caracte\*`re de \s-1EXPR\s0. Si \s-1EXPR\s0 est omis, utilise
\&\f(CW$_\fR.
.Sp
Voir \*(L"chr\*(R" pour l'ope\*'ration inverse. Voir perlunicode et encoding pour
en savoir plus sur Unicode.
.IP "our \s-1EXPR\s0" 8
.IX Item "our EXPR"
.PD 0
.IP "our \s-1TYPE\s0 \s-1EXPR\s0" 8
.IX Item "our TYPE EXPR"
.IP "our \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "our EXPR : ATTRS"
.IP "our \s-1TYPE\s0 \s-1EXPR\s0 : \s-1ATTRS\s0" 8
.IX Item "our TYPE EXPR : ATTRS"
.PD
Un \f(CW\*(C`our\*(C'\fR de\*'clare les variables liste\*'es comme e\*'tant des variables globales
valides dans la porte\*'e d'un bloc englobant, d'un fichier ou d'un \f(CW\*(C`eval\*(C'\fR. Il a
donc la me\*^me porte\*'e qu'une de\*'claration \*(L"my\*(R" mais ne cre\*'e pas de variable
locale. Si plus d'une valeur est liste\*'e, la liste doit e\*^tre place\*'e entre
parenthe\*`ses. La de\*'claration \f(CW\*(C`our\*(C'\fR n'a aucun effet se\*'mantique a\*` moins que \*(L"use
strict vars\*(R" soit actif auquel cas, cela vous permet d'utiliser les variables
globales de\*'clare\*'es sans les qualifier par un nom de package. (Mais seulement
dans la porte\*'e lexicale de votre de\*'claration \f(CW\*(C`our\*(C'\fR. En cela, il diffe\*`re de
\&\*(L"use vars\*(R" dont la porte\*'e est globale au package.)
.Sp
Un de\*'claration \f(CW\*(C`our\*(C'\fR de\*'clare un variable globale qui sera visible dans toute
la porte\*'e lexicale de cette de\*'claration, me\*^me entre diffe\*'rents packages. Le
package d'appartenance de la variable est de\*'termine\*'e lors de la de\*'claration et
non lors de l'utilisation. Cela signifie que vous aurez les comportements
suivants\ :
.Sp
.Vb 3
\&    package Foo;
\&    our $bar;           # de\*'clare $Foo::bar
\&    $bar = 20;
\&
\&    package Bar;
\&    print $bar;         # affiche 20 (valeur de $Foo:bar)
.Ve
.Sp
De multiples de\*'clarations \f(CW\*(C`our\*(C'\fR sont autorise\*'es dans la me\*^me porte\*'e lexicale
si elles sont dans des packages diffe\*'rents. Si elles sont dans le me\*^me
package, Perl produira un avertissement si vous le lui avez demande\*'.
.Sp
.Vb 4
\&    use warnings;
\&    package Foo;
\&    our $bar;           # de\*'clare $Foo::bar
\&    $bar = 20;
\&
\&    package Bar;
\&    our $bar = 30;      # de\*'clare $Bar::bar
\&    print $bar;         # affiche 30
\&
\&    our $bar;           # e\*'mission d'un avertissement
.Ve
.Sp
Une de\*'claration \f(CW\*(C`our\*(C'\fR peut aussi e\*^tre associer a\*` une liste d'attributs.
.Sp
La se\*'mantique exacte et l'interface de \s-1TYPE\s0 et \s-1ATTRS\s0 sont encore en cours
d'e\*'volution. \s-1TYPE\s0 est actuellement lie\*' a\*` l'utilisation de la directive
\&\f(CW\*(C`fields\*(C'\fR et les attributs (\s-1ATTRS\s0) sont ge\*'re\*'s par la directive \f(CW\*(C`attributes\*(C'\fR
ou, depuis perl 5.8.0, via le module \f(CW\*(C`Attribute::Handlers\*(C'\fR.  Voir
\&\*(L"Variables Prive\*'es via \fImy()\fR\*(R" in perlsub pour plus de de\*'tails ainsi que
fields, attributes et Attribute::Handlers.
.Sp
Actuellement, le seul attribut reconnu par \f(CW\*(C`our()\*(C'\fR est \f(CW\*(C`unique\*(C'\fR qui indique
qu'une seule et unique instance de la variable globale doit e\*^tre utilise\*'e par
tous les interpre\*'teurs que lance le programme dans un environnement
d'interpre\*'teurs multiples. (Le comportement par de\*'faut est que chaque
interpre\*'teur posse\*`de sa propre instance.) Exemples\ :
.Sp
.Vb 3
\&    our @EXPORT : unique = qw(foo);
\&    our %EXPORT_TAGS : unique = (bar => [qw(aa bb cc)]);
\&    our $VERSION : unique = "1.00";
.Ve
.Sp
Notez aussi que cette attribut a pour effet de rendre la variable globale
non-modifiable de\*`s que le premier interpre\*'teur est clone\*' (par exemple lorsque
le premier fil d'exe\*'cution est cre\*'e\*').
.Sp
Un environnement d'interpre\*'teurs multiples peut aussi provenir de l'e\*'mulation
de \fIfork()\fR sur les plateformes Windows ou d'un interpre\*'teur embarque\*' dans une
application multi-fils (multi\-threaded application). L'attribut \f(CW\*(C`unique\*(C'\fR en
fait rien dans tout autre environnement.
.IP "pack \s-1TEMPLATE\s0,LISTE" 8
.IX Item "pack TEMPLATE,LISTE"
Prend une liste de valeurs et les transforme en une chai\*^ne en utilisant les
re\*`gles de\*'crites par \s-1TEMPLATE\s0. La chai\*^ne re\*'sultante est la concate\*'nation des
valeurs converties. Typiquement, chaque valeur convertie aura sa
repre\*'sentation du niveau machine. Par exemple, sur une machine 32\-bit, un
entier converti sera repre\*'sente\*' par une se\*'quence de 4 octets.
.Sp
Le \s-1TEMPLATE\s0 est une se\*'quence de caracte\*`res qui donne l'ordre et le type des
valeurs, de la manie\*`re suivante\ :
.Sp
.Vb 5
\&    a   Une chai\*^ne contenant des donne\*'es binaires quelconques,
\&        e\*'ventuellement comple\*'te\*'e par des caracte\*`res NUL.
\&    A   Un texte (ASCII), comple\*'te\*'e par des blancs.
\&    Z   Une chai\*^ne (ASCII) termine\*'e par un caracte\*`re NUL,
\&        comple\*'te\*' par des caracte\*`res NUL.
\&
\&    b   Une chai\*^ne de bits (en ordre croissant dans chaque octet,
\&        comme pour vec()).
\&    B   Une chai\*^ne de bits (en ordre de\*'croissant dans chaque octet).
\&    h   Une chai\*^ne hexade\*'cimale (chiffres hexade\*'cimaux faibles en premier).
\&    H   Une chai\*^ne hexade\*'cimale (chiffres hexade\*'cimaux forts en premier).
\&
\&    c   La valeur d'un caracte\*`re signe\*'.
\&    C   La valeur d'un caracte\*`re non signe\*'. Ne traite que des octets.
\&        Voir U pour Unicode.
\&
\&    s   La valeur d'un entier court (short) signe\*'
\&    S   La valeur d'un entier court (short) non signe\*'
\&           (Ce 'short' est _exactement_ sur 16 bits ce qui peut
\&            e\*^tre diffe\*'rent de ce qu'un compilateur C local
\&            appelle 'short'. Si vous voulez un short natif, utilisez
\&            le suffixe '!'.)
\&
\&    i   La valeur d'un entier (integer) signe\*'.
\&    I   La valeur d'un entier (integer) non signe\*'.
\&           (Cet 'integer' est _au moins_ sur 32 bits. Sa taille
\&            exact de\*'pend de ce que le compilateur C local appelle 'int'
\&            et peut me\*^me e\*^tre plus long que le 'long' de\*'crit
\&            a\*` l'item suivant.)
\&
\&    l   La valeur d'un entier long (long) signe\*'.
\&    L   La valeur d'un entier long (long) non signe\*'.
\&           (Ce 'long' est _exactement_ sur 32 bits ce qui peut
\&            e\*^tre diffe\*'rent de ce qu'un compilateur C local
\&            appelle 'long'. Si vous voulez un long natif, utilisez
\&            le suffixe '!'.)
\&
\&    n   Un entier court non signe\*' (short) dans l'ordre "re\*'seau" (big\-endian).
\&    N   Un entier long non signe\*' (long) dans l'ordre "re\*'seau" (big\-endian).
\&    v   Un entier court non signe\*' (short) dans l'ordre "VAX" (little\-endian).
\&    V   Un entier long non signe\*' (long) dans l'ordre "VAX" (little\-endian).
\&           (Ces 'shorts' et ces 'longs' font _exactement_
\&            16 et 32 bits respectivement.)
\&
\&    q   Une valeur quad (64\-bit) signe\*'e.
\&    Q   Une valeur quad non signe\*'e.
\&           (Les quads ne sont disponibles que si votre syste\*`me supporte
\&            les entiers 64\-bit _et_ que si Perl a e\*'te\*' compile\*' pour les
\&            accepter. Provoquera une erreur fatale sinon.)
\&
\&    j   Une valeur entie\*`re signe\*'e (un entier interne de Perl, IV)
\&    J   Une valeur entie\*`re non\-signe\*'e (un entier non\-signe\*' de Perl, UV)
\&
\&    f   Un flottant simple pre\*'cision au format natif.
\&    d   Un flottant double pre\*'cision au format natif.
\&
\&    F   Une valeur a\*` virgule flottante en format natif
\&         (un flottant Perl interne, NV).
\&    D   Un flottant long en double pre\*'cision en format natif
\&         (Ce format doit e\*^tre connue de votre syste\*`me _ET_
\&          Perl doit e\*^tre compile\*' pour les reconnai\*^tre.
\&          Produit une erreur fatale sinon.)
\&
\&    p   Un pointeur vers une chai\*^ne termine\*'e par un caracte\*`re NUL.
\&    P   Un pointeur vers une structure (une chai\*^ne de longueur fixe).
\&
\&    u   Une chai\*^ne uuencode\*'e.
\&    U   Un nombre d'un caracte\*`re Unicode. Encode en UTF\-8 en interne
\&        (ou en UTF\-EBCDIC sur les plateformes EBCDIC).
\&
\&    w   Un entier BER compresse\*'. Ses octets repre\*'sentent chacun un entier
\&        non signe\*' en base 128. Les chiffres les plus significatifs viennent
\&        en premier et il y a le moins de chiffres possibles. Le huitie\*`me bit
\&        (le bit de poids fort) est toujours a\*` 1 pour chaque octets sauf
\&        le dernier.
\&
\&    x   Un octet nul.
\&    X   Retour en arrie\*`re d'un octet.
\&    @   Remplissage par des octets nuls jusqu'a\*` une position absolue.
\&    (   De\*'but d'un ()\-groupe.
.Ve
.Sp
Les re\*`gles suivantes s'appliquent\ :
.RS 8
.IP "\(bu" 8
Chaque lettre peut e\*'ventuellement e\*^tre suivie d'un nombre spe\*'cifiant le nombre
de re\*'pe\*'titions. Pour tous les types sauf \f(CW\*(C`a\*(C'\fR, \f(CW\*(C`A\*(C'\fR, \f(CW\*(C`Z\*(C'\fR, \f(CW\*(C`b\*(C'\fR, \f(CW\*(C`B\*(C'\fR, \f(CW\*(C`h\*(C'\fR,
\&\f(CW\*(C`H\*(C'\fR, \f(CW\*(C`@\*(C'\fR, \f(CW\*(C`x\*(C'\fR, \f(CW\*(C`X\*(C'\fR et \f(CW\*(C`P\*(C'\fR, la fonction pack utilisera autant de valeurs
de la liste \s-1LISTE\s0 que ne\*'cessaire. Une \f(CW\*(C`*\*(C'\fR comme valeur de re\*'pe\*'tition demande
a\*` utiliser toutes les valeurs restantes excepte\*' pour \f(CW\*(C`@\*(C'\fR, \f(CW\*(C`x\*(C'\fR et \f(CW\*(C`X\*(C'\fR ou\*`
c'est e\*'quivalent a\*` \f(CW0\fR et pour \f(CW\*(C`u\*(C'\fR ou\*` c'est e\*'quivalent a\*` 1 (ou 45, ce qui
est la me\*^me chose). Le nombre de re\*'pe\*'titions peut e\*'ventuellement e\*^tre entoure\*'
de crochets comme dans \f(CW\*(C`pack 'C[80]', @arr\*(C'\fR.
.Sp
Il est possible de remplacer ce nombre de re\*'pe\*'titions par un template place\*'
entre crochets. C'est alors la longueur en octets de ce template compacte\*' qui
est utilise\*'e comme nombre de re\*'pe\*'titions. Par exemple, \f(CW\*(C`x[L]\*(C'\fR sautera autant
d'octets que le nombre d'octets composant un long\ ; Le template \f(CW\*(C`$x X[$t]
$t\*(C'\fR pourra de\*'compacter deux fois ce que de\*'compactera \f(CW$t\fR. Si le template entre
crochets contient des commandes d'alignement (comme dans \f(CW\*(C`x![d]\*(C'\fR), sa
longueur compacte\*'e sera calcule\*'e en supposant que le de\*'but du template est a\*`
l'alignement maximal.
.Sp
Utilise\*' avec \f(CW\*(C`Z\*(C'\fR, \f(CW\*(C`*\*(C'\fR de\*'clenchera l'ajout d'un octet nul final (donc la
valeur compacte\*'e sera d'un octet plus longue que la longueur (\f(CW\*(C`length\*(C'\fR) de la
valeur initiale).
.Sp
La valeur de re\*'pe\*'tition pour \f(CW\*(C`u\*(C'\fR est interpre\*'te\*'e comme le nombre maximale
d'octets a\*` encoder par ligne produite avec 0 et 1 remplace\*' par 45.
.IP "\(bu" 8
Les types \f(CW\*(C`a\*(C'\fR, \f(CW\*(C`A\*(C'\fR et \f(CW\*(C`Z\*(C'\fR n'utilisent qu'une seule valeur mais la compacte
sur la longueur spe\*'cifie\*'e en la comple\*'tant e\*'ventuellement par des espaces ou
des caracte\*`res \s-1NUL\s0. Lors du de\*'compactage, \f(CW\*(C`A\*(C'\fR supprime les espaces et les
caracte\*`res \s-1NUL\s0 finaux, \f(CW\*(C`Z\*(C'\fR supprime tout ce qui suit le premier caracte\*`re \s-1NUL\s0
alors que \f(CW\*(C`a\*(C'\fR laisse la valeur comple\*`te. Lors du compactage, \f(CW\*(C`a\*(C'\fR et \f(CW\*(C`Z\*(C'\fR
sont e\*'quivalents.
.Sp
Si la valeur a\*` compacter est trop longue, elle est tronque\*'e. Si elle est trop
longue et qu'une longueur explicite \f(CW$count\fR est fournie, \f(CW\*(C`Z\*(C'\fR compactera
uniquement \f(CW\*(C`$count\-1\*(C'\fR octets suivi d'un octet nul. Donc, \f(CW\*(C`Z\*(C'\fR compacte un
caracte\*`re nul final en toutes circonstances.
.IP "\(bu" 8
De la me\*^me manie\*`re, les types \f(CW\*(C`b\*(C'\fR et \f(CW\*(C`B\*(C'\fR remplissent la chai\*^ne compacte\*'e
avec autant de bits que demande\*'s. Chaque octet du champ d'entre\*'e de \fIpack()\fR
produira 1 bit dans le re\*'sultat. Chaque bit re\*'sultant est le bit le moins
significatif de l'octet d'entre\*'e (i.e. \f(CW\*(C`ord($octet)%2\*(C'\fR). En particulier, les
octets \f(CW"0"\fR et \f(CW"1"\fR produisent les bits 0 et 1 exactement comme le font
\&\f(CW"\e0"\fR et \f(CW"\e1"\fR.
.Sp
En partant du de\*'but de la chai\*^ne d'entre\*'e de \fIpack()\fR, chaque 8\-uplet d'octets
est converti en un octet de sortie. Avec le format \f(CW\*(C`b\*(C'\fR, le premier octet du
8\-uplet de\*'termine le bit le moins significatif de l'octet alors qu'avec le
format \f(CW\*(C`B\*(C'\fR, il de\*'termine le bit le plus significatif.
.Sp
Si la longueur de la chai\*^ne d'entre\*'e n'est pas exactement divisible par 8, le
reste est compacte\*' comme si la chai\*^ne d'entre\*'e e\*'tait comple\*'te\*'e par des octets
nuls a\*` la fin. De manie\*`re similaire, lors du de\*'compactage, les bits
\&\*(L"supple\*'mentaires\*(R" sont ignore\*'s.
.Sp
Si la chai\*^ne d'entre\*'e de \fIpack()\fR est plus longue que ne\*'cessaire, les octets en
trop sont ignore\*'s. Une valeur de re\*'pe\*'tition de \f(CW\*(C`*\*(C'\fR demande a\*` utiliser tous
les octets du champ d'entre\*'e. Lors du de\*'compactage, les bits sont convertis en
une chai\*^ne de \f(CW"0"\fR et de \f(CW"1"\fR.
.IP "\(bu" 8
\&\f(CW\*(C`h\*(C'\fR et \f(CW\*(C`H\*(C'\fR compactent une chai\*^ne hexade\*'cimale (par groupe de 4\-bit
repre\*'sentant un chiffre hexade\*'cimale 0\-9a\-f).
.Sp
Chaque octet du champ d'entre\*'e de \fIpack()\fR ge\*'ne\*`re 4 bits du re\*'sultat. Pour les
octets non alphabe\*'tiques, le re\*'sultat est base\*' sur les 4 bits les moins
significatifs de l'octet conside\*'re\*' (i.e. sur \f(CW\*(C`ord($octet)%16\*(C'\fR). En
particulier, les octets \f(CW"0"\fR et \f(CW"1"\fR ge\*'ne\*`rent 0 et 1 comme le font les
octets \f(CW"\e0"\fR et \f(CW"\e1"\fR. Pour les octets \f(CW"a".."f"\fR et \f(CW"A".."F"\fR, le
re\*'sultat est compatible avec les chiffres hexade\*'cimaux habituels et donc
\&\f(CW"a"\fR et \f(CW"A"\fR ge\*'ne\*`rent tous les deux le groupe de 4 bits \f(CW\*(C`0xa==10\*(C'\fR. Le
re\*'sultat pour les octets \f(CW"g".."z"\fR et \f(CW"G".."Z"\fR n'est pas clairement
de\*'fini.
.Sp
En partant du de\*'but de la chai\*^ne d'entre\*'e de \fIpack()\fR, chaque paire d'octets est
convertie en 1 octet de sortie. Avec le format \f(CW\*(C`h\*(C'\fR, le premier octet de la
paire de\*'termine les 4 bits les moins significatifs de l'octet re\*'sultant alors
qu'avec le format \f(CW\*(C`H\*(C'\fR, il de\*'termine les 4 bits les plus significatifs.
.Sp
Si la longueur de la chai\*^ne d'entre\*'e n'est pas paire, \fIpack()\fR se comportera
comme si un octet nul avait e\*'te\*' ajoute\*' a\*` la fin. De manie\*`re similaire, lors du
de\*'compactage (par \fIunpack()\fR), les groupes de 4 bits supple\*'mentaires sont
ignore\*'s.
.Sp
Si la chai\*^ne d'entre\*'e de \fIpack()\fR est plus longue que ne\*'cessaire, les octets
supple\*'mentaires sont ignore\*'s. Une valeur de re\*'pe\*'tition de \f(CW\*(C`*\*(C'\fR demande a\*`
utiliser tous les octets de la chai\*^ne d'entre\*'e. Lors du de\*'compactage, les bits
sont convertis en une chai\*^ne de chiffres hexade\*'cimaux.
.IP "\(bu" 8
Le type \f(CW"p"\fR compactera une chai\*^ne termine\*'e par un caracte\*`re \s-1NUL\s0 dont on
donne le pointeur. Il est de votre responsabilite\*' de vous assurer que la
chai\*^ne n'est pas une valeur temporaire (qui pourrait e\*^tre de\*'salloue\*'e avant
l'utilisation de la valeur compacte\*'e). Le type \f(CW\*(C`P\*(C'\fR compactera une structure
de la taille indique\*' par la longueur. Un pointeur \s-1NULL\s0 est cre\*'e\*' si la valeur
correspondant a\*` \f(CW"p"\fR ou \f(CW"P"\fR est \f(CW\*(C`undef\*(C'\fR. Idem pour \fIunpack()\fR.
.IP "\(bu" 8
Le caracte\*`re \f(CW\*(C`/\*(C'\fR dans \s-1TEMPLATE\s0 autorise le compactage et le de\*'compactage de
chai\*^ne donc la repre\*'sentation compacte est la longueur en octets suivie de la
chai\*^ne elle\-me\*^me. Vous e\*'crivez \fIlongueur-item\fR\f(CW\*(C`/\*(C'\fR\fIchaine-item\fR.
.Sp
La \fIlongueur-item\fR peut e\*^tre n'importe quelle lettre d'un template \f(CW\*(C`pack\*(C'\fR et
elle repre\*'sente comment cette valeur de longueur est compacte\*'e. Les plus
utilise\*'es sont les longueurs entie\*`res comme \f(CW\*(C`n\*(C'\fR (pour des chai\*^nes Java), \f(CW\*(C`w\*(C'\fR
(pour \s-1ASN\s0.1 ou \s-1SNMP\s0) et \f(CW\*(C`N\*(C'\fR (pour les \s-1XDR\s0 de Sun).
.Sp
\&\fIlongueur-item\fR peut e\*^tre n'importe quel type de lettre d'un \s-1TEMPLATE\s0 \f(CW\*(C`pack\*(C'\fR
et de\*'crit la manie\*`re dont la longueur est compacte\*'e. Les plus courantes sont
\&\f(CW\*(C`n\*(C'\fR (pour les chai\*^nes Java), \f(CW\*(C`w\*(C'\fR (pour \s-1ASN\s0.1 ou \s-1SNMP\s0) et \f(CW\*(C`N\*(C'\fR (pour les \s-1XDR\s0
de \s-1SUN\s0).
.Sp
\&\fIchaine-item\fR doit e\*^tre, s'il est pre\*'sent, \f(CW"A*"\fR, \f(CW"a*"\fR ou \f(CW"Z*"\fR. Pour
le de\*'compactage (via \fIunpack()\fR), la longueur de la chai\*^ne est celle obtenue par
\&\fIlongueur-item\fR mais si vous spe\*'cifiez '*', elle sera ignore\*'e.
.Sp
.Vb 3
\&    unpack 'C/a', "\e04Gurusamy";        donne 'Guru'
\&    unpack 'a3/A* A*', '007 Bond  J ';  donne (' Bond','J')
\&    pack 'n/a* w/a*','hello,','world';  donne "\e000\e006hello,\e005world"
.Ve
.Sp
\&\fIlongueur-item\fR n'est pas retourne\*' explicitement par \fIunpack()\fR.
.Sp
L'ajout d'un compteur de re\*'pe\*'tition a\*` la lettre \fIlongueur-item\fR est inutile
sauf si cette lettre est \f(CW\*(C`A\*(C'\fR, \f(CW\*(C`a\*(C'\fR ou \f(CW\*(C`Z\*(C'\fR. Le compactage avec une
\&\fIlongueur-item\fR spe\*'cifie\*'e par \f(CW\*(C`a\*(C'\fR ou \f(CW\*(C`Z\*(C'\fR peut introduire des caracte\*`res
\&\f(CW"\e000"\fR que Perl ne conside\*'rera pas comme le\*'gal dans une chai\*^ne nume\*'rique.
.IP "\(bu" 8
Les types entiers \f(CW\*(C`s\*(C'\fR, \f(CW\*(C`S\*(C'\fR, \f(CW\*(C`l\*(C'\fR et \f(CW\*(C`L\*(C'\fR peuvent e\*^tre imme\*'diatement suivi
d'un suffixe \f(CW\*(C`!\*(C'\fR pour indiquer des shorts ou des longs natifs \*(-- comme vous
pourrez le voir dans l'exemple suivant, \f(CW\*(C`l\*(C'\fR ne signifie pas exactement 32
bits puisque le long natif (tel qu'il est vu par le compilateur C natif) peut
e\*^tre plus long. C'est une pre\*'occupation principalement sur des plates-formes
64\-bit. Vous pouvez voir si l'utilisation de \f(CW\*(C`!\*(C'\fR fait une diffe\*'rence en
faisant\ :
.Sp
.Vb 2
\&        print length(pack("s")), " ", length(pack("s!")), "\en";
\&        print length(pack("l")), " ", length(pack("l!")), "\en";
.Ve
.Sp
\&\f(CW\*(C`i!\*(C'\fR et \f(CW\*(C`I!\*(C'\fR fonctionne aussi mais uniquement dans un souci de comple\*'tude
puisqu'ils sont totalement identique a\*` \f(CW\*(C`i\*(C'\fR et \f(CW\*(C`I\*(C'\fR.
.Sp
La taille re\*'elle (en octets) des short, int, long et long long natifs sur la
plate-forme ou\*` Perl a e\*'te\*' installe\*' est aussi disponible via Config\ :
.Sp
.Vb 5
\&       use Config;
\&       print $Config{shortsize},    "\en";
\&       print $Config{intsize},      "\en";
\&       print $Config{longsize},     "\en";
\&       print $Config{longlongsize}, "\en";
.Ve
.Sp
(\f(CW$Config{longlongsize}\fR sera inde\*'fini (undef) si votre syste\*`me ne supporte
pas les long long).
.IP "\(bu" 8
Les formats entiers \f(CW\*(C`s\*(C'\fR, \f(CW\*(C`S\*(C'\fR, \f(CW\*(C`i\*(C'\fR, \f(CW\*(C`I\*(C'\fR, \f(CW\*(C`l\*(C'\fR, \f(CW\*(C`L\*(C'\fR, \f(CW\*(C`j\*(C'\fR et \f(CW\*(C`J\*(C'\fR sont par
construction non portables entre processeurs et entre syste\*`mes d'exploitation
puisqu'ils respectent l'ordre (big\-endian ou little\-endian) natif. Par exemple
l'entier sur 4 octets 0x12345678 (305419896 en de\*'cimal) devrait e\*^tre
nativement ordonne\*' (stocke\*' et manipule\*' par les registres de la \s-1CPU\s0) en octets
comme\ :
.Sp
.Vb 2
\&        0x12 0x34 0x56 0x78     # ordre little\-endian
\&        0x78 0x56 0x34 0x12     # ordre big\-endian
.Ve
.Sp
A\*` la base, les \s-1CPU\s0 des familles Intel et \s-1VAX\s0 sont little-endian alors que tous
les autres, par exemple Motorola m68k/88k, \s-1PPC\s0, Sparc, \s-1HP\s0 \s-1PA\s0, Power et Cray,
sont big\-endian. Les puces Alpha et \s-1MIPS\s0 peuvent e\*^tre les deux\ : Digital
les utilise(ait) en mode little-endian\ ; SGI/Cray les utilise en mode
big\-endian.
.Sp
Les noms \*(L"big\-endian\*(R" et \*(L"little\-endian\*(R" sont des re\*'fe\*'rences au grand
classique \*(L"Les voyages de Gulliver\*(R" (au travers de l'article \*(L"On Holy Wars and
a Plea for Peace\*(R" par Danny Cohen, \s-1USC/ISI\s0 \s-1IEN\s0 137, April 1, 1980) et donc aux
habitudes des mangeurs d'oeufs Lilliputiens.
.Sp
Quelques syste\*`mes peuvent me\*^me avoir un ordre des octets encore plus bizarre
tel que\ :
.Sp
.Vb 2
\&        0x56 0x78 0x12 0x34
\&        0x34 0x12 0x78 0x56
.Ve
.Sp
Vous pouvez voir les pre\*'fe\*'rences de votre syste\*`mes par
.Sp
.Vb 2
\&        print join(" ", map { sprintf "%#02x", $_ }
\&                            unpack("C*",pack("L",0x12345678))), "\en";
.Ve
.Sp
L'ordre des octets de la plate-forme ou\*` Perl a e\*'te\*' installe\*' est aussi
disponible via Config\ :
.Sp
.Vb 2
\&        use Config;
\&        print $Config{byteorder}, "\en";
.Ve
.Sp
Les ordres d'octets \f(CW'1234'\fR et \f(CW'12345678'\fR sont little-endian alors que
\&\f(CW'4321'\fR et \f(CW'87654321'\fR sont big\-endian.
.Sp
Si vous voulez des entiers compacte\*'s portables, il vous faut utiliser les
formats \f(CW\*(C`n\*(C'\fR, \f(CW\*(C`N\*(C'\fR, \f(CW\*(C`v\*(C'\fR et \f(CW\*(C`V\*(C'\fR puisque leur taille et l'ordre de leurs
octets sont connus. Voir aussi perlport.
.IP "\(bu" 8
Les nombres re\*'els (simple et double pre\*'cision) sont uniquement au format natif
de la machine. A\*` cause de la multiplicite\*' des formats existants pour les
flottants et du manque d'une repre\*'sentation \*(L"re\*'seau\*(R" standard, aucune
possibilite\*' d'e\*'change n'est propose\*'e. Cela signifie que les donne\*'es re\*'elles
compresse\*'es sur une machine peuvent ne pas e\*^tre lisibles par une autre machine
\&\*(-- me\*^me si elles utilisent toutes deux l'arithme\*'tique flottante \s-1IEEE\s0 (puisque
l'ordre des octets de la repre\*'sentation me\*'moire ne fait pas partie des
spe\*'cifications \s-1IEEE\s0). Voir aussi perlport.
.Sp
Sachez que Perl utilise des doubles en interne pour tous les calculs
nume\*'riques et qu'une conversion de double vers float puis retour vers double
ame\*`ne a\*` une perte de pre\*'cision (i.e., \f(CW\*(C`unpack("f", pack("f", $foo)\*(C'\fR) est
ge\*'ne\*'ralement diffe\*'rent de \f(CW$foo\fR).
.IP "\(bu" 8
Vous devez re\*'aliser vous\-me\*^me tous les alignements et les remplissages
ne\*'cessaires en inse\*'rant par exemple assez de \f(CW\*(C`x\*(C'\fR lors du compactage. \fIpack()\fR
et \fIunpack()\fR n'ont aucun moyen de savoir d'ou\*` viennent et ou\*` iront les octets. Par
conse\*'quent, \fIpack()\fR (et \fIunpack()\fR) ge\*`re leurs entre\*'e et leurs sortie comme des
se\*'quences d'octets a\*` plat.
.IP "\(bu" 8
Un ()\-groupe est un sous-TEMPLATE entoure\*' de parenthe\*`ses. Un tel groupe peut
e\*^tre re\*'pe\*'te\*' soit en le postfixant par un compteur de re\*'pe\*'tition soit en le
pre\*'fixant par un compteur via le caracte\*`re \f(CW\*(C`/\*(C'\fR.
.IP "\(bu" 8
\&\f(CW\*(C`x\*(C'\fR et \f(CW\*(C`X\*(C'\fR accepte le modificateur \f(CW\*(C`!\*(C'\fR. Dans ce cas, ils agissent comme des
commandes d'alignement\ : ils sautent vers la position la plus proche
aligne\*'e sur un multiple de \f(CW\*(C`count\*(C'\fR octets. Par exemple, pour compacter ou
de\*'compacter la structure C \f(CW\*(C`struct {char c; double d; char cc[2]}\*(C'\fR, on peut
utiliser le \s-1TEMPLATE\s0 \f(CW\*(C`C\ x![d]\ d\ C[2]\*(C'\fR\ ; Cela garantit que les doubles
seront aligne\*'s sur la taille d'un double.
.Sp
Pour les commandes d'alignement un \f(CW\*(C`count\*(C'\fR de 0 est e\*'quivalent a\*` un \f(CW\*(C`count\*(C'\fR
de 1\ ; Et tous les deux sont sans effet.
.IP "\(bu" 8
Dans \s-1TEMPLATE\s0, un commentaire commence par \f(CW\*(C`#\*(C'\fR et se termine en fin de ligne.
.IP "\(bu" 8
Si \s-1TEMPLATE\s0 ne\*'cessite plus d'argument que ceux re\*'ellement fournis, \fIpack()\fR
supposera que des arguments \f(CW""\fR supple\*'mentaires sont fournis. Si \s-1TEMPLATE\s0
ne\*'cessite moins d'arguments que ceux re\*'ellement fournis a\*` \fIpack()\fR, les
arguments en trop sont ignore\*'s.
.RE
.RS 8
.Sp
Exemples :
.Sp
.Vb 6
\&    $foo = pack("CCCC",65,66,67,68);
\&    # foo eq "ABCD"
\&    $foo = pack("C4",65,66,67,68);
\&    # me\*^me chose
\&    $foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
\&    # me\*^me chose avec des lettres cercle\*'es Unicode
\&
\&    $foo = pack("ccxxcc",65,66,67,68);
\&    # foo eq "AB\e0\e0CD"
\&
\&    # note : les exemples pre\*'ce\*'dents utilisant "C" et "c" ne sont
\&    # corrects que sus des syste\*`mes ACSII ou de\*'rive\*'s comme ISO Latin 1
\&    # ou UTF\-8. En EBCDIC, le premier exemple devrait e\*^tre
\&    # $foo = pack("CCCC",193,194,195,196);
\&
\&    $foo = pack("s2",1,2);
\&    # "\e1\e0\e2\e0" sur little\-endian
\&    # "\e0\e1\e0\e2" sur big\-endian
\&
\&    $foo = pack("a4","abcd","x","y","z");
\&    # "abcd"
\&
\&    $foo = pack("aaaa","abcd","x","y","z");
\&    # "axyz"
\&
\&    $foo = pack("a14","abcdefg");
\&    # "abcdefg\e0\e0\e0\e0\e0\e0\e0"
\&
\&    $foo = pack("i9pl", gmtime);
\&    # une vraie struct tm (sur mon syste\*`me en tous cas)
\&
\&    $utmp_template = "Z8 Z8 Z16 L";
\&    $utmp = pack($utmp_template, @utmp1);
\&    # une struct utmp (BSD\-isme)
\&
\&    @utmp2 = unpack($utmp_template, $utmp);
\&    # "@utmp1" eq "@utmp2"
\&
\&    sub bintodec {
\&        unpack("N", pack("B32", substr("0" x 32 . shift, \-32)));
\&    }
\&
\&    $foo = pack('sx2l', 12, 34);
\&    # short 12, two zero bytes padding, long 34
\&    $bar = pack('s@4l', 12, 34);
\&    # short 12, zero fill to position 4, long 34
\&    # $foo eq $bar
.Ve
.Sp
La me\*^me valeur de \s-1TEMPLATE\s0 peut ge\*'ne\*'ralement e\*^tre utilise\*'e avec la fonction
\&\fIunpack()\fR.
.RE
.IP "package" 8
.IX Item "package"
.PD 0
.IP "package \s-1NAMESPACE\s0" 8
.IX Item "package NAMESPACE"
.PD
De\*'clare l'unite\*' de compilation comme faisant partie de l'espace de nommage
\&\s-1NAMESPACE\s0. La porte\*'e de la de\*'claration package (N.d.t\ : paquetage en franc\*,ais)
commence a\*` la de\*'claration elle\-me\*^me et se termine a\*` la fin du bloc, du fichier
ou de l'eval englobant (c'est la me\*^me porte\*'e que l'ope\*'rateur \f(CW\*(C`local()\*(C'\fR). Tout
identificateur dynamique non qualifie\*' a\*` venir sera dans cet espace de
nommage. Une instruction package n'affecte que les variables dynamiques \*(--
me\*^me celles sur lesquelles vous utilisez \f(CW\*(C`local()\*(C'\fR \*(-- et \fInon\fR les variables
lexicales cre\*'e\*'es par \f(CW\*(C`my()\*(C'\fR. C'est typiquement la premie\*`re de\*'claration dans
un fichier inclus par les ope\*'rateurs \f(CW\*(C`require\*(C'\fR ou \f(CW\*(C`use\*(C'\fR. Vous pouvez
basculer vers un me\*^me paquetage en plusieurs endroits\ ; cela ne fait que
changer la table de symboles utilise\*'e par le compilateur pour la suite du
bloc. Vous pouvez re\*'fe\*'rencer des variables ou des descripteurs de fichiers
d'autres packages en pre\*'fixant l'identificateur par le nom du package suivi de
deux fois deux points\ : \f(CW$Package::Variable\fR. Si le nom de paquetage est
vide, c'est la paquetage \f(CW\*(C`main\*(C'\fR qui est utilise\*'. Donc \f(CW$::sail\fR est
e\*'quivalent a\*` \f(CW$main::sail\fR (et aussi a\*` \f(CW$main'sail\fR qui peut encore se voir
dans du vieux code)..
.Sp
Si \s-1NAMESPACE\s0 est omis alors il n'y a pas de paquetage courant et tous les
identificateurs doivent e\*^tre soit comple\*`tement qualifie\*'s soit lexicaux. Mais
nous vous de\*'conseillons fortement d'utiliser cette fonctionnalite\*'. Son
utilisation peut amener a\*` des comportements inattendus et peut me\*^me faire
planter certaines versions de Perl. Cette fonctionnalite\*' est de\*'pre\*'cie\*'e et sera
supprime\*'e dans une version ulte\*'rieure.
.Sp
Voir \*(L"Paquetages\*(R" in perlmod pour des plus amples informations a\*` propos des
paquetages (packages), des modules et des classes. Voir perlsub pour tous
les proble\*`mes de porte\*'e.
.IP "pipe \s-1READHANDLE\s0,WRITEHANDLE" 8
.IX Item "pipe READHANDLE,WRITEHANDLE"
Ouvre une paire de tubes (pipe) exactement comme l'appel syste\*`me
correspondant. Remarquez qu'en faisant une boucle de tubes entre plusieurs
processus vous risquez un inter-blocage (deadlock) a\*` moins d'y faire tre\*`s
attention. De plus, sachez que les tubes de Perl utilisent des tampons
d'entre\*'e/sortie. Donc, selon les applications, vous aurez peut\-e\*^tre a\*`
positionner correctement \f(CW$|\fR pour vider vos \s-1WRITEHANDLE\s0 apre\*`s chaque
commande.
.Sp
Voir IPC::Open2, IPC::Open3 et \*(L"Communication Bidirectionnelle
avec un autre Processus\*(R" in perlipc pour des exemples sur tout c\*,a.
.Sp
Sur les syste\*`mes qui supportent le drapeau fermeture\-a\*`\-l\-exe\*'cution
(close\-on\-exec) sur les fichiers, ce drapeau sera positionne\*' pour de nouveaux
descripteurs de fichier en fonction de la valeur de $^F. Voir \*(L"$^F\*(R" in perlvar.
.IP "pop \s-1TABLEAU\s0" 8
.IX Item "pop TABLEAU"
.PD 0
.IP "pop" 8
.IX Item "pop"
.PD
De\*'pile et retourne la dernie\*`re valeur du tableau \s-1TABLEAU\s0. La taille du tableau
est diminue\*' d'une unite\*'. Cette commande a le me\*^me effet que\ :
.Sp
.Vb 1
\&    $TABLEAU[$#TABLEAU\-\-]
.Ve
.Sp
Si le tableau est vide, c'est la valeur undef qui est retourne\*'e (cela peut
arriver dans d'autres cas aussi). Si \s-1TABLEAU\s0 est omis, pop de\*'pilera soit le
tableau \f(CW@ARGV\fR dans le programme principale soit \f(CW@_\fR dans les subroutines,
exactement comme \f(CW\*(C`shift()\*(C'\fR.
.IP "pos \s-1SCALAIRE\s0" 8
.IX Item "pos SCALAIRE"
.PD 0
.IP "pos" 8
.IX Item "pos"
.PD
Retourne l'offset (l'index du caracte\*`re dans la chai\*^ne) ou\*` s'est arre\*^te\*' la
dernie\*`re recherche \f(CW\*(C`m//g\*(C'\fR sur la variable \s-1SCALAIRE\s0 spe\*'cifie\*'e (s'appliquera a\*`
\&\f(CW$_\fR si la variable \s-1SCALAIRE\s0 n'est pas spe\*'cifie\*'e). Peut e\*^tre utilise\*' pour
modifier cette offset. Une telle modification influe aussi sur l'assertion de
longueur nulle \f(CW\*(C`\eG\*(C'\fR dans les expressions rationnelles. Voir perlre et
perlop.
.IP "print \s-1DESCRIPTEUR\s0 \s-1LISTE\s0" 8
.IX Item "print DESCRIPTEUR LISTE"
.PD 0
.IP "print \s-1LISTE\s0" 8
.IX Item "print LISTE"
.IP "print" 8
.IX Item "print"
.PD
Affiche une chai\*^ne ou une liste de chai\*^nes. Retourne true (vrai) en cas de
succe\*`s. \s-1DESCRIPTEUR\s0 peut e\*^tre une variable scalaire auquel cas cette variable
contiendra le nom ou la re\*'fe\*'rence du \s-1DESCRIPTEUR\s0 et donc introduira un niveau
d'indirection supple\*'mentaire. (\s-1REMARQUE\s0\ : si \s-1DESCRIPTEUR\s0 est une variable et
que l'e\*'le\*'ment syntaxique qui suit est un terme, il peut e\*^tre interpre\*'te\*'
accidentellement comme un ope\*'rateur a\*` moins d'ajouter un \f(CW\*(C`+\*(C'\fR ou de mettre des
parenthe\*`ses autour des arguments.) Si aucun \s-1DESCRIPTEUR\s0 n'est spe\*'cifie\*', affichera
par de\*'faut sur la sortie standard (ou le dernier canal de sortie se\*'lectionne\*'
\&\*(-- voir \*(L"select\*(R"). Si la liste \s-1LISTE\s0 est elle aussi omise, affichera \f(CW$_\fR
sur le canal de sortie courant. Pour utiliser un autre canal que \s-1STDOUT\s0 comme
canal de sortie par de\*'faut, utilisez l'ope\*'ration select. La valeur courante de
\&\f(CW$,\fR (si elle existe) est affiche\*'e entre chaque item de \s-1LISTE\s0. Remarquez
qu'e\*'tant donne\*' que print utilise une liste (\s-1LISTE\s0), tout ce qui est dans \s-1LISTE\s0
est e\*'value\*' dans un contexte de liste et, en particulier, toutes les
expressions e\*'value\*'es dans les subroutines appele\*'es le seront dans un contexte
de liste. Faites aussi attention de ne pas faire suivre le mot\-cle\*' print par
une parenthe\*`se ouvrante a\*` moins de vouloir clore la liste de ses arguments a\*`
la parenthe\*`se fermante correspondante \*(-- sinon pre\*'fixez votre parenthe\*`se par
un \f(CW\*(C`+\*(C'\fR ou entourez tous les arguments par des parenthe\*`ses.
.Sp
Notez que si vous stockez vos \s-1DESCRIPTEUR\s0 dans un tableau (ou quelque chose
qui ne\*'cessite une expression), vous devrez utiliser un bloc qui retourne une
valeur\ :
.Sp
.Vb 2
\&    print { $files[$i] } "stuff\en";
\&    print { $OK ? STDOUT : STDERR } "stuff\en";
.Ve
.IP "printf \s-1DESCRIPTEUR\s0 \s-1FORMAT\s0, \s-1LISTE\s0" 8
.IX Item "printf DESCRIPTEUR FORMAT, LISTE"
.PD 0
.IP "printf \s-1FORMAT\s0, \s-1LISTE\s0" 8
.IX Item "printf FORMAT, LISTE"
.PD
E\*'quivalent a\*` \f(CW\*(C`print DESCRIPTEUR sprintf(FORMAT, LISTE)\*(C'\fR sauf que \f(CW\*(C`$\e\*(C'\fR (le
se\*'parateur d'enregistrements en sortie) n'est pas ajoute\*'. Le premier argument
de la liste sera interpre\*'te\*' comme le format de \f(CW\*(C`printf()\*(C'\fR. Voir \f(CW\*(C`sprintf\*(C'\fR
pour les explications concernant le format. Si \f(CW\*(C`use locale\*(C'\fR
est actif, le caracte\*`re utilise\*' comme se\*'parateur de\*'cimal pour les nombres
re\*'els sera de\*'pendant de la valeur de locale spe\*'cifie\*'e dans \s-1LC_NUMERIC\s0. Voir
perllocale.
.Sp
Ne tombez pas de le pie\*`ge d'utiliser \f(CW\*(C`printf()\*(C'\fR alors qu'un simple \f(CW\*(C`print()\*(C'\fR
suffirait. \f(CW\*(C`print()\*(C'\fR est plus efficace et moins sujet a\*` erreur.
.IP "prototype \s-1FONCTION\s0" 8
.IX Item "prototype FONCTION"
Retourne, sous forme de chai\*^ne, le prototype d'une fonction (ou \f(CW\*(C`undef\*(C'\fR si la
fonction n'a pas de prototype). \s-1FONCTION\s0 est une re\*'fe\*'rence ou le nom de la
fonction dont on veut retrouver le prototype.
.Sp
Si \s-1FONCTION\s0 est une chai\*^ne commenc\*,ant par \f(CW\*(C`CORE::\*(C'\fR, la suite de la chai\*^ne se
re\*'fe\*`re au nom d'une fonction interne de Perl. Si la fonction interne n'est pas
\&\fIrede\*'finissable\fR (par exemple \f(CW\*(C`qw//\*(C'\fR) ou si ses arguments ne peuvent
s'exprimer sous forme de prototype (par exemple \f(CW\*(C`system()\*(C'\fR) \- en d'autres
termes, si la fonction interne ne se comporte pas comme une fonction Perl \- la
fonction prototype retournera \f(CW\*(C`undef\*(C'\fR. Sinon, c'est la chai\*^ne qui de\*'crit le
prototype qui est retourne\*'e.
.IP "push \s-1TABLEAU\s0,LISTE" 8
.IX Item "push TABLEAU,LISTE"
Traite \s-1TABLEAU\s0 comme une pile et empile les valeurs de la liste \s-1LISTE\s0 a\*` la fin
du tableau \s-1TABLEAU\s0. La longueur de \s-1TABLEAU\s0 est augmente\*'e de la longueur de la
liste \s-1LISTE\s0. Cela a le me\*^me effet que\ :
.Sp
.Vb 3
\&    for $value (LISTE) {
\&        $TABLEAU[++$#TABLEAU] = $value;
\&    }
.Ve
.Sp
mais en plus efficace. Retourne le nouveau nombre d'e\*'le\*'ments du tableau.
.IP "q/CHAINE/" 8
.IX Item "q/CHAINE/"
.PD 0
.IP "qq/CHAINE/" 8
.IX Item "qq/CHAINE/"
.IP "qr/CHAINE/" 8
.IX Item "qr/CHAINE/"
.IP "qx/CHAINE/" 8
.IX Item "qx/CHAINE/"
.IP "qw/CHAINE/" 8
.IX Item "qw/CHAINE/"
.PD
Guillemets/Apostrophes ge\*'ne\*'ralise\*'es. Voir perlop.
.IP "quotemeta \s-1EXPR\s0" 8
.IX Item "quotemeta EXPR"
.PD 0
.IP "quotemeta" 8
.IX Item "quotemeta"
.PD
Retourne la valeur de \s-1EXPR\s0 avec tous les caracte\*`res non alphanume\*'riques
pre\*'ce\*'de\*'s par un backslash (une barre oblique inverse). (Tous les caracte\*`res
non reconnus par \f(CW\*(C`/[A\-Za\-z_0\-9]/\*(C'\fR seront pre\*'ce\*'de\*'s d'un backslash quels que
soient les re\*'glages des locale). C'est la fonction interne qui imple\*'mente la
se\*'quence d'e\*'chappement \f(CW\*(C`\eQ\*(C'\fR dans les chai\*^nes entre guillemets.
.Sp
Si \s-1EXPR\s0 est omis, s'appliquera a\*` \f(CW$_\fR.
.IP "rand \s-1EXPR\s0" 8
.IX Item "rand EXPR"
.PD 0
.IP "rand" 8
.IX Item "rand"
.PD
Retourne un nombre fractionnaire ale\*'atoire plus grand ou e\*'gal a\*` \f(CW0\fR et plus
petit que la valeur de \s-1EXPR\s0 (la valeur de \s-1EXPR\s0 devrait e\*^tre positive). A\*`
de\*'faut de \s-1EXPR\s0, c'est \f(CW1\fR qui est utilise\*' comme borne. Actuellement, si \s-1EXPR\s0
vaut \f(CW0\fR, c'est aussi un cas spe\*'cial qui est e\*'quivalent a\*` un appel avec \f(CW1\fR
\&\- ceci n'est documente\*' que depuis la version 5.8.0 de perl et peut changer
dans des futures versions de perl. \f(CW\*(C`rand()\*(C'\fR appelle automatiquement \f(CW\*(C`srand()\*(C'\fR
sauf cela a de\*'ja\*` e\*'te\*' fait. Voir aussi \f(CW\*(C`srand()\*(C'\fR.
.Sp
(Remarque\ : si votre fonction rand retourne re\*'gulie\*`rement des nombres trop
grands ou trop petits alors votre version de Perl a probablement e\*'te\*' compile\*'e
avec une valeur errone\*'e pour \s-1RANDBITS\s0.)
.IP "read \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR,OFFSET" 8
.IX Item "read DESCRIPTEUR,SCALAIRE,LONGUEUR,OFFSET"
.PD 0
.IP "read \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR" 8
.IX Item "read DESCRIPTEUR,SCALAIRE,LONGUEUR"
.PD
Essaye de lire \s-1LONGUEUR\s0 \fIcaracte\*`res\fR depuis le \s-1DESCRIPTEUR\s0 spe\*'cifie\*' et les
stocke dans la variable \s-1SCALAIRE\s0. Retourne le nombre de caracte\*`res re\*'ellement
lus, \f(CW0\fR a\*` la fin du fichier ou undef si une erreur a lieu. La taille de la
variable \s-1SCALAIRE\s0 augmentera ou diminuera pour atteindre la taille exacte de
ce qui est lu. Un \s-1OFFSET\s0 (de\*'calage) peut e\*^tre spe\*'cifie\*' pour placer les donne\*'es
lues ailleurs qu'au de\*'but de la chai\*^ne. Cette fonction est imple\*'mente\*'e par des
appels a\*` la fonction \fIfread()\fR de Perl ou du syste\*`me. Pour obtenir un ve\*'ritable
appel syste\*`me \fIread\fR\|(2), voir \f(CW\*(C`sysread()\*(C'\fR.
.Sp
Notez que l'on parle bien de \fIcaracte\*`res\fR\ : selon l'e\*'tat du \s-1DESCRIPTEUR\s0,
ce seront soit des octets (8\-bit) soit des caracte\*`res qui seront lus. Par
de\*'faut tous les DESCRIPTEURs ope\*`rent sur des octets mais, par exemple, si un
\&\s-1DESCRIPTEUR\s0 a e\*'te\*' ouvert avec le filtre d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR (voir
\&\*(L"open\*(R" et la directive \f(CW\*(C`open\*(C'\fR dans open) alors les entre\*'es/sorties se
feront sur des caracte\*`res et non sur des octets.
.IP "readdir \s-1DIRHANDLE\s0" 8
.IX Item "readdir DIRHANDLE"
Retourne l'entre\*'e suivante d'un re\*'pertoire ouvert par \f(CW\*(C`opendir()\*(C'\fR. Dans un
contexte de liste, retournera toutes les entre\*'es restant dans le
re\*'pertoire. Si il n'y a plus d'entre\*'e, retournera la valeur undef dans un
contexte scalaire ou une liste vide dans un contexte de liste.
.Sp
Si vous pre\*'voyez de faire des tests de fichiers sur les valeurs retourne\*'es par
\&\f(CW\*(C`readdir()\*(C'\fR, n'oubliez pas de les pre\*'fixer par le re\*'pertoire en
question. Sinon, puisqu'aucun appel a\*` \f(CW\*(C`chdir()\*(C'\fR n'est effectue\*', vous risquez
de tester un mauvais fichier.
.Sp
.Vb 3
\&    opendir(DIR, $some_dir) || die "can't opendir $some_dir: $!";
\&    @dots = grep { /^\e./ && \-f "$some_dir/$_" } readdir(DIR);
\&    closedir DIR;
.Ve
.IP "readline \s-1EXPR\s0" 8
.IX Item "readline EXPR"
Lit a\*` partir du descripteur dont le typeglob est donne\*' par \s-1EXPR\s0. Dans un
contexte scalaire, chaque appel lit et retourne la ligne suivante jusqu'a\*`
atteindre la fin du fichier. A\*` ce moment, un appel supple\*'mentaire retournera
undef. Dans un contexte de liste, la lecture se fera jusqu'a\*` la fin du fichier
et le re\*'sultat sera une liste de lignes. La notion de \*(L"ligne\*(R" utilise\*'e ici est
celle de\*'finie par la variable \f(CW$/\fR ou \f(CW$INPUT_RECORD_SEPARATOR\fR. Voir
\&\*(L"$/\*(R" in perlvar.
.Sp
Lorsque \f(CW$/\fR est positionne\*' a\*` \f(CW\*(C`undef\*(C'\fR, que \fIreadline()\fR est utilise\*' dans un
contexte scalaire (i.e. en mode 'slurp') et que le fichier lu est vide, le
premier appel retourne \f(CW''\fR et \f(CW\*(C`undef\*(C'\fR pour les suivants.
.Sp
C'est la fonction interne qui imple\*'mente l'ope\*'rateur \f(CW\*(C`<EXPR>\*(C'\fR mais
vous pouvez l'utiliser directement. L'ope\*'rateur \f(CW\*(C`<EXPR>\*(C'\fR est de\*'crit
en de\*'tail dans \*(L"Les ope\*'rateurs d'E/S\*(R" in perlop.
.Sp
.Vb 2
\&    $line = <STDIN>;
\&    $line = readline(*STDIN);           # me\*^me chose
.Ve
.IP "readlink \s-1EXPR\s0" 8
.IX Item "readlink EXPR"
.PD 0
.IP "readlink" 8
.IX Item "readlink"
.PD
Retourne la valeur d'un lien symbolique si les liens symboliques sont
imple\*'mente\*'s. Sinon, produit une erreur fatale. Si il y a une erreur syste\*`me,
cette fonction retournera la valeur undef et positionnera la variable \f(CW$!\fR
(errno). Si \s-1EXPR\s0 est omis, s'applique a\*` \f(CW$_\fR.
.IP "readpipe \s-1EXPR\s0" 8
.IX Item "readpipe EXPR"
\&\s-1EXPR\s0 est exe\*'cute\*' comme une commande syste\*`me. La sortie standard de la commande
est collecte\*'e puis retourne\*'e. Dans un contexte scalaire, cette sortie est une
seule chai\*^ne (contenant e\*'ventuellement plusieurs lignes). Dans un contexte de
liste, retourne une liste de lignes (telles que de\*'finies par la variable \f(CW$/\fR
ou \f(CW$INPUT_RECORD_SEPARATOR\fR). C'est la fonction interne qui imple\*'mente
l'ope\*'rateur \f(CW\*(C`qx/EXPR/\*(C'\fR mais vous pouvez l'utiliser directement. L'ope\*'rateur
\&\f(CW\*(C`qx/EXPR/\*(C'\fR est de\*'crit plus en de\*'tail dans \*(L"Les ope\*'rateurs d'E/S\*(R" in perlop.
.IP "recv \s-1SOCKET\s0,SCALAIRE,LONGUEUR,FLAGS" 8
.IX Item "recv SOCKET,SCALAIRE,LONGUEUR,FLAGS"
Rec\*,oit un message depuis un socket. Tente de recevoir \s-1LONGUEUR\s0 caracte\*`res de
donne\*'es dans la variable \s-1SCALAIRE\s0 depuis le descripteur spe\*'cifie\*' par
\&\s-1SOCKET\s0. \s-1SCALAIRE\s0 grossira ou re\*'duira jusqu'a\*` la taille des donne\*'es re\*'ellement
lues. Utilise les me\*^mes \s-1FLAGS\s0 que l'appel syste\*`me du me\*^me nom. Retourne
l'adresse de l'e\*'metteur si le protocole de \s-1SOCKET\s0 le permet\ ; retourne une
chai\*^ne vide sinon. Retourne la valeur undef en cas d'erreur.  Cette fonction
est imple\*'mente\*'e en terme d'appel syste\*`me \fIrecvfrom\fR\|(2). Voir \*(L"\s-1UDP\s0 :
Transfert de Message\*(R" in perlipc pour des exemples.
.Sp
Notez que l'on parle bien de \fIcaracte\*`res\fR\ : selon l'e\*'tat du \s-1SOCKET\s0, ce
seront soit des octets (8\-bit) soit des caracte\*`res qui seront lus. Par de\*'faut
tous les SOCKETs ope\*`rent sur des octets mais si un \s-1SOCKET\s0 a e\*'te\*' modifie\*' via
\&\fIbinmode()\fR pour utiliser le filtre d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR (voir la directive
\&\f(CW\*(C`open\*(C'\fR dans open) alors les entre\*'es/sorties se feront sur des caracte\*`res
et non sur des octets.
.IP "redo \s-1LABEL\s0" 8
.IX Item "redo LABEL"
.PD 0
.IP "redo" 8
.IX Item "redo"
.PD
La commande \f(CW\*(C`redo\*(C'\fR rede\*'marre une boucle sans e\*'valuer a\*` nouveau la
condition. Le bloc \f(CW\*(C`continue\*(C'\fR, s'il existe, n'est pas e\*'value\*'. Si l'e\*'tiquette
\&\s-1LABEL\s0 est omise, la commande se re\*'fe\*`re a\*` la boucle englobante la plus
profonde. Cette commande est habituellement utilise\*'e par des programmes qui
veulent utiliser eux\-me\*^mes ce qui vient juste d'e\*^tre lu :
.Sp
.Vb 10
\&    # un programme simple pour supprimer les commentaires en Pascal
\&    # (Attention: suppose qu'il n'y pas de { ni de } dans les chai\*^nes.)
\&    LINE: while (<STDIN>) {
\&        while (s|({.*}.*){.*}|$1 |) {}
\&        s|{.*}| |;
\&        if (s|{.*| |) {
\&            $front = $_;
\&            while (<STDIN>) {
\&                if (/}/) {      # end of comment?
\&                    s|^|$front\e{|;
\&                    redo LINE;
\&                }
\&            }
\&        }
\&        print;
\&    }
.Ve
.Sp
\&\f(CW\*(C`redo\*(C'\fR ne peut pas e\*^tre utilise\*' pour rede\*'marrer un bloc qui doit retourner
une valeur comme \f(CW\*(C`eval {}\*(C'\fR, \f(CW\*(C`sub {}\*(C'\fR ou \f(CW\*(C`do {}\*(C'\fR et ne devrait pas e\*^tre
utilise\*' pour sortir d'une ope\*'ration \fIgrep()\fR ou \fImap()\fR.
.Sp
Remarques qu'un bloc en lui\-me\*^me est se\*'mantiquement identique a\*` une boucle qui
ne s'exe\*'cute qu'une fois. Donc \f(CW\*(C`redo\*(C'\fR dans un tel bloc le transforme
effectivement en une construction de boucle.
.Sp
Voir aussi \*(L"continue\*(R" pour illustrer la manie\*`re dont \f(CW\*(C`last\*(C'\fR, \f(CW\*(C`next\*(C'\fR et
\&\f(CW\*(C`redo\*(C'\fR fonctionnent.
.IP "ref \s-1EXPR\s0" 8
.IX Item "ref EXPR"
.PD 0
.IP "ref" 8
.IX Item "ref"
.PD
Retourne une valeur true (vraie) si \s-1EXPR\s0 est une re\*'fe\*'rence, false (faux)
sinon. Si \s-1EXPR\s0 n'est pas spe\*'cifie\*', s'applique a\*` \f(CW$_\fR. La valeur retourne\*'e
de\*'pend du type de ce qui est re\*'fe\*'rence\*' par la re\*'fe\*'rence. Les types internes
incluent\ :
.Sp
.Vb 7
\&    SCALAR
\&    ARRAY
\&    HASH
\&    CODE
\&    REF
\&    GLOB
\&    LVALUE
.Ve
.Sp
Si l'objet re\*'fe\*'rence\*' a e\*'te\*' be\*'ni (par \fIbless()\fR) par un paquetage alors le nom du
paquetage est retourne\*'. Vous pouvez voir \f(CW\*(C`ref()\*(C'\fR comme une sorte d'ope\*'rateur
\&\f(CW\*(C`typeof()\*(C'\fR (type de).
.Sp
.Vb 9
\&    if (ref($r) eq "HASH") {
\&        print "r is a reference to a hash.\en";
\&    }
\&    unless (ref($r)) {
\&        print "r is not a reference at all.\en";
\&    }
\&    if (UNIVERSAL::isa($r, "HASH")) {  # for subclassing
\&        print "r is a reference to something that isa hash.\en";
\&    }
.Ve
.Sp
Voir aussi perlref.
.IP "rename \s-1ANCIENNOM\s0,NOUVEAUNOM" 8
.IX Item "rename ANCIENNOM,NOUVEAUNOM"
Change le nom d'un fichier\ ; un fichier pre\*'existant de nom \s-1NOUVEAUNOM\s0 sera
e\*'crase\*'. Retourne true (vrai) en cas de succe\*`s ou false (faux) sinon.
.Sp
Le comportement de cette fonction varie beaucoup d'un syste\*`me a\*` l'autre. Par
exemple, habituellement elle ne fonctionne pas entre des syste\*`mes de fichiers
diffe\*'rents me\*^me si la commande syste\*`me \fImv\fR re\*'ussit parfois a\*` le faire. Il y
a d'autres restrictions selon que cela fonctionne ou non sur des re\*'pertoires,
sur des fichiers ouverts ou sur des fichiers pre\*'existants. Regarder
perlport et la page de documentation de \fIrename\fR\|(2) pour les de\*'tails.
.IP "require \s-1VERSION\s0" 8
.IX Item "require VERSION"
.PD 0
.IP "require \s-1EXPR\s0" 8
.IX Item "require EXPR"
.IP "require" 8
.IX Item "require"
.PD
Exige une version de Perl spe\*'cifie\*'e par \s-1VERSION\s0 ou une
X\ se\*'mantique\ X spe\*'cifie\*'e par \s-1EXPR\s0 ou par \f(CW$_\fR si \s-1EXPR\s0 n'est pas
fourni.
.Sp
\&\s-1VERSION\s0 peut e\*^tre spe\*'cifie\*' soit sous la forme d'une valeur nume\*'rique telle que
5.006, elle sera alors compare\*'e a\*` \f(CW$]\fR soit sous la forme d'une valeur
litte\*'rale telle que v5.6.1 qui sera alors compare\*'e a\*` \f(CW$^V\fR (ou son synonyme
\&\f(CW$PERL_VERSION\fR). Une erreur fatale est produite lors de l'exe\*'cution si \s-1VERSION\s0
est supe\*'rieure a\*` la version de l'interpre\*'teur Perl courant. Comparez avec
\&\*(L"use\*(R" qui peut faire un contro\*^le similaire mais lors de la compilation.
.Sp
.Vb 3
\&    require v5.6.1;     # contro\*^le de version a\*` l'exe\*'cution
\&    require 5.6.1;      # idem
\&    require 5.006_001;   # argument nume\*'rique autorise\*' par compatibilite\*'
.Ve
.Sp
Sinon, exige que le fichier d'une bibliothe\*`que soit inclus si ce n'est pas
de\*'ja\*` fait. Le fichier est inclus via le me\*'canisme do-FICHIER qui est
pratiquement une variante de \f(CW\*(C`eval()\*(C'\fR. Sa se\*'mantique est similaire a\*` la
proce\*'dure suivante\ :
.Sp
.Vb 10
\&    sub require {
\&        my($filename) = @_;
\&        return 1 if $INC{$filename};
\&        my($realfilename,$result);
\&        ITER: {
\&            foreach $prefix (@INC) {
\&                $realfilename = "$prefix/$filename";
\&                if (\-f $realfilename) {
\&                    $INC{$filename} = $realfilename;
\&                    $result = do $realfilename;
\&                    last ITER;
\&                }
\&            }
\&            die "Can't find $filename in \e@INC";
\&        }
\&        delete $INC{$filename} if $@ || !$result;
\&        die $@ if $@;
\&        die "$filename did not return true value" unless $result;
\&        return $result;
\&    }
.Ve
.Sp
Remarquez que le fichier ne sera pas inclus deux fois sous le me\*^me nom. Le
fichier doit retourner true (vrai) par sa dernie\*`re instruction pour indiquer
une exe\*'cution correcte du code d'initialisation. Il est donc courant de
terminer un tel fichier par un "\f(CW\*(C`1;\*(C'\fR\*(L" a\*` moins d'e\*^tre su\*^r qu'il retournera
true (vrai) par un autre moyen. Mais il est plus su\*^r de mettre \*(R"\f(CW\*(C`1;\*(C'\fR" au cas
ou\*` vous ajouteriez quelques instructions.
.Sp
Si \s-1EXPR\s0 est un nom simple (bareword), require suppose l'extension "\fI.pm\fR\*(L" et
remplace pour vous les \*(R"\fI::\fR\*(L" par des \*(R"\fI/\fR" dans le nom du fichier afin de
rendre plus simple le chargement des modules standards. Cette forme de
chargement des modules ne risque pas d'alte\*'rer votre espace de noms.
.Sp
En d'autres termes, si vous dites\ :
.Sp
.Vb 1
\&        require Foo::Bar;    # un splendide mot simple
.Ve
.Sp
La fonction require cherchera en fait le fichier "\fIFoo/Bar.pm\fR" dans les
re\*'pertoires spe\*'cifie\*'s par le tableau \f(CW@INC\fR.
.Sp
Mais si vous essayez\ :
.Sp
.Vb 4
\&        $class = 'Foo::Bar';
\&        require $class;      # $class n'est pas un mot simple
\&    #ou
\&        require "Foo::Bar";  # n'est pas un mot simple a\*` cause des guillemets
.Ve
.Sp
La fonction require cherchera le fichier "\fIFoo::Bar\fR" dans les re\*'pertoires du
tableau \f(CW@INC\fR et se plaindra qu'elle ne peut trouver le fichier
"\fIFoo::Bar\fR". Dans ce cas, vous pouvez faire\ :
.Sp
.Vb 1
\&        eval "require $class";
.Ve
.Sp
Vous pouvez aussi accrocher des actions (on dit crochets ou des \*(L"hooks\*(R") a\*` la
fonctionnalite\*' d'importation en plac\*,ant directement du code Perl dans le
tableau \f(CW@INC\fR. Il y a trois formes de crochets\ : une re\*'fe\*'rence vers une
subroutine, une re\*'fe\*'rence vers un tableau et une re\*'fe\*'rence vers un objet be\*'nit.
.Sp
La re\*'fe\*'rence vers une subroutine est le cas simple. Lorsque le syste\*`me
d'inclusion rencontre une telle re\*'fe\*'rence en parcourant le tableau \f(CW@INC\fR, la
subroutine est appele\*'e avec deux arguments. Le premier est une re\*'fe\*'rence vers
la subroutine elle\-me\*^me et le second est le nom du fichier a\*` inclure (par
exemple "\fIFoo/Bar.pm\fR"). La subroutine devrait alors retourner soit \f(CW\*(C`undef\*(C'\fR
soit un descripteur a\*` partir duquel le fichier a\*` inclure sera lu. Si la valeur
de retour est \f(CW\*(C`undef\*(C'\fR, \f(CW\*(C`require\*(C'\fR continuera sa recherche dans la suite du
tableau \f(CW@INC\fR>
.Sp
Si c'est une re\*'fe\*'rence vers un tableau, le premier e\*'le\*'ment de ce tableau doit
e\*^tre une re\*'fe\*'rence vers une subroutine. Cette subroutine sera appele\*'e comme
ci-dessous mais le premier argument sera la re\*'fe\*'rence vers le tableau. Cela
permet de passer des arguments indirectement a\*` la subroutine.
.Sp
En d'autres termes, vous pouvez e\*'crire\ :
.Sp
.Vb 5
\&     push @INC, \e&my_sub;
\&     sub my_sub {
\&       my ($coderef, $filename) = @_;  # $coderef est \e&my_sub
\&       ...
\&     }
.Ve
.Sp
ou\ :
.Sp
.Vb 7
\&     push @INC, [ \e&my_sub, $x, $y, ... ];
\&     sub my_sub {
\&       my ($arrayref, $filename) = @_;
\&       # On retrouve $x, $y, ...
\&       my @parameters = @$arrayref[1..$#$arrayref];
\&       ...
\&     }
.Ve
.Sp
Si c'est une re\*'fe\*'rence vers un objet, cet objet doit avoir une me\*'thode \s-1INC\s0 qui
sera appele\*'e comme ci-dessus avec comme premier parame\*`tre l'objet
lui\-me\*^me. (Notez que vous devez comple\*`tement qualifier le nom de cette
subroutine pour e\*'viter qu'il soit placer de force dans le package \f(CW\*(C`main\*(C'\fR.)
Voici un exemple typique de code\ :
.Sp
.Vb 7
\&     # Dans Foo.pm
\&     package Foo;
\&     sub new { ... }
\&     sub Foo::INC {
\&       my ($self, $filename) = @_;
\&       ...
\&     }
\& 
\&     # Dans le programme principal (main)
\&     push @INC, new Foo(...);
.Ve
.Sp
Notez que ces crochets ont aussi le droit de remplir les donne\*'es dans \f(CW%INC\fR
correspondant aux fichiers qu'ils ont charge\*'s. Voir \*(L"%INC\*(R" in perlvar.
.Sp
Pour une fonctionnalite\*' d'importation encore plus puissante, voir \*(L"use\*(R" et
perlmod.
.IP "reset \s-1EXPR\s0" 8
.IX Item "reset EXPR"
.PD 0
.IP "reset" 8
.IX Item "reset"
.PD
Ge\*'ne\*'ralement utilise\*'e dans un bloc \f(CW\*(C`continue\*(C'\fR a\*` la fin d'une boucle pour
effacer les variables et re\*'initialiser les recherches \f(CW\*(C`??\*(C'\fR pour qu'elle
marche a\*` nouveau. L'expression \s-1EXPR\s0 est interpre\*'te\*'e comme une liste de
caracte\*`res (le moins est autorise\*' pour des intervalles). Toutes les variables
commenc\*,ant par l'un de ces caracte\*`res sont re\*'initialise\*'es a\*` leur e\*'tat
primitif. Si \s-1EXPR\s0 est omis, les motifs de recherche qui ne marchent qu'une
fois (\f(CW\*(C`?motif?\*(C'\fR) sont re\*'initialise\*'s pour fonctionner a\*` nouveau. Ne
re\*'initialise que les variables et les motifs du paquetage courant. Retourne
toujours 1. Exemples\ :
.Sp
.Vb 4
\&    reset 'X';          # re\*'initialise toutes les variables X...
\&    reset 'a\-z';        # re\*'initialise toutes les variables
\&                        # commenc\*,ant par une minuscule
\&    reset;              # re\*'initialise juste les motifs ?...?
.Ve
.Sp
Re\*'initialiser \f(CW"A\-Z"\fR n'est pas recommande\*' parce que cela efface les tableaux
\&\f(CW@ARGV\fR et \f(CW@INC\fR ainsi que la table de hachage \f(CW%ENV\fR. Ne re\*'initialise que
les variables de paquetage \*(-- les variables lexicales ne sont pas modifie\*'es
mais elles s'effacent toutes seules de\*`s que l'on sort de leur porte\*'e, ce qui
devrait vous inciter a\*` les utiliser. Voir \*(L"my\*(R".
.IP "return \s-1EXPR\s0" 8
.IX Item "return EXPR"
.PD 0
.IP "return" 8
.IX Item "return"
.PD
Sort d'une subroutine, d'un bloc \f(CW\*(C`eval()\*(C'\fR ou d'un \f(CW\*(C`do FICHIER\*(C'\fR en retournant
la valeur donne\*'e par \s-1EXPR\s0. L'e\*'valuation de \s-1EXPR\s0 peut se faire dans un contexte
scalaire, de liste ou vide selon la manie\*`re dont la valeur sera utilise\*'e. Le
contexte peut varier d'une exe\*'cution a\*` l'autre (voir \f(CW\*(C`wantarray()\*(C'\fR). Si
aucune \s-1EXPR\s0 n'est donne\*'e, retourne la liste vide dans un contexte de liste, la
valeur undef dans un contexte scalaire et rien du tout dans un contexte vide.
.Sp
(Remarque\ : en l'absence de \f(CW\*(C`return\*(C'\fR explicite, une subroutine, un bloc
eval ou un do \s-1FICHIER\s0 retournera automatiquement la valeur de la dernie\*`re
expression e\*'value\*'e.)
.IP "reverse \s-1LISTE\s0" 8
.IX Item "reverse LISTE"
Dans un contexte de liste, retourne une liste de valeurs constitue\*'e des
e\*'le\*'ments de \s-1LISTE\s0 en ordre inverse. Dans un contexte scalaire, concate\*`ne les
e\*'le\*'ments de \s-1LISTE\s0 et retourne la chai\*^ne ainsi constitue\*'e mais avec les
caracte\*`res dans l'ordre inverse.
.Sp
.Vb 2
\&    print reverse <>;           # tac (cat a\*` l'envers) les lignes,
\&                                # la dernie\*`re ligne en premier
\&
\&    undef $/;                   # pour un <> efficace
\&    print scalar reverse <>;    # tac (cat a\*` l'envers) les octets,
\&                                # la dernie\*`re ligne en reimerp
.Ve
.Sp
Cet ope\*'rateur est aussi utilise\*' pour inverser des tables de hachage bien que
cela pose quelques proble\*`mes. Si une valeur est duplique\*'e dans la table
originale, seule l'une des ces valeurs sera repre\*'sente\*'e comme une cle\*' dans la
table re\*'sultante. Cela ne\*'cessite aussi de mettre toute la table a\*` plat avant
d'en reconstruire une nouvelle ce qui peut prendre beaucoup de temps sur une
grosse table telle qu'un fichier \s-1DBM\s0.
.Sp
.Vb 1
\&    %by_name = reverse %by_address;     # Inverse la table
.Ve
.IP "rewinddir \s-1DIRHANDLE\s0" 8
.IX Item "rewinddir DIRHANDLE"
Rame\*`ne la position courante au de\*'but du re\*'pertoire pour le prochain
\&\f(CW\*(C`readdir()\*(C'\fR sur \s-1DIRHANDLE\s0.
.IP "rindex \s-1CHAINE\s0,SUBSTR,POSITION" 8
.IX Item "rindex CHAINE,SUBSTR,POSITION"
.PD 0
.IP "rindex \s-1CHAINE\s0,SUBSTR" 8
.IX Item "rindex CHAINE,SUBSTR"
.PD
Fonctionne exactement comme index sauf qu'il retourne la position de la
dernie\*`re occurrence de \s-1SUBSTR\s0 dans \s-1CHAINE\s0. Si \s-1POSITION\s0 est spe\*'cifie\*'e, retourne
la dernie\*`re occurrence avant ou exactement a\*` cette position.
.IP "rmdir \s-1REPNOM\s0" 8
.IX Item "rmdir REPNOM"
.PD 0
.IP "rmdir" 8
.IX Item "rmdir"
.PD
Efface le re\*'pertoire spe\*'cifie\*' par \s-1REPNOM\s0 si ce re\*'pertoire est vide. En cas
de succe\*`s, retourne true (vrai) ou sinon, retourne false (faux) et positionne
la variable \f(CW$!\fR (errno). Si \s-1REPNOM\s0 est omis, utilise \f(CW$_\fR.
.IP "s///" 8
.IX Item "s///"
L'ope\*'rateur de substitution. Voir perlop.
.IP "scalar \s-1EXPR\s0" 8
.IX Item "scalar EXPR"
Contraint l'interpre\*'tation de \s-1EXPR\s0 dans un contexte scalaire et retourne la
valeur de \s-1EXPR\s0.
.Sp
.Vb 1
\&    @counts = ( scalar @a, scalar @b, scalar @c );
.Ve
.Sp
Il n'y pas d'ope\*'rateur e\*'quivalent pour contraindre l'interpre\*'tation d'une
expression dans un contexte de liste parce qu'en pratique ce n'est jamais
ne\*'cessaire. Si vous en avez re\*'ellement besoin, vous pouvez utiliser une
construction comme \f(CW\*(C`@{[ (une expression) ]}\*(C'\fR mais un simple \f(CW\*(C`(une
expression)\*(C'\fR suffit en ge\*'ne\*'ral.
.Sp
Comme \f(CW\*(C`scalar\*(C'\fR est un ope\*'rateur unaire, si vous l'utilisez accidentellement
sur une \s-1EXPR\s0 constitue\*'e d'une liste entre parenthe\*`ses, cela se comporte comme
l'ope\*'rateur scalaire virgule en e\*'valuant tous les e\*'le\*'ments dans un contexte
vide sauf le dernier e\*'le\*'ment qui est e\*'value\*' dans un contexte scalaire et
retourne\*'. C'est rarement ce que vous vouliez.
.Sp
L'instruction suivante\ :
.Sp
.Vb 1
\&        print uc(scalar(&foo,$bar)),$baz;
.Ve
.Sp
est e\*'quivalente a\*` ces deux instructions\ :
.Sp
.Vb 2
\&        &foo;
\&        print(uc($bar),$baz);
.Ve
.Sp
Voir perlop pour les de\*'tails sur les ope\*'rateurs unaires et l'ope\*'rateur
virgule.
.IP "seek \s-1DESCRIPTEUR\s0,POSITION,WHENCE" 8
.IX Item "seek DESCRIPTEUR,POSITION,WHENCE"
Modifie la position d'un \s-1DESCRIPTEUR\s0 exactement comme le fait l'appel
\&\f(CW\*(C`fseek()\*(C'\fR de \f(CW\*(C`stdio()\*(C'\fR. \s-1DESCRIPTEUR\s0 peut e\*^tre une expression dont la valeur
donne le nom du descripteur. Les valeurs possibles de \s-1WHENCE\s0 sont \f(CW0\fR pour
re\*'gler la nouvelle position \fIen octets\fR a\*` \s-1POSITION\s0, \f(CW1\fR pour la re\*'gler a\*` la
position courante plus \s-1POSITION\s0 ou \f(CW2\fR pour la re\*'gler a\*` \s-1EOF\s0 plus \s-1POSITION\s0 (en
ge\*'ne\*'ral ne\*'gative). Pour \s-1WHENCE\s0, vous pouvez utiliser les constantes
\&\f(CW\*(C`SEEK_SET\*(C'\fR, \f(CW\*(C`SEEK_CUR\*(C'\fR et \f(CW\*(C`SEEK_END\*(C'\fR (relatif au de\*'but du fichier, a\*` la
position courante, a\*` la fin du fichier) provenant du module Fcntl. Renvoie
\&\f(CW1\fR en cas de succe\*`s et \f(CW0\fR sinon.
.Sp
Notez bien qu'on parle \fIen octets\fR\ : me\*^me si le \s-1DESCRIPTEUR\s0 a e\*'te\*'
configure\*' pour ope\*'rer sur des caracte\*`res (par exemple en utilisant le filtre
\&\f(CW\*(C`:utf8\*(C'\fR), \fIseek()\fR travaille quand me\*^me en terme d'octets et non en terme de
caracte\*`res (imple\*'menter cette fonctionnalite\*' aurait rendu \fIseek()\fR et \fItell()\fR
extre\*^mement lents).
.Sp
Si vous voulez re\*'gler la position pour un fichier dans le but d'utiliser
\&\f(CW\*(C`sysread()\*(C'\fR ou \f(CW\*(C`syswrite()\*(C'\fR, n'utilisez pas \f(CW\*(C`seek()\*(C'\fR \*(-- la bufferisation
rend ses effets impre\*'visibles et non portables. Utilisez \f(CW\*(C`sysseek()\*(C'\fR a\*` la
place.
.Sp
A\*` cause des re\*`gles et de la rigueur du C \s-1ANSI\s0, sur certains syste\*`mes, vous
devez faire un seek a\*` chaque fois que vous basculez entre lecture et
e\*'criture. Entre autres choses, cela a pour effet d'appeler la fonction
\&\fIclearerr\fR\|(3) de stdio. Un \s-1WHENCE\s0 de \f(CW1\fR (\f(CW\*(C`SEEK_CUR\*(C'\fR) est pratique pour ne pas
modifier la position dans le fichier\ :
.Sp
.Vb 1
\&    seek(TEST,0,1);
.Ve
.Sp
C'est aussi tre\*`s pratique pour les applications qui veulent simuler \f(CW\*(C`tail
\&\-f\*(C'\fR. Une fois rencontre\*' un \s-1EOF\s0 en lecture et apre\*`s avoir attendu un petit peu,
vous devez utiliser \fIseek()\fR pour re\*'activer les choses. L'appel a\*` \f(CW\*(C`seek()\*(C'\fR ne
modifie pas la position courante mais par contre, il efface la condition
fin-de-fichier (\s-1EOF\s0) sur le descripteur et donc, au prochain \f(CW\*(C`<FILE>\*(C'\fR,
Perl essayera a\*` nouveau de lire quelque chose. Espe\*'rons\-le.
.Sp
Si cela ne marche pas (certaines imple\*'mentations des E/S sont particulie\*`rement
irascibles) alors vous devrez faire quelque chose comme\ :
.Sp
.Vb 8
\&    for (;;) {
\&        for ($curpos = tell(FILE); $_ = <FILE>;
\&             $curpos = tell(FILE)) {
\&            # search for some stuff and put it into files
\&        }
\&        sleep($for_a_while);
\&        seek(FILE, $curpos, 0);
\&    }
.Ve
.IP "seekdir \s-1DIRHANDLE\s0,POS" 8
.IX Item "seekdir DIRHANDLE,POS"
Re\*`gle la position courante pour la routine \f(CW\*(C`readdir()\*(C'\fR sur un \s-1DIRHANDLE\s0. \s-1POS\s0
doit e\*^tre une valeur retourne\*'e par \f(CW\*(C`telldir()\*(C'\fR. Posse\*`de les me\*^me limitations
que l'appel syste\*`me correspondant.
.IP "select \s-1DESCRIPTEUR\s0" 8
.IX Item "select DESCRIPTEUR"
.PD 0
.IP "select" 8
.IX Item "select"
.PD
Retourne le descripteur courant. Se\*'lectionne le descripteur \s-1DESCRIPTEUR\s0 comme
sortie par de\*'faut si \s-1DESCRIPTEUR\s0 est fourni. Ceci a deux effets : tout
d'abord, un \f(CW\*(C`write()\*(C'\fR ou un \f(CW\*(C`print()\*(C'\fR sans descripteur spe\*'cifie\*' iront par
de\*'faut sur ce \s-1DESCRIPTEUR\s0. Ensuite, toutes re\*'fe\*'rences a\*` des variables
relatives aux sorties se re\*'fe\*'reront a\*` ce canal de sortie. Par exemple, si vous
devez spe\*'cifier un en\-te\*^te de format pour plusieurs canaux de sortie, vous
devez faire la chose suivante\ :
.Sp
.Vb 4
\&    select(REPORT1);
\&    $^ = 'report1_top';
\&    select(REPORT2);
\&    $^ = 'report2_top';
.Ve
.Sp
\&\s-1DESCRIPTEUR\s0 peut e\*^tre une expression dont le re\*'sultat donne le nom du
descripteur re\*'el. Donc\ :
.Sp
.Vb 1
\&    $oldfh = select(STDERR); $| = 1; select($oldfh);
.Ve
.Sp
Certains programmeurs pre\*'fe\*`rent conside\*'rer les descripteurs comme des objets
avec des me\*'thodes. Ils e\*'criraient donc l'exemple pre\*'ce\*'dent de la manie\*`re
suivante\ :
.Sp
.Vb 2
\&    use IO::Handle;
\&    STDERR\->autoflush(1);
.Ve
.IP "select \s-1RBITS\s0,WBITS,EBITS,TIMEOUT" 8
.IX Item "select RBITS,WBITS,EBITS,TIMEOUT"
Ceci utilise directement l'appel syste\*`me \fIselect\fR\|(2) avec les masques de bit
spe\*'cifie\*'s qui peuvent e\*^tre construits en utilisant \f(CW\*(C`fileno()\*(C'\fR et \f(CW\*(C`vec()\*(C'\fR
comme dans les lignes suivantes\ :
.Sp
.Vb 4
\&    $rin = $win = $ein = '';
\&    vec($rin,fileno(STDIN),1) = 1;
\&    vec($win,fileno(STDOUT),1) = 1;
\&    $ein = $rin | $win;
.Ve
.Sp
Si vous voulez surveiller de nombreux descripteurs, vous aurez peut\-e\*^tre a\*`
e\*'crire une subroutine\ :
.Sp
.Vb 9
\&    sub fhbits {
\&        my(@fhlist) = split(' ',$_[0]);
\&        my($bits);
\&        for (@fhlist) {
\&            vec($bits,fileno($_),1) = 1;
\&        }
\&        $bits;
\&    }
\&    $rin = fhbits('STDIN TTY SOCK');
.Ve
.Sp
L'appel classique est\ :
.Sp
.Vb 2
\&    ($nfound,$timeleft) =
\&      select($rout=$rin, $wout=$win, $eout=$ein, $timeout);
.Ve
.Sp
ou pour attendre que quelque chose soit pre\*^t\ :
.Sp
.Vb 1
\&    $nfound = select($rout=$rin, $wout=$win, $eout=$ein, undef);
.Ve
.Sp
De nombreux syste\*`mes ne prennent pas la peine de retourner quelque chose
d'utile dans \f(CW$timeleft\fR (le temps restant). En conse\*'quence, un appel a\*`
\&\fIselect()\fR dans un contexte scalaire retourne juste \f(CW$nfound\fR.
.Sp
undef est une valeur acceptable pour les masques de bits. Le timeout, s'il
est spe\*'cifie\*', est donne\*' en secondes et peut e\*^tre fractionnaire. Note\ :
certaines imple\*'mentations ne sont pas capables de retourner \f(CW$timeleft\fR. Dans
ce cas, elles retournent toujours un \f(CW$timeleft\fR e\*'gal au \f(CW$timeout\fR fourni.
.Sp
Vous pouvez spe\*'cifier une attente de 250 millisecondes de la manie\*`re
suivante\ :
.Sp
.Vb 1
\&    select(undef, undef, undef, 0.25);
.Ve
.Sp
Notez que selon les imple\*'mentations, un \f(CW\*(C`select\*(C'\fR continuera ou non apre\*`s
re\*'ception d'un signal (un \s-1SIGALRM\s0 par exemple).
.Sp
\&\fB\s-1ATTENTION\s0\fR\ : il ne faut pas me\*'langer des E/S bufferise\*'es (comme \f(CW\*(C`read()\*(C'\fR
ou <\s-1FH\s0>) avec \f(CW\*(C`select()\*(C'\fR excepte\*' lorsque la norme \s-1POSIX\s0 le permet et,
dans ce cas, uniquement sur les syste\*`mes \s-1POSIX\s0. Vous devez utiliser
\&\f(CW\*(C`sysread()\*(C'\fR a\*` la place.
.IP "semctl \s-1ID\s0,SEMNUM,CMD,ARG" 8
.IX Item "semctl ID,SEMNUM,CMD,ARG"
Appelle la fonction \f(CW\*(C`semctl()\*(C'\fR des \s-1IPC\s0 System V. Vous aurez sans doute besoin
de\ :
.Sp
.Vb 1
\&    use IPC::SysV;
.Ve
.Sp
au pre\*'alable pour avoir les de\*'finitions correctes des constantes. Si \s-1CMD\s0 est
\&\s-1IPC_STAT\s0 ou \s-1GETALL\s0 alors \s-1ARG\s0 doit e\*^tre une variable capable de contenir la
structure semid_ds retourne\*'e ou le tableau des valeurs des se\*'maphores. Les
valeurs retourne\*'es sont comme celles de \f(CW\*(C`ioctl()\*(C'\fR\ : la valeur undef en cas
d'erreur, la chai\*^ne "\f(CW0\fR but true" pour rien ou la vraie valeur retourne\*'e
dans les autres cas. \s-1ARG\s0 doit e\*^tre un vecteur d'entiers courts (short) natifs
qui peut e\*^tre cre\*'e\*' par \f(CW\*(C`pack("s!",(0)x$nsem)\*(C'\fR.  Voir aussi la documentation
de \f(CW\*(C`IPC::SysV\*(C'\fR et de \f(CW\*(C`IPC::SysV::Semaphore\*(C'\fR.
.IP "semget \s-1KEY\s0,NSEMS,FLAGS" 8
.IX Item "semget KEY,NSEMS,FLAGS"
Appelle la fonction \f(CW\*(C`semget()\*(C'\fR des \s-1IPC\s0 System V. Renvoie l'id du se\*'maphore ou
la valeur undef en cas d'erreur. Voir aussi la documentation de \f(CW\*(C`IPC::SysV\*(C'\fR
et de \f(CW\*(C`IPC::SysV::Semaphore\*(C'\fR.
.IP "semop \s-1KEY\s0,OPSTRING" 8
.IX Item "semop KEY,OPSTRING"
Appelle la fonction \f(CW\*(C`semop()\*(C'\fR des \s-1IPC\s0 System V pour re\*'aliser certaines
ope\*'rations sur les se\*'maphores comme l'attente ou la signalisation. \s-1OPSTRING\s0
doit e\*^tre un tableau compacte\*' (par \fIpack()\fR) de structures semop. Chaque
structure semop peut e\*^tre ge\*'ne\*'re\*'e par \f(CW\*(C`pack("s!3", $semnum, $semop,
$semflag)\*(C'\fR. Le nombre total d'ope\*'rations sur les se\*'maphores est de\*'duit de la
taille de \s-1OPSTRING\s0. Renvoie true (vrai) en cas de succe\*`s ou false (faux) en
cas d'erreur. Par exemple, le code suivant attend sur le se\*'maphore \f(CW$semnum\fR
de l'ensemble de se\*'maphores d'id \f(CW$semid\fR\ :
.Sp
.Vb 2
\&    $semop = pack("s!3", $semnum, \-1, 0);
\&    die "Semaphore trouble: $!\en" unless semop($semid, $semop);
.Ve
.Sp
Pour envoyer un signal au se\*'maphore, remplacez le \f(CW\*(C`\-1\*(C'\fR par \f(CW1\fR.  Voir aussi
la documentation de \f(CW\*(C`IPC::SysV\*(C'\fR et de \f(CW\*(C`IPC::SysV::Semaphore\*(C'\fR.
.IP "send \s-1SOCKET\s0,MSG,FLAGS,TO" 8
.IX Item "send SOCKET,MSG,FLAGS,TO"
.PD 0
.IP "send \s-1SOCKET\s0,MSG,FLAGS" 8
.IX Item "send SOCKET,MSG,FLAGS"
.PD
Envoie un message sur un socket. Envoie le scalaire \s-1MSG\s0 vers le descripteur
\&\s-1SOCKET\s0. Utilise les me\*^mes flags que l'appel syste\*`me du me\*^me nom. Pour des
sockets non connecte\*'s, vous devez spe\*'cifier dans le parame\*`tre \s-1TO\s0 une
destination pour l'envoi. Dans ce cas c'est la fonction C \f(CW\*(C`sendto()\*(C'\fR qui est
utilise\*'e. Retourne le nombre de caracte\*`res envoye\*'s ou la valeur undef s'il y
a une erreur. L'appel syste\*`me \fIsendmsg\fR\|(2) n'est pas imple\*'mente\*' pour
l'instant. Voir les exemples dans \*(L"\s-1UDP\s0 : Transfert de Message\*(R" in perlipc.
.Sp
Notez que l'on parle bien de \fIcaracte\*`res\fR\ : selon l'e\*'tat du \s-1SOCKET\s0, ce
seront soit des octets (8\-bit) soit des caracte\*`res qui seront lus. Par de\*'faut
tous les SOCKETs ope\*`rent sur des octets mais si un \s-1SOCKET\s0 a e\*'te\*' modifie\*' via
\&\fIbinmode()\fR pour utiliser le filtre d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR (voir la directive
\&\f(CW\*(C`open\*(C'\fR dans open) alors les entre\*'es/sorties se feront sur des caracte\*`res
et non sur des octets.
.IP "setpgrp \s-1PID\s0,PGRP" 8
.IX Item "setpgrp PID,PGRP"
Modifie le groupe de processus courant pour le \s-1PID\s0 spe\*'cifie\*' (\f(CW0\fR pour le
processus courant). Cela produira une erreur fatale si vous l'utilisez sur un
syste\*`me qui n'imple\*'mente pas l'appel \s-1POSIX\s0 \fIsetpgid\fR\|(2) ou l'appel \s-1BSD\s0
\&\fIsetpgrp\fR\|(2). Si les arguments sont omis, ils prennent comme valeur par de\*'faut
\&\f(CW\*(C`0,0\*(C'\fR. Remarquez aussi que la version \s-1BSD\s0 4.2 de \f(CW\*(C`setpgrp()\*(C'\fR n'accepte aucun
argument. Donc seul setpgrp \f(CW\*(C`0,0\*(C'\fR est portable. Voir aussi
\&\f(CW\*(C`POSIX::setsid()\*(C'\fR.
.IP "setpriority \s-1WHICH\s0,WHO,PRIORITY" 8
.IX Item "setpriority WHICH,WHO,PRIORITY"
Modifie la priorite\*' courante d'un process, d'un groupe de process ou d'un
utilisateur. (Voir \fIsetpriority\fR\|(2).) Cela produira une erreur fatale si vous
l'utilisez sur un syste\*`me qui n'imple\*'mente pas \fIsetpriority\fR\|(2).
.IP "setsockopt \s-1SOCKET\s0,LEVEL,OPTNAME,OPTVAL" 8
.IX Item "setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL"
Modifie l'option spe\*'cifie\*'e d'un socket. Retourne undef en cas d'erreur. \s-1OPTVAL\s0
peut e\*^tre \f(CW\*(C`undef\*(C'\fR si vous ne voulez pas passer d'argument.
.IP "shift \s-1TABLEAU\s0" 8
.IX Item "shift TABLEAU"
.PD 0
.IP "shift" 8
.IX Item "shift"
.PD
Retourne la premie\*`re valeur d'un tableau apre\*`s l'avoir supprime\*'e du tableau en
re\*'tre\*'cissant sa taille de 1 et en de\*'plac\*,ant tout vers le bas. Renvoie undef si
il n'y a pas d'e\*'le\*'ments dans le tableau. Si \s-1TABLEAU\s0 est omis, shift agira soit
sur le tableau \f(CW@_\fR s'il est dans la porte\*'e lexicale d'une subroutine ou
d'un format, soit sur le tableau \f(CW@ARGV\fR s'il est dans la porte\*'e lexicale
d'un fichier ou s'il est dans une porte\*'e lexicale e\*'tablie par l'une des
constructions \f(CW\*(C`eval ''\*(C'\fR, \f(CW\*(C`BEGIN {}\*(C'\fR, \f(CW\*(C`END {}\*(C'\fR ou \f(CW\*(C`INIT {}\*(C'\fR.
.Sp
Voir aussi \f(CW\*(C`unshift\*(C'\fR, \f(CW\*(C`push\*(C'\fR et \f(CW\*(C`pop\*(C'\fR. \f(CW\*(C`shift()\*(C'\fR et \f(CW\*(C`unshift()\*(C'\fR agissent
sur le co\*^te\*' gauche d'un tableau exactement comme \f(CW\*(C`pop()\*(C'\fR et \f(CW\*(C`push()\*(C'\fR le font
sur le co\*^te\*' droit.
.IP "shmctl \s-1ID\s0,CMD,ARG" 8
.IX Item "shmctl ID,CMD,ARG"
Appelle la fonction shmctl de \s-1IPC\s0 System V. Vous aurez sans doute besoin de\ :
.Sp
.Vb 1
\&    use IPC::SysV;
.Ve
.Sp
au pre\*'alable pour avoir les de\*'finitions correctes des constantes. Si \s-1CMD\s0 est
\&\f(CW\*(C`IPC_STAT\*(C'\fR alors \s-1ARG\s0 doit e\*^tre une variable capable de contenir la structure
\&\f(CW\*(C`shmid_ds\*(C'\fR retourne\*'e. Les valeurs retourne\*'es sont comme celles de
\&\f(CW\*(C`ioctl()\*(C'\fR\ : la valeur undef en cas d'erreur, la chai\*^ne "\f(CW0\fR but true"
pour ze\*'ro ou la vraie valeur retourne\*'e dans les autres cas. Voir aussi la
documentation de \f(CW\*(C`IPC::SysV\*(C'\fR.
.IP "shmget \s-1KEY\s0,SIZE,FLAGS" 8
.IX Item "shmget KEY,SIZE,FLAGS"
Appelle la fonction shmget de \s-1IPC\s0 System V. Renvoie l'id du segment de me\*'moire
partage\*'e ou undef en cas d'erreur. Voir aussi la documentation de
\&\f(CW\*(C`IPC::SysV\*(C'\fR.
.IP "shmread \s-1ID\s0,VAR,POS,SIZE" 8
.IX Item "shmread ID,VAR,POS,SIZE"
.PD 0
.IP "shmwrite \s-1ID\s0,CHAINE,POS,SIZE" 8
.IX Item "shmwrite ID,CHAINE,POS,SIZE"
.PD
Lit ou e\*'crit le segment de me\*'moire partage\*'e System V d'id \s-1ID\s0 en commenc\*,ant a\*`
la position \s-1POS\s0 et sur une taille de \s-1SIZE\s0 en s'attachant a\*` lui puis en le
lisant ou en l'e\*'crivant puis enfin en s'en de\*'tachant. Lors d'une lecture, \s-1VAR\s0
doit e\*^tre une variable qui contiendra les donne\*'es lues. Lors d'une e\*'criture,
si \s-1CHAINE\s0 est trop long, seuls \s-1SIZE\s0 octets seront utilise\*'s, si \s-1CHAINE\s0 est trop
court des caracte\*`res nuls seront ajoute\*'s pour comple\*'ter jusqu'a\*` \s-1SIZE\s0
octets. Retourne true (vrai) en cas de succe\*`s et false (faux) en cas
d'erreur. \fIshmread()\fR souille (taint) la variable \s-1CHAINE\s0. Voir aussi la
documentation de \f(CW\*(C`IPC::SysV\*(C'\fR.
.IP "shutdown \s-1SOCKET\s0,HOW" 8
.IX Item "shutdown SOCKET,HOW"
Ferme une connexion socket de la manie\*`re indique\*'e par \s-1HOW\s0 qui est interpre\*'te\*'
comme le fait l'appel syste\*`me du me\*^me nom.
.Sp
.Vb 3
\&    shutdown(SOCKET, 0);    # J'ai arre\*^te\*' de lire des donne\*'es
\&    shutdown(SOCKET, 1);    # J'ai arre\*^te\*' d'e\*'crire des donne\*'es
\&    shutdown(SOCKET, 2);    # J'ai arre\*^te\*' d'utiliser ce socket
.Ve
.Sp
C'est pratique pour des sockets pour lesquels vous voulez indiquer a\*` l'autre
extre\*'mite\*' que vous avez fini d'e\*'crire mais pas de lire ou vice versa. C'est
aussi une forme plus insistante de close puisque qu'elle de\*'sactive aussi le
descripteur de fichier pour tous les process duplique\*'s par fork.
.IP "sin \s-1EXPR\s0" 8
.IX Item "sin EXPR"
.PD 0
.IP "sin" 8
.IX Item "sin"
.PD
Retourne le sinus de \s-1EXPR\s0 (exprime\*' en radians). Si \s-1EXPR\s0 est omis, retourne le
sinus de \f(CW$_\fR.
.Sp
Pour calculer la fonction inverse du sinus, vous pouvez utiliser la fonction
\&\f(CW\*(C`Math::Trig::asin\*(C'\fR ou utiliser cette relation\ :
.Sp
.Vb 1
\&    sub asin { atan2($_[0], sqrt(1 \- $_[0] * $_[0])) }
.Ve
.IP "sleep \s-1EXPR\s0" 8
.IX Item "sleep EXPR"
.PD 0
.IP "sleep" 8
.IX Item "sleep"
.PD
Demande au script de s'endormir pendant \s-1EXPR\s0 secondes ou pour toujours si \s-1EXPR\s0
est omis. Peut e\*^tre interrompu si le process rec\*,oit un signal comme
\&\f(CW\*(C`SIGALRM\*(C'\fR. Renvoie la dure\*'e re\*'elle du sommeil en secondes. Vous ne pourrez
probablement pas me\*'langer des appels \f(CW\*(C`alarm()\*(C'\fR et \f(CW\*(C`sleep()\*(C'\fR car \f(CW\*(C`sleep()\*(C'\fR
est souvent imple\*'mente\*' en utilisant \f(CW\*(C`alarm()\*(C'\fR.
.Sp
Sur quelques vieux syste\*`mes, il se peut que la dure\*'e du sommeil soit d'une
seconde de moins que celle que vous avez demande\*'e en fonction de la manie\*`re
dont il compte les secondes. Les syste\*`mes plus modernes s'endorment toujours
pendant la bonne dure\*'e. En revanche, il peut arriver que votre sommeil dure
plus longtemps que pre\*'vu sur un syste\*`me multi\-ta\*^ches tre\*`s charge\*'.
.Sp
Pour des de\*'lais d'une granularite\*' infe\*'rieure a\*` la seconde, vous pouvez
utiliser l'interface Perl \f(CW\*(C`syscall()\*(C'\fR pour acce\*'der a\*` \fIsetitimer\fR\|(2) si votre
syste\*`me le supporte ou sinon regarder \*(L"\fIselect()\fR\*(R" plus haut. Le module
Time::HiRes (disponible sur \s-1CPAN\s0 ou inte\*'grer a\*` la distribution standard depuis
Perl 5.8.0) peut aussi aider.
.Sp
Regarder aussi la fonction \f(CW\*(C`sigpause()\*(C'\fR du module \s-1POSIX\s0.
.IP "socket \s-1SOCKET\s0,DOMAIN,TYPE,PROTOCOL" 8
.IX Item "socket SOCKET,DOMAIN,TYPE,PROTOCOL"
Ouvre un socket du type spe\*'cifie\*' et l'attache au descripteur \s-1SOCKET\s0. \s-1DOMAIN\s0,
\&\s-1TYPE\s0 et \s-1PROTOCOL\s0 sont spe\*'cifie\*'s comme pour l'appel syste\*`me du me\*^me nom. Vous
devriez mettre "\f(CW\*(C`use Socket;\*(C'\fR" au pre\*'alable pour importer les de\*'finitions
correctes. Voir les exemples dans \*(L"Sockets : Communication
Client/Serveur\*(R" in perlipc.
.Sp
Sur les syste\*`mes qui supportent le drapeau fermeture\-a\*`\-l\-exe\*'cution
(close\-on\-exec) sur les fichiers, ce drapeau sera positionne\*' pour de nouveaux
descripteurs de fichier en fonction de la valeur de $^F. Voir \*(L"$^F\*(R" in perlvar.
.IP "socketpair \s-1SOCKET1\s0,SOCKET2,DOMAIN,TYPE,PROTOCOL" 8
.IX Item "socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL"
Cre\*'e une paire de sockets sans nom dans le domaine spe\*'cifie\*' et du type
spe\*'cifie\*'. \s-1DOMAIN\s0, \s-1TYPE\s0 et \s-1PROTOCOL\s0 sont spe\*'cifie\*'s comme pour l'appel syste\*`me
du me\*^me nom. Si l'appel syste\*`me n'est pas imple\*'mente\*', cela produit une erreur
fatale. Retourne true (vrai) en cas de succe\*`s.
.Sp
Sur les syste\*`mes qui supportent le drapeau fermeture\-a\*`\-l\-exe\*'cution
(close\-on\-exec) sur les fichiers, ce drapeau sera positionne\*' pour de nouveaux
descripteurs de fichier en fonction de la valeur de $^F. Voir \*(L"$^F\*(R" in perlvar.
.Sp
Certains syste\*`mes de\*'finissent \f(CW\*(C`pipe()\*(C'\fR en terme de \f(CW\*(C`socketpair()\*(C'\fR, auquel
cas un appel a\*` \f(CW\*(C`pipe(Rdr, Wtr)\*(C'\fR est quasiment e\*'quivalent\ a\*`\ :
.Sp
.Vb 4
\&    use Socket;
\&    socketpair(Rdr, Wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
\&    shutdown(Rdr, 1);        # plus d'e\*'criture pour le lecteur
\&    shutdown(Wtr, 0);        # plus de lecture pour l'e\*'crivain
.Ve
.Sp
Voir perlipc pour des exemples d'utilisation de socketpair. Perl 5.8 et
plus e\*'muleront socketpair en utilisant de sockets \s-1IP\s0 sur la machine locale si
votre syste\*`me imple\*'mente les sockets mais pas socketpair.
.IP "sort \s-1SUBNAME\s0 \s-1LISTE\s0" 8
.IX Item "sort SUBNAME LISTE"
.PD 0
.IP "sort \s-1BLOC\s0 \s-1LISTE\s0" 8
.IX Item "sort BLOC LISTE"
.IP "sort \s-1LISTE\s0" 8
.IX Item "sort LISTE"
.PD
Dans un contexte de liste, \f(CW\*(C`sort()\*(C'\fR trie \s-1LISTE\s0 et retourne la liste de
valeurs trie\*'e. Dans un contexte scalaire, le comportement de \f(CW\*(C`sort()\*(C'\fR est
inde\*'fini.
.Sp
Si \s-1SUBNAME\s0 et \s-1BLOC\s0 sont omis, le tri est effectue\*' dans l'ordre standard de
comparaison de chai\*^nes. Si \s-1SUBNAME\s0 est spe\*'cifie\*', il donne le nom d'une
subroutine qui retourne un entier plus petit, e\*'gal ou plus grand que \f(CW0\fR
selon l'ordre dans lequel les e\*'le\*'ments du tableau doivent e\*^tre trie\*'s. (Les
ope\*'rateurs \f(CW\*(C`<=>\*(C'\fR et \f(CW\*(C`cmp\*(C'\fR sont extre\*^mement utiles dans de telles
subroutines.) \s-1SUBNAME\s0 peut e\*^tre une variable scalaire, auquel cas sa valeur
donne le nom de (ou la re\*'fe\*'rence vers) la subroutine a\*` utiliser. A\*` la place de
\&\s-1SUBNAME\s0, vous pouvez fournir un \s-1BLOC\s0 comme subroutine de tri anonyme et en
ligne.
.Sp
Si le prototype de la subroutine est \f(CW\*(C`($$)\*(C'\fR, les e\*'le\*'ments a\*` comparer sont
passe\*'s par re\*'fe\*'rence dans \f(CW@_\fR comme pour une subroutine normale. C'est plus
lent qu'une subroutine sans prototype pour laquelle les e\*'le\*'ments a\*` comparer
sont passe\*'s a\*` la subroutine par les variables globales du package courant \f(CW$a\fR
et \f(CW$b\fR (voir exemples ci\-dessous). Dans ce dernier cas, il est contre-productif
de de\*'clarer \f(CW$a\fR et \f(CW$b\fR comme des variables lexicales.
.Sp
Dans tous les cas, la subroutine ne peut pas e\*^tre re\*'cursive. Les valeurs a\*`
comparer sont toujours passe\*'es par re\*'fe\*'rence. Donc, ne les modifiez pas.
.Sp
Vous ne pouvez pas non plus sortir du bloc sort ou de la subroutine en
utilisant un \f(CW\*(C`goto()\*(C'\fR ou les ope\*'rateurs de contro\*^le de boucles de\*'crits dans
perlsyn.
.Sp
Lorsque \f(CW\*(C`use locale\*(C'\fR est actif, \f(CW\*(C`sort LISTE\*(C'\fR trie \s-1LISTE\s0 selon l'ordre
(collation) du locale courant. Voir perllocale.
.Sp
Jusqu'a\*` Perl 5.6, Perl utilisait un algorithme quicksort pour imple\*'menter le
tri. Cet algorithme n'e\*'tait pas stable et \fIpouvait\fR parfois e\*^tre
quadratique. (Un tri \fIstable\fR pre\*'serve l'ordre des e\*'le\*'ments e\*'gaux. De plus,
bien que la complexite\*' moyenne d'un quicksort soit en O(NlogN) pour un tableau
de taille N, la complexite\*' peut atteindre O(N**2), un comportement
quadratique, pour certains tableaux.) En Perl 5.7, l'imple\*'mentation du
quicksort a e\*'te\*' remplace\*'e par un algorithme stable mergesort dont la complexite\*'
est O(NlogN). Mais des tests de performance ont montre\*' que, dans certains cas
et sur certaines plateformes, quicksort e\*'tait plus rapide. Perl 5.8 propose
donc une directive sort afin de choisir l'imple\*'mentation. Mais cela n'est pas
satisfaisant et disparai\*^tra dans de futures versions. Voir \*(L"use\*(R".
.Sp
Exemples\ :
.Sp
.Vb 2
\&    # tri alphabe\*'tique
\&    @articles = sort @files;
\&
\&    # idem mais avec une routine de tri explicite
\&    @articles = sort {$a cmp $b} @files;
\&
\&    # idem mais inde\*'pendant de la casse
\&    @articles = sort {uc($a) cmp uc($b)} @files;
\&
\&    # idem mais dans l'ordre inverse
\&    @articles = sort {$b cmp $a} @files;
\&
\&    # tri nume\*'rique ascendant
\&    @articles = sort {$a <=> $b} @files;
\&
\&    # tri nume\*'rique descendant
\&    @articles = sort {$b <=> $a} @files;
\&
\&    # tri de %age par valeur pluto\*^t que par cle\*'
\&    # en utilisant une fonction en\-ligne
\&    @eldest = sort { $age{$b} <=> $age{$a} } keys %age;
\&
\&    # tri utilisant le nom explicite d'une subroutine
\&    sub byage {
\&        $age{$a} <=> $age{$b};  # suppose\*' nume\*'rique
\&    }
\&    @sortedclass = sort byage @class;
\&
\&    sub backwards { $b cmp $a; }
\&    @harry  = qw(dog cat x Cain Abel);
\&    @george = qw(gone chased yz Punished Axed);
\&    print sort @harry;
\&            # affiche AbelCaincatdogx
\&    print sort backwards @harry;
\&            # affiche xdogcatCainAbel
\&    print sort @george, 'to', @harry;
\&            # affiche AbelAxedCainPunishedcatchaseddoggonetoxyz
\&
\&    # tri inefficace par ordre nume\*'rique descendant utilisant
\&    # le premier entier apre\*`s le signe = ou l'ensemble de
\&    # l'enregistrement si cet entier n'existe pas
\&
\&    @new = sort {
\&        ($b =~ /=(\ed+)/)[0] <=> ($a =~ /=(\ed+)/)[0]
\&                            ||
\&                    uc($a)  cmp  uc($b)
\&    } @old;
\&
\&    # la me\*^me chose mais plus efficace;
\&    # nous construisons un tableau auxiliaire d'indices
\&    # pour aller plus vite
\&    @nums = @caps = ();
\&    for (@old) {
\&        push @nums, /=(\ed+)/;
\&        push @caps, uc($_);
\&    }
\&
\&    @new = @old[ sort {
\&                        $nums[$b] <=> $nums[$a]
\&                                 ||
\&                        $caps[$a] cmp $caps[$b]
\&                       } 0..$#old
\&               ];
\&
\&    # me\*^me chose sans utiliser de variables temporaires
\&    @new = map { $_\->[0] }
\&        sort { $b\->[1] <=> $a\->[1]
\&                        ||
\&               $a\->[2] cmp $b\->[2]
\&        } map { [$_, /=(\ed+)/, uc($_)] } @old;
\&
\&    # l'utilisation d'un prototype vous permet d'utiliser
\&    # n'importe quelle subroutine de comparaison comme
\&    # subroutine de tri (y compris des subroutines d'autres packages)
\&    package other;
\&    sub backwards ($$) { $_[1] cmp $_[0]; }     # $a and $b are not set here
\&
\&    package main;
\&    @new = sort other::backwards @old;
\&
\&    # tri stable, sans choix de l'algorithme
\&    use sort 'stable';
\&    @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
\&
\&    # utilisation force\*'e d'un mergesort (non portable en dehors de Perl 5.8)
\&    use sort '_mergesort';  # notez le _ de\*'courageant
\&    @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
.Ve
.Sp
Si vous utilisez strict, vous \fI\s-1NE\s0 \s-1DEVEZ\s0 \s-1PAS\s0\fR de\*'clarer \f(CW$a\fR et \f(CW$b\fR comme
variables lexicales. Ce sont des variables globales au package. Cela signifie
que si vous e\*^tes dans le package \f(CW\*(C`main\*(C'\fR, c'est\ :
.Sp
.Vb 1
\&    @articles = sort {$main::b <=> $main::a} @files;
.Ve
.Sp
ou juste\ :
.Sp
.Vb 1
\&    @articles = sort {$::b <=> $::a} @files;
.Ve
.Sp
mais si vous e\*^tes dans le package \f(CW\*(C`FooPack\*(C'\fR, <c'est :>
.Sp
.Vb 1
\&    @articles = sort {$FooPack::b <=> $FooPack::a} @files;
.Ve
.Sp
La fonction de comparaison doit se comporter correctement. Si elle retourne
des re\*'sultats incohe\*'rents (parfois elle dit que \f(CW$x[1]\fR est plus petit que
\&\f(CW$x[2]\fR et d'autres fois le contraire par exemple), le re\*'sultat du tri n'est
pas bien de\*'fini.
.IP "splice \s-1TABLEAU\s0,OFFSET,LONGUEUR,LISTE" 8
.IX Item "splice TABLEAU,OFFSET,LONGUEUR,LISTE"
.PD 0
.IP "splice \s-1TABLEAU\s0,OFFSET,LONGUEUR" 8
.IX Item "splice TABLEAU,OFFSET,LONGUEUR"
.IP "splice \s-1TABLEAU\s0,OFFSET" 8
.IX Item "splice TABLEAU,OFFSET"
.IP "splice \s-1TABLEAU\s0" 8
.IX Item "splice TABLEAU"
.PD
Supprime d'un tableau les e\*'le\*'ments conse\*'cutifs de\*'signe\*'s par \s-1OFFSET\s0 (indice du
premier e\*'le\*'ment) et \s-1LONGUEUR\s0 (nombre d'e\*'le\*'ments concerne\*'s) et les remplace par
les e\*'le\*'ments de \s-1LISTE\s0 si il y en a. Dans un contexte de liste, renvoie les
e\*'le\*'ments supprime\*'s du tableau. Dans un contexte scalaire, renvoie le dernier
e\*'le\*'ment supprime\*' ou \f(CW\*(C`undef\*(C'\fR si aucun e\*'le\*'ment n'est supprime\*'. Le tableau
grossit ou diminue si ne\*'cessaire. Si \s-1OFFSET\s0 est ne\*'gatif, il est compte\*' a\*`
partir de la fin du tableau. Si \s-1LONGUEUR\s0 est omis, supprime tout a\*` partir de
\&\s-1OFFSET\s0. Si \s-1LONGUEUR\s0 est ne\*'gatif, supprime les e\*'le\*'ments a\*` partir de \s-1OFFSET\s0 en
laissant \-LONGUEUR e\*'le\*'ments a\*` la fin du tableau. Si \s-1OFFSET\s0 et \s-1LONGUEUR\s0 sont
omis, supprime tout ce qui est dans le tableau. Si \s-1OFFSET\s0 va au\-dela\*` de la fin
du tableau, perl produit un message d'avertissement et splice agit a\*` la fin du
tableau.
.Sp
Les e\*'quivalences suivantes sont vraies en supposant que \f(CW\*(C`$[\ ==\ 0\*(C'\fR\ :
.Sp
.Vb 5
\&    push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
\&    pop(@a)             splice(@a,\-1)
\&    shift(@a)           splice(@a,0,1)
\&    unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
\&    $a[$x] = $y         splice(@a,$x,1,$y)
.Ve
.Sp
Exemple, en supposant que la longueur des tableaux est passe\*'e avant chaque
tableau\ :
.Sp
.Vb 10
\&    sub aeq {   # compare deux listes de valeurs
\&        my(@a) = splice(@_,0,shift);
\&        my(@b) = splice(@_,0,shift);
\&        return 0 unless @a == @b;       # me\*^me longueur ?
\&        while (@a) {
\&            return 0 if pop(@a) ne pop(@b);
\&        }
\&        return 1;
\&    }
\&    if (&aeq($len,@foo[1..$len],0+@bar,@bar)) { ... }
.Ve
.IP "split /MOTIF/,EXPR,LIMITE" 8
.IX Item "split /MOTIF/,EXPR,LIMITE"
.PD 0
.IP "split /MOTIF/,EXPR" 8
.IX Item "split /MOTIF/,EXPR"
.IP "split /MOTIF/" 8
.IX Item "split /MOTIF/"
.IP "split" 8
.IX Item "split"
.PD
De\*'coupe une chai\*^ne en une liste de chai\*^nes et la retourne. Par de\*'faut, les
champs vides du de\*'but sont conserve\*'s et ceux de la fin sont e\*'limine\*'s.
.Sp
Si l'appel n'est pas dans un contexte de liste, split retourne le nombre de
champs trouve\*'s et les place dans le tableau \f(CW@_\fR. (Dans un contexte de liste,
vous pouvez forcer l'utilisation du tableau \f(CW@_\fR en utilisant \f(CW\*(C`??\*(C'\fR comme
motif de\*'limiteur mais il renvoie encore la liste des valeurs.) En revanche,
l'utilisation implicite de \f(CW@_\fR par split est de\*'sapprouve\*'e parce que cela
e\*'crase les arguments de votre subroutine.
.Sp
\&\s-1SI\s0 \s-1EXPR\s0 est omis, split de\*'coupe la chai\*^ne \f(CW$_\fR. Si \s-1MOTIF\s0 est aussi omis, il
de\*'coupe selon les blancs (apre\*`s avoir saute\*' d'e\*'ventuels blancs au
de\*'part). Tout ce qui reconnu par \s-1MOTIF\s0 est conside\*'re\*' comme e\*'tant un de\*'limiteur
de champs. (Remarquez que le de\*'limiteur peut e\*^tre plus long qu'un seul
caracte\*`re.)
.Sp
Si \s-1LIMITE\s0 est spe\*'cifie\*' et positif, fixe le nombre maximum de champs du
de\*'coupage (le nombre de champs de\*'pend du nombre de fois ou\*` le \s-1MOTIF\s0 sera
reconnu dans \s-1EXPR\s0). Si \s-1LIMITE\s0 n'est pas spe\*'cifie\*' ou vaut ze\*'ro, les champs
vides de la fin sont supprime\*'s (chose dont les utilisateurs potentiels de
\&\f(CW\*(C`pop()\*(C'\fR devraient se souvenir). Si \s-1LIMITE\s0 est ne\*'gatif, il est traite\*' comme si
\&\s-1LIMITE\s0 avait une valeur arbitrairement tre\*`s grande. Notez que de\*'couper une
\&\s-1EXPR\s0 dont la valeur est la chai\*^ne vide retourne toujours une liste vide, que
\&\s-1LIMIT\s0 soit spe\*'cifie\*' ou non.
.Sp
Un motif qui peut correspondre a\*` la chai\*^ne vide (ne pas confondre avec le
motif vide \f(CW\*(C`//\*(C'\fR qui n'est qu'un motif parmi tous ceux qui peuvent
correspondre a\*` la chai\*^ne vide) de\*'coupera la valeur de \s-1EXPR\s0 en caracte\*`re se\*'pare\*'
a\*` chaque point ou\*` il sera reconnu. Par exemple\ :
.Sp
.Vb 1
\&    print join(':', split(/ */, 'hi there'));
.Ve
.Sp
produira la sortie 'h:i:t:h:e:r:e'.
.Sp
Un champ vide de de\*'but (ou de fin) n'est produit que lorsqu'il y a
reconnaissance du \s-1MOTIF\s0 avec une longueur positive au de\*'but (a\*` la fin) de la
chai\*^ne. Une reconnaissance de longueur nulle en de\*'but ou en fin de chai\*^ne ne
produira pas de champs vide. Par exemple\ :
.Sp
.Vb 1
\&    print join(':', split(/(?=\ew)/, 'hi there!'));
.Ve
.Sp
produira la sortie  'h:i :t:h:e:r:e!'.
.Sp
Le parame\*`tre \s-1LIMITE\s0 peut e\*^tre utilise\*' pour de\*'couper partiellement une ligne\ :
.Sp
.Vb 1
\&    ($login, $passwd, $remainder) = split(/:/, $_, 3);
.Ve
.Sp
Lors de l'affectation a\*` une liste, si \s-1LIMITE\s0 est omis, Perl agit comme si
\&\s-1LIMITE\s0 e\*'tait e\*'gal au nombre de variables de la liste plus un pour e\*'viter tout
travail inutile. Pour la liste ci\-dessous, la valeur par de\*'faut de \s-1LIMITE\s0
serait 4. Dans les applications ou\*` le temps est critique, il vous incombe de
ne pas de\*'couper en plus de champs que ceux re\*'ellement ne\*'cessaires.
.Sp
Si \s-1MOTIF\s0 contient des parenthe\*`ses (et donc des sous\-motifs), un e\*'le\*'ment
supple\*'mentaire est cre\*'e\*' dans le tableau re\*'sultat pour chaque chai\*^ne reconnue
par le sous\-motif.
.Sp
.Vb 1
\&    split(/([,\-])/, "1\-10,20", 3);
.Ve
.Sp
produit la liste de valeurs
.Sp
.Vb 1
\&    (1, '\-', 10, ',', 20)
.Ve
.Sp
Si vous avez dans la variable \f(CW$header\fR tout l'en\-te\*^te d'un email normal
d'\s-1UNIX\s0, vous devriez pouvoir le de\*'couper en champs et valeurs en proce\*'dant
comme suit\ :
.Sp
.Vb 2
\&    $header =~ s/\en\es+/ /g;  # fix continuation lines
\&    %hdrs   =  (UNIX_FROM => split /^(\eS*?):\es*/m, $header);
.Ve
.Sp
Le motif \f(CW\*(C`/MOTIF/\*(C'\fR peut e\*^tre remplace\*' par une expression pour spe\*'cifier un
motif qui varie a\*` chaque passage. (Pour faire une compilation une seule fois
lors de l'exe\*'cution, utilisez \f(CW\*(C`/$variable/o\*(C'\fR.)
.Sp
Un cas spe\*'cial\ : spe\*'cifier un blanc (\f(CW' '\fR) comme \s-1MOTIF\s0 de\*'coupe selon les
espaces exactement comme le fait \f(CW\*(C`split()\*(C'\fR sans argument. Donc, \f(CW\*(C`split(' ')\*(C'\fR
peut e\*^tre utilise\*' pour e\*'muler le comportement par de\*'faut de \fBawk\fR alors que
\&\f(CW\*(C`split(/ /)\*(C'\fR vous donnera autant de champs vides que d'espaces au de\*'but. Un
\&\f(CW\*(C`split()\*(C'\fR avec \f(CW\*(C`/\es+/\*(C'\fR est comme \f(CW\*(C`split(' ')\*(C'\fR sauf dans le cas de blancs au
de\*'but qui produiront un premier champ vide. Un \f(CW\*(C`split()\*(C'\fR sans argument
effectue re\*'ellement un \f(CW\*(C`split(' ', $_)\*(C'\fR en interne.
.Sp
Un \s-1MOTIF\s0 \f(CW\*(C`/^/\*(C'\fR sera traite\*' comme si c'e\*'tait \f(CW\*(C`/^/m\*(C'\fR sinon il ne serait
d'aucune utilite\*'.
.Sp
Exemple\ :
.Sp
.Vb 7
\&    open(PASSWD, '/etc/passwd');
\&    while (<PASSWD>) {
\&        chomp;
\&        ($login, $passwd, $uid, $gid,
\&         $gcos, $home, $shell) = split(/:/);
\&        #...
\&    }
.Ve
.Sp
Comme dans le cas de la reconnaissance d'expressions rationnelles, tout
sous-groupe me\*'morise\*' non reconnue durant le \f(CW\*(C`split()\*(C'\fR produira un \f(CW\*(C`undef\*(C'\fR\ :
.Sp
.Vb 2
\&     @fields = split /(A)|B/, "1A2B3";
\&     # @fields est (1, 'A', 2, undef, 3)
.Ve
.IP "sprintf \s-1FORMAT\s0, \s-1LISTE\s0" 8
.IX Item "sprintf FORMAT, LISTE"
Retourne une chai\*^ne formate\*'e selon les conventions usuelles de la fonction
\&\f(CW\*(C`sprintf()\*(C'\fR de la bibliothe\*`que C. Voir ci-dessous et \fIsprintf\fR\|(3) ou
\&\fIprintf\fR\|(3) sur votre syste\*`me pour une explication sur les principes
ge\*'ne\*'raux.
.Sp
Par exemple\ :
.Sp
.Vb 2
\&         # Produire un nombre avec jusqu'a\*` 8 ze\*'ros devant
\&         $result = sprintf("%08d", $number);
\& 
\&         # Arrondir un nombre a\*` la troisie\*`me de\*'cimale
\&         $rounded = sprintf("%.3f", $number);
.Ve
.Sp
Perl a sa propre imple\*'mentation de \f(CW\*(C`sprintf()\*(C'\fR \*(-- elle e\*'mule la fonction C
\&\f(CW\*(C`sprintf()\*(C'\fR mais elle ne l'utilise pas (sauf pour les nombres en virgule
flottante, et encore en n'autorisant que les modificateurs
standards). Conse\*'quence\ : une extension non standard de votre version
locale de \f(CW\*(C`sprintf()\*(C'\fR ne sera pas disponible en Perl.
.Sp
Au contraire de \f(CW\*(C`printf\*(C'\fR, \f(CW\*(C`sprintf\*(C'\fR ne fera probablement pas ce que vous
voulez si vous lui passez un tableau comme premier argument. Ce tableau sera
e\*'value\*' dans un contexte scalaire et, au lieu d'utiliser le premier e\*'le\*'ment du
tableau comme \s-1FORMAT\s0, Perl utilisera le nombre d'e\*'le\*'ments de ce tableau comme
\&\s-1FORMAT\s0, ce qui n'est pas vraiment utilisable.
.Sp
Le \f(CW\*(C`sprintf()\*(C'\fR de Perl autorise les conversions universellement connues\ :
.Sp
.Vb 10
\&   %%   un signe pourcent
\&   %c   un caracte\*`re dont on fournit le code
\&   %s   une chai\*^ne
\&   %d   un entier signe\*', en de\*'cimal
\&   %u   un entier non\-signe\*', en de\*'cimal
\&   %o   un entier non\-signe\*', en octal
\&   %x   un entier non\-signe\*', en hexade\*'cimal
\&   %e   un nombre en virgule flottante, en notation scientifique
\&   %f   un nombre en virgule flottante, avec un nombre de de\*'cimales fixe
\&   %g   un nombre en virgule flottante, %e ou %f (au mieux)
.Ve
.Sp
De plus, Perl autorise les conversions largement supporte\*'es\ :
.Sp
.Vb 7
\&   %X   comme %x mais avec des lettres majuscules
\&   %E   comme %e, mais en utilisant un "E" majuscule
\&   %G   comme %g, mais en utilisant un "E" majuscule (si ne\*'cessaire)
\&   %b   un entier non signe\*', en binaire
\&   %p   un pointeur (affiche la valeur Perl de l'adresse en hexade\*'cimal)
\&   %n   spe\*'cial: stocke le nombre de caracte\*`res produits dans la
\&        prochaine variable de la liste des parame\*`tres
.Ve
.Sp
Et finalement, pour des raisons de compatibilite\*' (et \*(L"uniquement\*(R" pour cela),
Perl autorise les conversions inutiles mais largement supporte\*'es\ :
.Sp
.Vb 5
\&   %i   un synonyme de %d
\&   %D   un synonyme de %ld
\&   %U   un synonyme de %lu
\&   %O   un synonyme de %lo
\&   %F   un synonyme de %f
.Ve
.Sp
Notez que le nombre de chiffres utilise\*'s pour l'exposant en notation
scientifique produit par \f(CW%e\fR, \f(CW%E\fR, \f(CW%g\fR et \f(CW%G\fR lorsque cet exposant est
infe\*'rieur a\*` 100 de\*'pend du syste\*`me\ : c\*,a peut e\*^tre 3 chiffres ou moins (avec
d'e\*'ventuels ze\*'ros initiaux). En d'autres termes, 1,23 multiplie\*' par 10 a\*` la
puissance 99 peut e\*^tre \*(L"1.23e99\*(R" ou \*(L"1.23e099\*(R".
.Sp
Entre le \f(CW\*(C`%\*(C'\fR et la lettre de format, vous pouvez spe\*'cifier un certain nombre
d'attributs supple\*'mentaires qui permettent de contro\*^ler l'interpre\*'tation du
format. Dans l'ordre, on trouve\ :
.RS 8
.IP "un index de choix de parame\*`tre" 4
.IX Item "un index de choix de parame`tre"
Un index de choix explicite de parame\*`tre tel que \f(CW\*(C`2$\*(C'\fR. Par de\*'faut, sprintf
formatera le prochain argument inutilise\*' de la liste mais cela vous permet de
choisir votre argument sans respecter cet ordre. Exemple\ :
.Sp
.Vb 2
\&   printf '%2$d %1$d', 12, 34;      # affiche "34 12"
\&   printf '%3$d %d %1$d', 1, 2, 3;  # affiche "3 1 1"
.Ve
.IP "des flags" 4
.IX Item "des flags"
un ou plusieurs flags parmi\ :
.Sp
.Vb 6
\&   espace   pre\*'ce\*`de les nombres positifs par un espace
\&   +        pre\*'ce\*`de les nombres positifs par un signe plus
\&   \-        justifie le champ a\*` gauche
\&   0        utilise des ze\*'ros a\*` la place des espaces pour justifier a\*` droite
\&   #        pre\*'ce\*`de le nombre non nul en octal par "0",
\&            en hexade\*'cimal par "0x" et en binaire par "0b"
.Ve
.Sp
Par exemple\ :
.Sp
.Vb 6
\&   printf '<% d>', 12;   # affiche "< 12>"
\&   printf '<%+d>', 12;   # affiche "<+12>"
\&   printf '<%6s>', 12;   # affiche "<    12>"
\&   printf '<%\-6s>', 12;  # affiche "<12    >"
\&   printf '<%06s>', 12;  # affiche "<000012>"
\&   printf '<%#x>', 12;   # affiche "<0xc>"
.Ve
.IP "des flags vectoriels" 4
.IX Item "des flags vectoriels"
Le flag vectoriel et optionnel \f(CW\*(C`v\*(C'\fR spe\*'cifie le chai\*^ne de jointure a\*`
utiliser. Ce flag indique a\*` perl d'interpre\*'ter le chai\*^ne fournie comme un
vecteur d'entier, un pour chaque caracte\*`re dans la chai\*^ne, se\*'pare\*' par un
chai\*^ne donne\*'e (un point \f(CW\*(C`.\*(C'\fR par de\*'faut). C'est pratique pour afficher des
valeurs ou des caracte\*`res ordinaux dans des chai\*^nes quelconques\ :
.Sp
.Vb 1
\&   printf "version is v%vd\en", $^V; # La version de Perl
.Ve
.Sp
Placez un aste\*'risque \f(CW\*(C`*\*(C'\fR avant le \f(CW\*(C`v\*(C'\fR pour changer la chai\*^ne utilise\*'e comme
se\*'parateur de nombres\ :
.Sp
.Vb 2
\&   printf "address is %*vX\en", ":", $addr;   # adresse IPv6
\&   printf "bits are %0*v8b\en", " ", $bits;   # une chai\*^ne de bits quelconque
.Ve
.Sp
Vous pouvez aussi spe\*'cifier explicitement le nume\*'ro d'argument a\*` utiliser
comme chai\*^ne de se\*'parateur\ :
.Sp
.Vb 1
\&   printf '%*4$vX %*4$vX %*4$vX', @addr[1..3], ":";   # 3 adresses IPv6
.Ve
.IP "largeur (minimale)" 4
.IX Item "largeur (minimale)"
Les arguments sont habituellement formate\*'s pour utiliser juste la place
ne\*'cessaire a\*` la repre\*'sentation de la valeur. Vous pouvez forcer la largeur en
plac\*,ant directement un nombre ou en obtenant la largeur depuis l'argument
suivant (via \f(CW\*(C`*\*(C'\fR) ou me\*^me depuis un argument spe\*'cifique (via \f(CW\*(C`*2$\*(C'\fR)\ :
.Sp
.Vb 5
\&   printf '<%s>', "a";       # affiche "<a>"
\&   printf '<%6s>', "a";      # affiche "<     a>"
\&   printf '<%*s>', 6, "a";   # affiche "<     a>"
\&   printf '<%*2$s>', "a", 6; # affiche "<     a>"
\&   printf '<%2s>', "long";   # affiche "<long>" (ne tronque pas)
.Ve
.Sp
Si la largeur obtenue par \f(CW\*(C`*\*(C'\fR est ne\*'gative, cela a le me\*^me effet que le flag
\&\f(CW\*(C`\-\*(C'\fR\ : une justification a\*` gauche.
.IP "pre\*'cision, ou largeur maximale" 4
.IX Item "pre'cision, ou largeur maximale"
Vous pouvez pre\*'ciser la pre\*'cision (pour les conversions nume\*'riques) ou la
largeur maximale (pour les conversions de chai\*^nes) en spe\*'cifiant un \f(CW\*(C`.\*(C'\fR suivi
d'un nombre. Pour les nombres en virgule flottante, cela indique le nombre de
de\*'cimales a\*` afficher. Exemple\ :
.Sp
.Vb 6
\&   # ces exemples peuvent varier selon le syste\*`me
\&   printf '<%f>', 1;    # affiche "<1.000000>"
\&   printf '<%.1f>', 1;  # affiche "<1.0>"
\&   printf '<%.0f>', 1;  # affiche "<1>"
\&   printf '<%e>', 10;   # affiche "<1.000000e+01>"
\&   printf '<%.1e>', 10; # affiche "<1.0e+01>"
.Ve
.Sp
Pour les nombres entiers, la spe\*'cification d'une pre\*'cision indique la largeur
du nombre a\*` afficher. Il sera e\*'ventuellement pre\*'ce\*'de\*' de ze\*'ros pour atteindre
cette largeur\ :
.Sp
.Vb 3
\&   printf '<%.6x>', 1;      # affiche "<000001>"
\&   printf '<%#.6x>', 1;     # affiche "<0x000001>"
\&   printf '<%\-10.6x>', 1;   # affiche "<000001    >"
.Ve
.Sp
Pour les conversions de chai\*^nes, la spe\*'cification d'une pre\*'cision tronquera la
chai\*^ne pour qu'elle tienne dans cette longueur maximale\ :
.Sp
.Vb 2
\&   printf '<%.5s>', "truncated";   # affiche "<trunc>"
\&   printf '<%10.5s>', "truncated"; # affiche "<     trunc>"
.Ve
.Sp
Vous pouvez aussi re\*'cupe\*'rer la valeur de pre\*'cision dans le prochain argument
via \f(CW\*(C`.*\*(C'\fR\ :
.Sp
.Vb 2
\&   printf '<%.6x>', 1;       # affiche "<000001>"
\&   printf '<%.*x>', 6, 1;    # affiche "<000001>"
.Ve
.Sp
Ce n'est pas encore faisable mais une future version proposera de re\*'cupe\*'rer la
pre\*'cision dans un argument choisi en utilisant par exemple \f(CW\*(C`.*2$\*(C'\fR\ :
.Sp
.Vb 1
\&   printf '<%.*2$x>', 1, 6;   # INVALIDE, mais affichera un jour "<000001>"
.Ve
.IP "taille" 4
.IX Item "taille"
Pour les conversions nume\*'riques, vous pouvez pre\*'ciser la taille a\*` utiliser
pour interpre\*'ter le nombre en utilisant \f(CW\*(C`l\*(C'\fR, \f(CW\*(C`h\*(C'\fR, \f(CW\*(C`V\*(C'\fR, \f(CW\*(C`q\*(C'\fR, \f(CW\*(C`L\*(C'\fR ou
\&\f(CW\*(C`ll\*(C'\fR. Pour les conversions d'entiers, on suppose que la taille est celle
utilise\*'e par de\*'faut par votre syste\*`me pour un entier (habituellement 32 ou 64
bits). Mais vous pouvez changer cela en pre\*'cisant vous\-me\*^me un type standard C
(l'un de ceux connus du compilateur ayant compile\*' Perl) a\*` utiliser a\*` la
place\ :
.Sp
.Vb 8
\&   l           interpre\*`te un entier comme e\*'tant
\&               du type C "long" ou "unsigned long"
\&   h           interpre\*`te un entier comme e\*'tant
\&               du type C "short" ou "unsigned short"
\&   q, L ou ll  interpre\*`te un entier comme e\*'tant
\&               du type C "long long" ou "unsigned long long"
\&               (si votre plateforme reconnai\*^t ces types, sinon
\&               c'est une erreur)
.Ve
.Sp
Pour les conversions de nombres a\*` virgule flottante, on suppose que le nombre
est du type utilise\*' par de\*'faut sur votre syste\*`me (double ou long double). Mais
vous pouvez contraindre l'usage des 'long double' gra\*^ce a\*` \f(CW\*(C`q\*(C'\fR, \f(CW\*(C`L\*(C'\fR ou \f(CW\*(C`ll\*(C'\fR
si votre plateforme connai\*^t ce type.
.Sp
Le spe\*'cificateur de taille 'V' n'a aucun effet pour le code Perl mais il est
accepte\*' pour des raisons de compatibilite\*' avec du code \s-1XS\s0\ ; il signifie
X\ utilise la taille standard pour un entier (ou un nombre en virgule
flottante) Perl\ X, ce qui est de\*'ja\*` le cas par de\*'faut dans le code Perl.
.IP "l'ordre des arguments" 4
.IX Item "l'ordre des arguments"
Normalement, sprintf utilise le premier argument encore inutilise\*' comme valeur
a\*` formater pour chaque spe\*'cification de format. Si cette spe\*'cification utilise
\&\f(CW\*(C`*\*(C'\fR pour utiliser des arguments supple\*'mentaires, ils sont pris dans la liste
d'arguments dans l'ordre ou\*` ils apparaissent dans la spe\*'cification \fIavant\fR la
valeur elle\-me\*^me. Lorsqu'un argument est spe\*'cifie\*' en utilisant un index
explicite, cela ne modifie en rien l'ordre d'utilisation normal des arguments.
.Sp
Donc\ :
.Sp
.Vb 1
\&   printf '<%*.*s>', $a, $b, $c;
.Ve
.Sp
devrait utiliser \f(CW$a\fR pour la largeur, \f(CW$b\fR pour la pre\*'cision et \f(CW$c\fR
comme valeur a\*` formater alors que\ :
.Sp
.Vb 1
\&   print '<%*1$.*s>', $a, $b;
.Ve
.Sp
devrait utiliser \f(CW$a\fR comme largeur et comme pre\*'cision et \f(CW$b\fR comme valeur
a\*` formater.
.Sp
Voici quelques exemples supple\*'mentaires \- notez bien que pour utiliser les
index explicites, il faut parfois prote\*'ger le \f(CW\*(C`$\*(C'\fR\ :
.Sp
.Vb 4
\&   printf "%2\e$d %d\en",    12, 34;             # affichera "34 12\en"
\&   printf "%2\e$d %d %d\en", 12, 34;             # affichera "34 12 34\en"
\&   printf "%3\e$d %d %d\en", 12, 34, 56;         # affichera "56 12 34\en"
\&   printf "%2\e$*3\e$d %d\en", 12, 34, 3;         # affichera " 34 12\en"
.Ve
.RE
.RS 8
.Sp
Si \f(CW\*(C`use locale\*(C'\fR est actif, le caracte\*`re utilise\*' comme se\*'parateur de\*'cimal pour
les nombres re\*'els de\*'pend de la valeur de \s-1LC_NUMERIC\s0. Voir perllocale.
.RE
.IP "sqrt \s-1EXPR\s0" 8
.IX Item "sqrt EXPR"
.PD 0
.IP "sqrt" 8
.IX Item "sqrt"
.PD
Renvoie la racine carre\*'e de \s-1EXPR\s0. Si \s-1EXPR\s0 est omis, retourne la racine carre\*'e
de \f(CW$_\fR. Ne fonctionne que sur les ope\*'randes non ne\*'gatifs a\*` moins que vous
n'ayez charge\*' le module standard Math::Complex.
.Sp
.Vb 2
\&    use Math::Complex;
\&    print sqrt(\-2);    # affiche 1.4142135623731i
.Ve
.IP "srand \s-1EXPR\s0" 8
.IX Item "srand EXPR"
.PD 0
.IP "srand" 8
.IX Item "srand"
.PD
Fixe la graine ale\*'atoire pour l'ope\*'rateur \f(CW\*(C`rand()\*(C'\fR.
.Sp
La seule utilite\*' de cette fonction est d'initialiser la fonction \f(CW\*(C`rand\*(C'\fR pour
que cette dernie\*`re produise une se\*'quence diffe\*'rente a\*` chaque exe\*'cution de
votre programme.
.Sp
Si \fIsrand()\fR n'est pas appele\*' explicitement, il l'est implicitement lors de la
premie\*`re utilisation de l'ope\*'rateur \f(CW\*(C`rand()\*(C'\fR. Par contre, ce n'e\*'tait pas le
cas dans les versions de Perl ante\*'rieures a\*` la version 5.004 et donc, si votre
script doit pouvoir tourner avec de vieilles versions de Perl, il doit appeler
\&\f(CW\*(C`srand()\*(C'\fR.
.Sp
La plupart des programmes n'ont pas besoins d'appeler \fIsrand()\fR. Seuls le feront
ceux ayant besoin d'une graine cryptographiquement forte puisqu'ils ne peuvent
se satisfaire de la valeur par de\*'faut calcule\*'e en fonction de l'heure
courante, du nume\*'ro de processus et de l'allocation me\*'moire ou en fonction du
device \fI/dev/urandom\fR lorsqu'il est disponible.
.Sp
Vous pouvez appeler srand($graine) avec la me\*^me \f(CW$graine\fR pour que \fIrand()\fR
reproduise la \fIme\*^me\fR se\*'quence mais cela est re\*'serve\*' a\*` la production de
donne\*'es pre\*'visibles afin de faciliter les tests et le debogage.
.Sp
N'appelez \fBpas\fR \fIsrand()\fR (sans argument) plus d'une fois par exe\*'cution de
votre script. L'e\*'tat interne du ge\*'ne\*'rateur de nombres ale\*'atoires devrait
contenir plus d'entropie que celle fournie par une graine quelconque. Donc un
nouvel appel a\*` \fIsrand()\fR ne peut qu'amener a\*` \fIperdre\fR de l'ale\*'a.
.Sp
La plupart des imple\*'mentations de \f(CW\*(C`srand\*(C'\fR utilise un entier et ignoreront
silencieusement une e\*'ventuelle partie de\*'cimale. Cela signifie que l'appel
\&\f(CW\*(C`srand(42)\*(C'\fR produira le me\*^me re\*'sultat que l'appel \f(CW\*(C`srand(42.1)\*(C'\fR. Pour e\*^tre
correct, passez toujours un entier a\*` \f(CW\*(C`srand\*(C'\fR.
.Sp
Dans les versions de Perl ante\*'rieures a\*` la version 5.004, la valeur par de\*'faut
e\*'tait juste \f(CW\*(C`time()\*(C'\fR. Ce n'est pas une graine particulie\*`rement bonne et donc
de nombreux programmes anciens fournissaient leur propre valeur de graine
(souvent \f(CW\*(C`time ^ $$\*(C'\fR ou \f(CW\*(C`time ^ ($$ + ($$ << 15))\*(C'\fR) mais ce n'est
plus ne\*'cessaire maintenant.
.Sp
Remarque\ : vous devez utiliser quelque chose de beaucoup plus ale\*'atoire que
la graine par de\*'faut pour des applications de cryptographie. Le checksum d'une
sortie compresse\*'e d'un ou plusieurs programmes syste\*`me dont les valeurs
changent rapidement est une me\*'thode usuelle. Par exemple\ :
.Sp
.Vb 1
\&    srand (time ^ $$ ^ unpack "%L*", `ps axww | gzip`);
.Ve
.Sp
Si cela vous inte\*'resse tout particulie\*`rement, regardez le module \s-1CPAN\s0
\&\f(CW\*(C`Math::TrulyRandom\*(C'\fR.
.Sp
Les programmes fre\*'quemment utilise\*'s (comme des scripts \s-1CGI\s0) qui utilisent
simplement\ :
.Sp
.Vb 1
\&    time ^ $$
.Ve
.Sp
comme graine peuvent tomber sur la proprie\*'te\*' mathe\*'matique suivante\ :
.Sp
.Vb 1
\&    a^b == (a+1)^(b+1)
.Ve
.Sp
une fois sur trois. Donc ne faites pas c\*,a.
.IP "stat \s-1DESCRIPTEUR\s0" 8
.IX Item "stat DESCRIPTEUR"
.PD 0
.IP "stat \s-1EXPR\s0" 8
.IX Item "stat EXPR"
.IP "stat" 8
.IX Item "stat"
.PD
Retourne une liste de 13 e\*'le\*'ments donnant des informations sur l'e\*'tat soit du
fichier dont le nom est donne\*' par \s-1EXPR\s0 soit du fichier ouvert par
\&\s-1DESCRIPTEUR\s0. Si \s-1EXPR\s0 est omis, retourne l'e\*'tat de \f(CW$_\fR. Retourne une liste
vide en cas d'e\*'chec. Typiquement utilise\*' de la manie\*`re suivante\ :
.Sp
.Vb 3
\&    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
\&       $atime,$mtime,$ctime,$blksize,$blocks)
\&           = stat($filename);
.Ve
.Sp
Certains champs ne sont pas ge\*'re\*'s par certains types de syste\*`mes de
fichiers. Voici la signification de ces champs\ :
.Sp
.Vb 10
\&  0 dev      nume\*'ro de device du syste\*`me de fichiers
\&  1 ino      nume\*'ro d'inode
\&  2 mode     droits du fichier (type et permissions)
\&  3 nlink    nombre de liens (hard) sur le fichier
\&  4 uid      ID nume\*'rique de l'utilisateur proprie\*'taire du fichier
\&  5 gid      ID nume\*'rique du groupe proprie\*'taire du fichier
\&  6 rdev     l'identificateur de device (fichiers spe\*'ciaux uniquement)
\&  7 size     taille totale du fichier, en octets
\&  8 atime    date de dernier acce\*`s en secondes depuis l'origine des temps
\&  9 mtime    date de dernie\*`re modification en secondes depuis
\&             l'origine des temps
\& 10 ctime    date de dernie\*`re modification de l'inode en secondes
\&             depuis l'origine des temps (*)
\& 11 blksize  taille de blocs pre\*'fe\*'re\*'e pour les E/S sur fichiers
\& 12 blocks   nombre de blocs re\*'ellement occupe\*'s
.Ve
.Sp
(Sur la plupart des syste\*`mes, l'origine des temps est fixe\*'e au 1er janvier 1970
a\*` minuit \s-1GMT\s0.)
.Sp
(*) Le champ ctime n'est pas portable. En particulier, ne comptez pas dessus
pour repre\*'senter une X\ date de cre\*'ation\ X.
Voir \*(L"Fichiers\*(R" in perlport pour plus de de\*'tails.
.Sp
Si vous passez a\*` stat le descripteur spe\*'cial dont le nom est le caracte\*`re
souligne\*' seul, aucun appel a\*` stat n'est effectue\*' par contre le contenu courant
de la structure d'e\*'tat du dernier appel a\*` stat ou du dernier test de fichier
est retourne\*'. Exemple\ :
.Sp
.Vb 3
\&    if (\-x $file && (($d) = stat(_)) && $d < 0) {
\&        print "$file is executable NFS file\en";
\&    }
.Ve
.Sp
(Ceci ne marche que sur les machines dont le nume\*'ro de device est ne\*'gatif sous
\&\s-1NFS\s0.)
.Sp
Comme le mode contient a\*` la fois le type de fichier et les droits d'acce\*`s,
vous devrez masquer la portion concernant le type de fichier et utiliser
(s)printf avec le format \f(CW"%o"\fR pour voir les ve\*'ritables permissions\ :
.Sp
.Vb 2
\&    $mode = (stat($filename))[2];
\&    printf "Permissions are %04o\en", $mode & 07777;
.Ve
.Sp
Dans un contexte scalaire, \f(CW\*(C`stat()\*(C'\fR retourne une valeur boole\*'enne indiquant
le succe\*`s ou l'e\*'chec et positionne, en cas de succe\*`s, les informations
lie\*' au descripteur spe\*'cial \f(CW\*(C`_\*(C'\fR.
.Sp
Le module File::stat fournit un me\*'canisme pratique d'acce\*`s par nom\ :
.Sp
.Vb 5
\&    use File::stat;
\&    $sb = stat($filename);
\&    printf "File is %s, size is %s, perm %04o, mtime %s\en", 
\&        $filename, $sb\->size, $sb\->mode & 07777,
\&        scalar localtime $sb\->mtime;
.Ve
.Sp
Vous pouvez importer les constantes symboliques de permissions (\f(CW\*(C`S_IF*\*(C'\fR) et
les fonctions de test (\f(CW\*(C`S_IS*\*(C'\fR) depuis le module Fcntl\ :
.Sp
.Vb 1
\&    use Fcntl ':mode';
\&
\&    $mode = (stat($filename))[2];
\&
\&    $user_rwx      = ($mode & S_IRWXU) >> 6;
\&    $group_read    = ($mode & S_IRGRP) >> 3;
\&    $other_execute =  $mode & S_IXOTH;
\&
\&    printf "Permissions are %04o\en", S_ISMODE($mode), "\en";
\&
\&    $is_setuid     =  $mode & S_ISUID;
\&    $is_setgid     =  S_ISDIR($mode);
.Ve
.Sp
Vous pourriez e\*'crire ces deux derniers exemples en utilisant les ope\*'rateurs
\&\f(CW\*(C`\-u\*(C'\fR et \f(CW\*(C`\-d\*(C'\fR. Les constantes communes disponibles sont\ :
.Sp
.Vb 2
\&    # Droits : lecture, e\*'criture, exe\*'cution,
\&    # pour utilisateur, groupe, autres.
\&
\&    S_IRWXU S_IRUSR S_IWUSR S_IXUSR
\&    S_IRWXG S_IRGRP S_IWGRP S_IXGRP
\&    S_IRWXO S_IROTH S_IWOTH S_IXOTH
\&
\&    # Setuid/Setgid/Stickiness.
\&
\&    S_ISUID S_ISGID S_ISVTX S_ISTXT
\&
\&    # File types.  Not necessarily all are available on your system.
\&
\&    S_IFREG S_IFDIR S_IFLNK S_IFBLK S_ISCHR S_IFIFO S_IFSOCK S_IFWHT S_ENFMT
\&
\&    # The following are compatibility aliases for S_IRUSR, S_IWUSR, S_IXUSR.
\&
\&    S_IREAD S_IWRITE S_IEXEC
.Ve
.Sp
et les fonctions S_IF* <sont :>
.Sp
.Vb 2
\&    S_IFMODE($mode)     the part of $mode contaning the permission bits
\&                        and the setuid/setgid/sticky bits
\&
\&    S_IFMT($mode)       the part of $mode containing the file type
\&                        which can be bit\-anded with e.g. S_IFREG 
\&                        or with the following functions
\&
\&    # The operators \-f, \-d, \-l, \-b, \-c, \-p, and \-s.
\&
\&    S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode)
\&    S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode)
\&
\&    # No direct \-X operator counterpart, but for the first one
\&    # the \-g operator is often equivalent.  The ENFMT stands for
\&    # record flocking enforcement, a platform\-dependent feature.
\&
\&    S_ISENFMT($mode) S_ISWHT($mode)
.Ve
.Sp
Voir la documentation native de \fIchmod\fR\|(2) et de \fIstat\fR\|(2) pour de meilleures
informations au sujet des constantes S_*.
.IP "study \s-1SCALAIRE\s0" 8
.IX Item "study SCALAIRE"
.PD 0
.IP "study" 8
.IX Item "study"
.PD
Prend du temps supple\*'mentaire pour e\*'tudier (study) la chai\*^ne \s-1SCALAIRE\s0 (ou
\&\f(CW$_\fR si \s-1SCALAIRE\s0 est omis) afin d'anticiper de nombreuses recherches
d'expressions rationnelles sur elle avant sa prochaine modification. Cela peut
ame\*'liorer ou non le temps de recherche selon la nature et le nombre de motifs
que vous recherchez et selon la fre\*'quence de distribution des caracte\*`res dans
la chai\*^ne \*(-- vous devriez probablement comparer les temps d'exe\*'cution avec et
sans pour savoir quand cela est plus rapide. Les boucles qui recherchent de
nombreuses petites chai\*^nes constantes (me\*^me celles comprises dans des motifs
plus complexes) en be\*'ne\*'ficient le plus. Il ne peut y avoir qu'un seul
\&\f(CW\*(C`study()\*(C'\fR actif a\*` la fois \*(-- si vous e\*'tudiez un autre scalaire, le pre\*'ce\*'dent
est \*(L"oublie\*'\*(R". (\f(CW\*(C`study()\*(C'\fR fonctionne de la manie\*`re suivante\ : on construit
une liste chai\*^ne\*'e de tous les caracte\*`res de la chai\*^ne a\*` e\*'tudier ce qui permet
de savoir, par exemple, ou\*` se trouve tous les \f(CW'k'\fR. Dans chaque chai\*^ne
recherche\*'e, on choisit le caracte\*`re le plus rare en se basant sur une table de
fre\*'quences construite a\*` partir de programmes C et de textes anglais. Seuls
sont examine\*'s les endroits qui contiennent ce caracte\*`re \*(L"rare\*(R".)
.Sp
Par\ exemple\ : voici la boucle qui inse\*`re une entre\*'e d'index devant chaque ligne
contenant un certain motif\ :
.Sp
.Vb 8
\&    while (<>) {
\&        study;
\&        print ".IX foo\en" if /\ebfoo\eb/;
\&        print ".IX bar\en" if /\ebbar\eb/;
\&        print ".IX blurfl\en" if /\ebblurfl\eb/;
\&        # ...
\&        print;
\&    }
.Ve
.Sp
Lors de la recherche de \f(CW\*(C`/\ebfoo\eb/\*(C'\fR, seuls sont examine\*'s les endroits de
\&\f(CW$_\fR contenant \f(CW\*(C`f\*(C'\fR parce que \f(CW\*(C`f\*(C'\fR est plus rare que \f(CW\*(C`o\*(C'\fR. En ge\*'ne\*'ral, le
gain est important sauf dans des cas pathologiques. Savoir si l'e\*'tude initiale
est moins cou\*^teuse que le temps gagne\*' lors de la recherche est la seule vraie
question.
.Sp
Remarquez que si vous faites une recherche sur des chai\*^nes que vous ne
connaissez que lors de l'exe\*'cution, vous pouvez alors construire une boucle
entie\*`re dans une chai\*^ne que vous e\*'valuerez via \f(CW\*(C`eval()\*(C'\fR afin d'e\*'viter de
recompiler vos motifs a\*` chaque passage. Combine\*' avec l'affectation de undef a\*`
\&\f(CW$/\fR pour lire chaque fichier comme un seul enregistrement, cela peut e\*^tre
extre\*^mement rapide et parfois me\*^me plus rapide que des programmes spe\*'cialise\*'s
comme \fIfgrep\fR\|(1). Le code suivant recherche une liste de mots (\f(CW@words\fR) dans
une liste de fichiers (\f(CW@files\fR) et affiche la liste des fichiers qui
contiennent ces mots\ :
.Sp
.Vb 12
\&    $search = 'while (<>) { study;';
\&    foreach $word (@words) {
\&        $search .= "++\e$seen{\e$ARGV} if /\e\eb$word\e\eb/;\en";
\&    }
\&    $search .= "}";
\&    @ARGV = @files;
\&    undef $/;
\&    eval $search;               # ca parle...
\&    $/ = "\en";          # retour au de\*'limiteur de ligne normal
\&    foreach $file (sort keys(%seen)) {
\&        print $file, "\en";
\&    }
.Ve
.IP "sub \s-1NOM\s0 \s-1BLOC\s0" 8
.IX Item "sub NOM BLOC"
.PD 0
.IP "sub \s-1NOM\s0 (\s-1PROTO\s0) \s-1BLOC\s0" 8
.IX Item "sub NOM (PROTO) BLOC"
.IP "sub \s-1NOM\s0 : \s-1ATTRS\s0 \s-1BLOC\s0" 8
.IX Item "sub NOM : ATTRS BLOC"
.IP "sub \s-1NOM\s0 (\s-1PROTO\s0) : \s-1ATTRS\s0 \s-1BLOC\s0" 8
.IX Item "sub NOM (PROTO) : ATTRS BLOC"
.PD
C'est la de\*'finition de subroutine. Pas vraiment une fonction en tant que
telle. Avec juste le nom \s-1NOM\s0 (et un e\*'ventuel prototype), c'est une simple
de\*'claration pre\*'alable. Sans \s-1NOM\s0, c'est la de\*'claration d'une fonction anonyme
et cela retourne une valeur\ : la re\*'fe\*'rence du \s-1CODE\s0 de la fermeture que vous
venez de cre\*'er.
.Sp
Voir perlsub et perlref pour plus de de\*'tails sur les subroutines et les
re\*'fe\*'rences et attributes et Attribute::Handlers pour plus de de\*'tails au
sujet des attributs (\s-1ATTRS\s0).
.IP "substr \s-1EXPR\s0,OFFSET,LONGUEUR,REMPLACEMENT" 8
.IX Item "substr EXPR,OFFSET,LONGUEUR,REMPLACEMENT"
.PD 0
.IP "substr \s-1EXPR\s0,OFFSET,LONGUEUR" 8
.IX Item "substr EXPR,OFFSET,LONGUEUR"
.IP "substr \s-1EXPR\s0,OFFSET" 8
.IX Item "substr EXPR,OFFSET"
.PD
Extrait une sous\-chai\*^ne de \s-1EXPR\s0 et la retourne. Le premier caracte\*`re est a\*`
l'indice \f(CW0\fR ou a\*` ce que vous avez fixe\*' par \f(CW$[\fR (mais ne le faites pas). Si
\&\s-1OFFSET\s0 est ne\*'gatif (ou plus pre\*'cise\*'ment plus petit que \f(CW$[\fR), le compte a
lieu a\*` partir de la fin de la chai\*^ne. Si \s-1LONGUEUR\s0 est omis, retourne tous les
caracte\*`res jusqu'a\*` la fin de la chai\*^ne. Si \s-1LONGUEUR\s0 est ne\*'gatif, il indique le
nombre de caracte\*`res a\*` laisser a\*` la fin de la chai\*^ne.
.Sp
Vous pouvez utiliser la fonction \f(CW\*(C`substr()\*(C'\fR comme une lvalue auquel cas \s-1EXPR\s0
doit aussi e\*^tre une lvalue. Si vous affectez quelque chose de plus court que
\&\s-1LONGUEUR\s0, la chai\*^ne raccourcit et si vous affectez quelque chose de plus long
que \s-1LONGUEUR\s0, la chai\*^ne grossit. Pour conserver la me\*^me longueur vous pouvez
remplir ou couper votre valeur en utilisant \f(CW\*(C`sprintf()\*(C'\fR.
.Sp
Si \s-1OFFSET\s0 et \s-1LONGUEUR\s0 spe\*'cifient une sous\-chai\*^ne qui est partiellement en
dehors de la chai\*^ne, seule la partie qui est dans la chai\*^ne qui est
retourne\*'e. Si la sous\-chai\*^ne est entie\*`rement en dehors de la chai\*^ne, un
message d'avertissement (warning) est produit et la valeur undef est
retourne\*'e. Lorsque \fIsubstr()\fR est utilise\*' en tant que lvalue, spe\*'cifier une
sous\-chai\*^ne entie\*`rement en dehors de la chai\*^ne produit une erreur
fatale. Voici un exemple illustrant ce comportement\ :
.Sp
.Vb 5
\&    my $name = 'fred';
\&    substr($name, 4) = 'dy';            # $name vaut maintenant 'freddy'
\&    my $null = substr $name, 6, 2;      # retourne '' (sans avertissement)
\&    my $oops = substr $name, 7;         # retourne undef, avec avertissement
\&    substr($name, 7) = 'gap';           # erreur fatale
.Ve
.Sp
Un autre moyen d'utiliser \f(CW\*(C`substr()\*(C'\fR comme lvalue est de spe\*'cifier la chai\*^ne
de remplacement comme quatrie\*`me argument (\s-1REMPLACEMENT\s0). Ceci permet de
remplacer une partie de la chai\*^ne en re\*'cupe\*'rant ce qui y e\*'tait auparavant en
une seule ope\*'ration exactement comme avec \fIsplice()\fR.
.IP "symlink \s-1OLDFILE\s0,NEWFILE" 8
.IX Item "symlink OLDFILE,NEWFILE"
Cre\*'e un nouveau fichier (\s-1NEWFILE\s0) lie\*' symboliquement au vieux fichier
(\s-1OLDFILE\s0). Retourne \f(CW1\fR en cas de succe\*`s ou \f(CW0\fR autrement. Produit une
erreur fatale lors de l'exe\*'cution sur les syste\*`mes qui ne supportent pas les
liens symboliques. Pour ve\*'rifier cela, utilisez eval\ :
.Sp
.Vb 1
\&    $symlink_exists =  eval { symlink("",""); 1 };
.Ve
.IP "syscall \s-1LISTE\s0" 8
.IX Item "syscall LISTE"
Re\*'alise l'appel syste\*`me spe\*'cifie\*' comme premier e\*'le\*'ment de la liste en lui
passant les e\*'le\*'ments restants comme arguments. Cela produit une erreur fatale
s'il n'est pas imple\*'mente\*'. Les arguments sont interpre\*'te\*'s de la manie\*`re
suivante\ : si un argument donne\*' est nume\*'rique, il est passe\*' comme un
entier. Sinon, c'est le pointeur vers la valeur de la chai\*^ne qui est
passe\*'. Vous avez la charge de vous assurer qu'une chai\*^ne est de\*'ja\*` assez longue
pour recevoir un re\*'sultat qui pourrait y e\*^tre e\*'crit. Vous ne pouvez pas
utiliser de chai\*^ne litte\*'rale (ou autres chai\*^ne en lecture seule) comme
argument de \f(CW\*(C`syscall()\*(C'\fR parce que Perl s'assure qu'il est possible d'e\*'crire
dans toutes les chai\*^nes dont il passe les pointeurs. Si votre argument
nume\*'rique n'est pas un litte\*'ral et n'a jamais e\*'te\*' interpre\*'te\*' dans un contexte
nume\*'rique. vous pouvez lui ajouter \f(CW0\fR pour forcer Perl a\*` le voir comme un
nombre. Le code suivant e\*'mule la fonction \f(CW\*(C`syswrite()\*(C'\fR :
.Sp
.Vb 3
\&    require 'syscall.ph';  # peut ne\*'cessiter de faire tourner h2ph
\&    $s = "hi there\en";
\&    syscall(&SYS_write, fileno(STDOUT), $s, length $s);
.Ve
.Sp
Remarquez que Perl ne peut pas passer plus de 14 arguments a\*` votre appel
syste\*`me, ce qui en pratique suffit largement.
.Sp
Syscall retourne la valeur retourne\*'e par l'appel syste\*`me appele\*'. Si l'appel
syste\*`me e\*'choue, \f(CW\*(C`syscall()\*(C'\fR retourne \f(CW\*(C`\-1\*(C'\fR et positionne \f(CW$!\fR
(errno). Remarquez que certains appels syste\*`mes peuvent le\*'gitimement retourner
\&\f(CW\*(C`\-1\*(C'\fR. Le seul moyen de ge\*'rer cela proprement est de faire \f(CW\*(C`$!=0\*(C'\fR avant
l'appel syste\*`me et de regarder la valeur de \f(CW$!\fR lorsque syscall retourne
\&\f(CW\*(C`\-1\*(C'\fR.
.Sp
Il y a un proble\*`me avec \f(CW\*(C`syscall(&SYS_pipe)\*(C'\fR\ : cela retourne le nume\*'ro du
fichier cre\*'e\*' co\*^te\*' lecture du tube. Il n'y a aucun moyen de re\*'cupe\*'rer le nume\*'ro
de fichier de l'autre co\*^te\*'. Vous pouvez contourner ce proble\*`me en utilisant
\&\f(CW\*(C`pipe()\*(C'\fR a\*` la place.
.IP "sysopen \s-1DESCRIPTEUR\s0,FILENAME,MODE" 8
.IX Item "sysopen DESCRIPTEUR,FILENAME,MODE"
.PD 0
.IP "sysopen \s-1DESCRIPTEUR\s0,FILENAME,MODE,PERMS" 8
.IX Item "sysopen DESCRIPTEUR,FILENAME,MODE,PERMS"
.PD
Ouvre le fichier dont le nom est donne\*' par \s-1FILENAME\s0 et l'associe avec
\&\s-1DESCRIPTEUR\s0. Si \s-1DESCRIPTEUR\s0 est une expression, sa valeur repre\*'sente le nom du
ve\*'ritable descripteur a\*` utiliser. Cette fonction appelle la fonction \f(CW\*(C`open()\*(C'\fR
du syste\*`me sous-jacent avec les parame\*`tres \s-1FILENAME\s0, \s-1MODE\s0 et \s-1PERMS\s0.
.Sp
Les valeurs possibles des bits du parame\*`tre \s-1MODE\s0 sont de\*'pendantes du syste\*`me\ ;
elles sont disponibles via le module standard \f(CW\*(C`Fcntl\*(C'\fR. Lisez la documentation
du \f(CW\*(C`open\*(C'\fR de votre syste\*`me d'exploitation pour savoir quels sont les bits
disponibles. Vous pouvez combiner plusieurs valeurs en utilisant l'ope\*'rateur
\&\f(CW\*(C`|\*(C'\fR.
.Sp
Quelques-unes des valeurs les plus courantes sont \f(CW\*(C`O_RDONLY\*(C'\fR pour l'ouverture
en lecture seule, \f(CW\*(C`O_WRONLY\*(C'\fR pour l'ouverture en e\*'criture seule, et \f(CW\*(C`O_RDWR\*(C'\fR
pour l'ouverture en mode lecture/e\*'criture.
.Sp
Pour des raisons historiques, quelques valeurs fonctionnent sur la plupart des
syste\*`mes supporte\*'s par perl\ : ze\*'ro signifie lecture seule, un signifie
e\*'criture seule et deux signifie lecture/e\*'criture. Nous savons que ces valeurs
\&\fIne\fR fonctionnent \fIpas\fR sous Unix \s-1OS/390\s0 ou sur Macintosh\ ; vous ne devriez
sans doute pas les utiliser dans du code nouveau.
.Sp
Si le fichier nomme\*' \s-1FILENAME\s0 n'existe pas et que l'appel a\*` \f(CW\*(C`open()\*(C'\fR le cre\*'e
(typiquement parce que \s-1MODE\s0 inclut le flag \f(CW\*(C`O_CREAT\*(C'\fR) alors la valeur de \s-1PERM\s0
spe\*'cifie les droits de ce nouveau fichier. Si vous avez omis l'argument \s-1PERM\s0
de \f(CW\*(C`sysopen()\*(C'\fR, Perl utilise la valeur octale \f(CW0666\fR. Les valeurs de droits
doivent e\*^tre fournies en octal et sont modifie\*'es par la valeur courante du
\&\f(CW\*(C`umask\*(C'\fR de votre process.
.Sp
Sur la plupart des syste\*`mes, le flag \f(CW\*(C`O_EXCL\*(C'\fR permet d'ouvrir un fichier en
mode exclusif. Ce n'est \fBpas\fR du verrouillage\ : l'exclusivite\*' signifie ici
que si le fichier existe de\*'ja\*`, \fIsysopen()\fR e\*'choue. \f(CW\*(C`O_EXCL\*(C'\fR l'emporte sur
\&\f(CW\*(C`O_TRUNC\*(C'\fR.
.Sp
Parfois vous voudrez tronquer un fichier existant\ : \f(CW\*(C`O_TRUNC\*(C'\fR.
.Sp
Vous devriez e\*'viter d'imposer un mode \f(CW0644\fR comme argument de \f(CW\*(C`sysopen\*(C'\fR
parce que cela enle\*`ve a\*` l'utilisateur la possibilite\*' de fixer un umask plus
permissif. Voir \*(L"umask\*(R" pour plus de de\*'tails.
.Sp
Notez que \f(CW\*(C`sysopen\*(C'\fR de\*'pend de la fonction \fIfdopen()\fR de votre bibliothe\*`que
C. Sur de nombreux syste\*`mes \s-1UNIX\s0, \fIfdopen()\fR est connue pour e\*'chouer si le
nombre de descripteurs de fichiers exce\*`de une certaine valeur, typiquement
255. Si vous avez besoin de plus de descripteurs, pensez a\*` recompiler Perl en
utilisant la bibliothe\*`que \f(CW\*(C`sfio\*(C'\fR ou a\*` utiliser la fonction \fIPOSIX::open()\fR.
.Sp
Voir perlopentut pour une initiation a\*` l'ouverture de fichiers.
.IP "sysread \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR,OFFSET" 8
.IX Item "sysread DESCRIPTEUR,SCALAIRE,LONGUEUR,OFFSET"
.PD 0
.IP "sysread \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR" 8
.IX Item "sysread DESCRIPTEUR,SCALAIRE,LONGUEUR"
.PD
Tente de lire \s-1LONGUEUR\s0 \fIcaracte\*`res\fR de donne\*'es a\*` partir du \s-1DESCRIPTEUR\s0
spe\*'cifie\*' en utilisant l'appel syste\*`me \fIread\fR\|(2). Les donne\*'es lues sont stocke\*'es
dans la variable \s-1SCALAIRE\s0. Comme cette fonction n'utilise pas les
entre\*'es/sorties bufferise\*'es, le me\*'lange avec d'autres sortes de
lecture/e\*'criture comme \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`write\*(C'\fR, \f(CW\*(C`seek\*(C'\fR, \f(CW\*(C`tell\*(C'\fR ou \f(CW\*(C`eof\*(C'\fR peut mal
se passer parce que habituellement PerlIO bufferise les donne\*'es. Retourne le
nombre de caracte\*`res re\*'ellement lus, \f(CW0\fR a\*` la fin du fichier ou undef en cas
d'erreur. \s-1SCALAIRE\s0 grossira ou re\*'duira afin que le dernier octet lu soit
effectivement le dernier octet du scalaire apre\*`s la lecture.
.Sp
Notez que l'on parle bien de \fIcaracte\*`res\fR\ : selon l'e\*'tat du \s-1DESCRIPTEUR\s0,
ce seront soit des octets (8\-bit) soit des caracte\*`res qui seront lus. Par
de\*'faut tous les DESCRIPTEURs ope\*`rent sur des octets mais si un DESCRIPTEURs a
e\*'te\*' ouvert en spe\*'cifiant le filtre d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR (voir la directive
\&\f(CW\*(C`open\*(C'\fR et open) alors les entre\*'es/sorties se feront sur des caracte\*`res et
non sur des octets.
.Sp
Un \s-1OFFSET\s0 peut e\*^tre spe\*'cifie\*' pour placer les donne\*'es lues ailleurs qu'au de\*'but
de la chai\*^ne. Un \s-1OFFSET\s0 ne\*'gatif spe\*'cifie un emplacement en comptant les
caracte\*`res a\*` partir de la fin de la chai\*^ne. Un \s-1OFFSET\s0 positif plus grand que
la longueur de \s-1SCALAIRE\s0 agrandira la chai\*^ne jusqu'a\*` la taille requise en la
remplissant avec des octets \f(CW"\e0"\fR avant de lui ajouter le re\*'sultat de la
lecture.
.Sp
Il n'y a pas de fonction \fIsyseof()\fR, ce qui n'est pas un mal puisque \fIeof()\fR ne
marche pas tre\*`s bien sur les fichiers device (comme les tty). Utilisez
\&\fIsysread()\fR et testez une valeur de retour a\*` ze\*'ro pour savoir si c'est termine\*'.
.IP "sysseek \s-1DESCRIPTEUR\s0,POSITION,WHENCE" 8
.IX Item "sysseek DESCRIPTEUR,POSITION,WHENCE"
Spe\*'cifie, en \fIoctets\fR, la position syste\*`me d'un \s-1DESCRIPTEUR\s0 en utilisant
l'appel syste\*`me \fIlseek\fR\|(2). \s-1DESCRIPTEUR\s0 peut e\*^tre une expression qui donne le
nom du descripteur a\*` utiliser. Les valeurs de \s-1WHENCE\s0 sont \f(CW0\fR pour mettre la
nouvelle position a\*` \s-1POSITION\s0, \f(CW1\fR pour la mettre a\*` la position courante plus
\&\s-1POSITION\s0 et \f(CW2\fR pour la mettre a\*` \s-1EOF\s0 plus \s-1POSITION\s0 (typiquement une valeur
ne\*'gative).
.Sp
Notez bien X\ en \fIoctets\fR\ X\ : me\*^me si le \s-1DESCRIPTEUR\s0 a e\*'te\*'
configure\*' pour ope\*'rer sur des caracte\*`res (en utilisant le filtre
d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR par exemple), \fItell()\fR retournera une position en
octets et non en caracte\*`res (l'imple\*'mentation d'une telle fonctionnalite\*'
aurait ralenti e\*'norme\*'ment \fIsysseek()\fR).
.Sp
\&\fIsysseek()\fR passe outre les tampons habituels d'entre\*'e/sortie. Donc le me\*'lange
avec d'autres sortes de lecture/e\*'criture (autre que \f(CW\*(C`sysread()\*(C'\fR) comme
\&\f(CW\*(C`print()\*(C'\fR, \f(CW\*(C`write()\*(C'\fR, \f(CW\*(C`seek()\*(C'\fR ou \f(CW\*(C`tell()\*(C'\fR peut tout casser.
.Sp
Pour \s-1WHENCE\s0, vous pouvez utiliser les constantes \f(CW\*(C`SEEK_SET\*(C'\fR, \f(CW\*(C`SEEK_CUR\*(C'\fR et
\&\f(CW\*(C`SEEK_END\*(C'\fR (de\*'but de fichier, position courante, fin de fichier) provenant du
module Fcntl. L'usage de ces constantes rend votre script plus portable. Voici
un exemple qui de\*'finit la fonction \*(L"systell\*(R"\ :
.Sp
.Vb 2
\&       use Fnctl 'SEEK_CUR';
\&       sub systell { sysseek($_[0], 0, SEEK_CUR) }
.Ve
.Sp
Retourne la nouvelle position ou undef en cas d'e\*'chec. Une position nulle est
retourne\*'e par la valeur \f(CW"0\ but\ true"\fR\ ; Donc \f(CW\*(C`sysseek()\*(C'\fR retourne true
(vrai) en cas de succe\*`s et false (faux) en cas d'e\*'chec et vous pouvez encore
de\*'terminer facilement la nouvelle position.
.IP "system \s-1LISTE\s0" 8
.IX Item "system LISTE"
.PD 0
.IP "system \s-1PROGRAMME\s0 \s-1LISTE\s0" 8
.IX Item "system PROGRAMME LISTE"
.PD
Fait exactement la me\*^me chose que \f(CW\*(C`exec LISTE\*(C'\fR sauf qu'un fork est effectue\*'
au pre\*'alable et que le process parent attend que son fils ait
termine\*'. Remarquez que le traitement des arguments de\*'pend de leur nombre. Si
il y a plus d'un argument dans \s-1LISTE\s0 ou si \s-1LISTE\s0 est un tableau avec plus
d'une valeur, system exe\*'cute le programme donne\*' comme premier argument avec
comme arguments ceux donne\*'s dans le reste de la liste. Si il n'y a qu'un seul
argument dans \s-1LISTE\s0 et s'il contient des me\*'ta\-caracte\*`res du shell, il est
passe\*' en entier au shell de commandes du syste\*`me pour e\*^tre interpre\*'te\*' (c'est
\&\f(CW\*(C`/bin/sh \-c\*(C'\fR sur les plates-formes Unix mais cela peut varier sur les
autres). Si il ne contient pas de me\*'ta\-caracte\*`res du shell, il est alors
de\*'coupe\*' en mots et passe\*' directement a\*` \f(CW\*(C`execvp()\*(C'\fR, ce qui est plus efficace.
.Sp
Depuis la version v5.6.0, Perl tente de vider les tampons de tous les fichiers
ouverts en e\*'criture avant d'effectuer une ope\*'ration impliquant un \fIfork()\fR mais
cela n'est pas supporte\*' sur toutes les plates-formes (voir perlport). Pour
e\*^tre plus su\*^r, vous devriez positionner la variable \f(CW$|\fR ($AUTOFLUSH en
anglais) ou appele\*' la me\*'thode \f(CW\*(C`autoflush()\*(C'\fR des objets \f(CW\*(C`IO::Handle\*(C'\fR pour
chacun des descripteurs ouverts.
.Sp
La valeur retourne\*'e est le statut de sortie (exit status) du programme tel que
retourne\*' par l'appel \f(CW\*(C`wait()\*(C'\fR. Pour obtenir la valeur re\*'elle de sortie, il
faut de\*'caler la valeur de retour de 8 bits vers la droite. Voir aussi
\&\*(L"exec\*(R". Ce n'est \fIpas\fR ce qu'il faut utiliser pour capturer la sortie d'une
commande. Pour cela, regarder les apostrophes inverse\*'es (backticks) ou \f(CW\*(C`qx//\*(C'\fR
comme de\*'crit dans \*(L"`CHAINE`\*(R" in perlop. Une valeur de retour \f(CW\*(C`\-1\*(C'\fR indique
l'e\*'chec du lancement du programme ($! en donne la raison).
.Sp
Comme \f(CW\*(C`exec()\*(C'\fR, \f(CW\*(C`system()\*(C'\fR vous autorise a\*` de\*'finir le nom sous lequel le
programme apparai\*^t si vous utilisez la syntaxe "\f(CW\*(C`system PROGRAMME
LISTE\*(C'\fR". Voir \*(L"exec\*(R".
.Sp
Puisque \f(CW\*(C`system()\*(C'\fR et les apostrophes inverse\*'es (backticks) bloquent
\&\f(CW\*(C`SIGINT\*(C'\fR et \f(CW\*(C`SIGQUIT\*(C'\fR, tuer le programme qu'ils font tourner n'interrompra
pas votre programme.
.Sp
.Vb 3
\&    @args = ("command", "arg1", "arg2");
\&    system(@args) == 0
\&         or die "system @args failed: $?"
.Ve
.Sp
Vous pouvez tester tous les cas possibles d'e\*'chec en analysant \f(CW$?\fR de la
manie\*`re suivante\ :
.Sp
.Vb 3
\&    $exit_value  = $? >> 8;
\&    $signal_num  = $? & 127;
\&    $dumped_core = $? & 128;
.Ve
.Sp
ou, de manie\*`re plus portable, en utilisant les appels W*() du module
\&\s-1POSIX\s0. Voir perlport pour plus d'information.
.Sp
Lorsque les arguments sont exe\*'cute\*'s via le shell syste\*`me, les re\*'sultats et
codes de retour sont sujet a\*` tous ses caprices et capacite\*'s. Voir
\&\*(L"`CHAINE`\*(R" in perlop et \*(L"exec\*(R" pour plus de de\*'tails.
.IP "syswrite \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR,OFFSET" 8
.IX Item "syswrite DESCRIPTEUR,SCALAIRE,LONGUEUR,OFFSET"
.PD 0
.IP "syswrite \s-1DESCRIPTEUR\s0,SCALAIRE,LONGUEUR" 8
.IX Item "syswrite DESCRIPTEUR,SCALAIRE,LONGUEUR"
.IP "syswrite \s-1DESCRIPTEUR\s0,SCALAIRE" 8
.IX Item "syswrite DESCRIPTEUR,SCALAIRE"
.PD
Essaye d'e\*'crire \s-1LONGUEUR\s0 caracte\*`res provenant de la variable \s-1SCALAIRE\s0 sur le
\&\s-1DESCRIPTEUR\s0 spe\*'cifie\*' en utilisant l'appel syste\*`me \fIwrite\fR\|(2). Si \s-1LONGUEUR\s0 n'est
pas spe\*'cifie\*', c'est le contenu complet de \s-1SCALAIRE\s0 qui est e\*'crit. Passe outre
la bibliothe\*`que stdio. Donc le me\*'lange avec d'autres sortes de
lecture/e\*'criture (autre que \f(CW\*(C`sysread()\*(C'\fR) comme \f(CW\*(C`print()\*(C'\fR, \f(CW\*(C`write()\*(C'\fR,
\&\f(CW\*(C`seek()\*(C'\fR ou \f(CW\*(C`tell()\*(C'\fR peut mal se passer parce que habituellement stdio
bufferise les donne\*'es. Retourne le nombre de caracte\*`res re\*'ellement e\*'crits ou
\&\f(CW\*(C`undef\*(C'\fR en cas d'erreur. Si \s-1LONGUEUR\s0 est plus grand que la quantite\*' de
donne\*'es disponibles dans \s-1SCALAIRE\s0 apre\*`s \s-1OFFSET\s0, seules les donne\*'es disponibles
sont e\*'crites.
.Sp
Un \s-1OFFSET\s0 peut e\*^tre spe\*'cifie\*' pour lire les donne\*'es a\*` e\*'crire a\*` partir d'autre
chose que le de\*'but du scalaire. Un \s-1OFFSET\s0 ne\*'gatif calcule l'emplacement en
comptant les caracte\*`res a\*` partir de la fin de la chai\*^ne. Au cas ou\*` \s-1SCALAIRE\s0
est vide, vous pouvez utiliser \s-1OFFSET\s0 mais uniquement avec la valeur ze\*'ro.
.Sp
Notez que l'on parle bien de \fIcaracte\*`res\fR\ : selon l'e\*'tat du \s-1DESCRIPTEUR\s0,
ce seront soit des octets (8\-bit) soit des caracte\*`res qui seront lus. Par
de\*'faut tous les DESCRIPTEURs ope\*`rent sur des octets mais si un \s-1DESCRIPTEUR\s0 a
e\*'te\*' modifie\*' via \fIbinmode()\fR pour utiliser le filtre d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR
(voir la directive \f(CW\*(C`open\*(C'\fR dans open) alors les entre\*'es/sorties se feront
sur des caracte\*`res et non sur des octets.
.IP "tell \s-1DESCRIPTEUR\s0" 8
.IX Item "tell DESCRIPTEUR"
.PD 0
.IP "tell" 8
.IX Item "tell"
.PD
Retourne la position courante en \fIoctets\fR de \s-1DESCRIPTEUR\s0 ou \-1 en cas
d'erreur. \s-1DESCRIPTEUR\s0 peut e\*^tre une expression dont la valeur donne le nom du
descripteurs re\*'el. Si \s-1DESCRIPTEUR\s0 est omis, on utilise le dernier fichier lu.
.Sp
Notez bien X\ en \fIoctets\fR\ X\ : me\*^me si le \s-1DESCRIPTEUR\s0 a e\*'te\*'
configure\*' pour ope\*'rer sur des caracte\*`res (en utilisant le filtre
d'entre\*'e/sortie \f(CW\*(C`:utf8\*(C'\fR par exemple), \fItell()\fR retournera une position en
octets et non en caracte\*`res (l'imple\*'mentation d'une telle fonctionnalite\*'
aurait ralenti e\*'norme\*'ment \fItell()\fR).
.Sp
Il n'y a pas de fonction \f(CW\*(C`systell\*(C'\fR. Utilisez \f(CW\*(C`sysseek(FH, 0, 1)\*(C'\fR a\*` la place.
.Sp
N'utilisez pas \fItell()\fR sur des DESCRIPTEURs qui ont e\*'te\*' ouverts via
\&\fIsysopen()\fR. Utilisez \fIsysseek()\fR pour cela. Pourquoi ? Parce que \fIsysopen()\fR cre\*'e
des DESCRIPTEURs sans bufferisation alors que \fIopen()\fR utilise la
bufferisation. \fIsysseek()\fR n'a un sens que dans le premier cas et \fItell()\fR que
dans le second.
.IP "telldir \s-1DIRHANDLE\s0" 8
.IX Item "telldir DIRHANDLE"
Retourne la position courante du dernier \f(CW\*(C`readdir()\*(C'\fR effectue\*' sur
\&\s-1DIRHANDLE\s0. La valeur retourne\*'e peut e\*^tre fournie a\*` \f(CW\*(C`seekdir()\*(C'\fR pour acce\*'der a\*`
un endroit particulier dans ce re\*'pertoire. Pose les me\*^mes proble\*`mes que
l'appel syste\*`me correspondant.
.IP "tie \s-1VARIABLE\s0,CLASSNAME,LISTE" 8
.IX Item "tie VARIABLE,CLASSNAME,LISTE"
Cette fonction relie une variable a\*` une classe d'un package qui fournit
l'imple\*'mentation de cette variable. \s-1VARIABLE\s0 est le nom de la variable a\*`
relier. \s-1CLASSNAME\s0 est le nom de la classe imple\*'mentant les objets du type
correct. Tout argument supple\*'mentaire est passe\*' tel quel a\*` la me\*'thode
"\f(CW\*(C`new()\*(C'\fR" de la classe (a\*` savoir \f(CW\*(C`TIESCALAR\*(C'\fR, \f(CW\*(C`TIEARRAY\*(C'\fR ou
\&\f(CW\*(C`TIEHASH\*(C'\fR). Typiquement, ce sont des arguments tels que ceux passe\*'s a\*` la
fonction C \f(CW\*(C`dbm_open()\*(C'\fR. L'objet retourne\*' par la me\*'thode "\f(CW\*(C`new()\*(C'\fR" est aussi
retourne\*' par la fonction \f(CW\*(C`tie()\*(C'\fR ce qui est pratique si vous voulez acce\*'der a\*`
d'autres me\*'thodes de \s-1CLASSNAME\s0.
.Sp
Remarquez que des fonctions telles que \f(CW\*(C`keys()\*(C'\fR et \f(CW\*(C`values()\*(C'\fR peuvent
retourner des listes e\*'normes lorsqu'elles sont utilise\*'es sur de gros objets
comme des fichiers \s-1DBM\s0. Vous devriez pluto\*^t utiliser la fonction \f(CW\*(C`each()\*(C'\fR
pour les parcourir. Exemple\ :
.Sp
.Vb 7
\&    # print out history file offsets
\&    use NDBM_File;
\&    tie(%HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
\&    while (($key,$val) = each %HIST) {
\&        print $key, ' = ', unpack('L',$val), "\en";
\&    }
\&    untie(%HIST);
.Ve
.Sp
Une classe imple\*'mentant une table de hachage devrait de\*'finir les me\*'thodes
suivantes\ :
.Sp
.Vb 10
\&    TIEHASH classname, LISTE
\&    FETCH this, key
\&    STORE this, key, value
\&    DELETE this, key
\&    CLEAR this
\&    EXISTS this, key
\&    FIRSTKEY this
\&    NEXTKEY this, lastkey
\&    DESTROY this
\&    UNTIE this
.Ve
.Sp
Une classe imple\*'mentant un tableau devrait de\*'finir les me\*'thodes suivantes\ :
.Sp
.Vb 10
\&    TIEARRAY classname, LISTE
\&    FETCH this, key
\&    STORE this, key, value
\&    FETCHSIZE this
\&    STORESIZE this, count
\&    CLEAR this
\&    PUSH this, LISTE
\&    POP this
\&    SHIFT this
\&    UNSHIFT this, LISTE
\&    SPLICE this, offset, length, LISTE
\&    EXTEND this, count
\&    DESTROY this
\&    UNTIE this
.Ve
.Sp
Une classe imple\*'mentant un descripteur de fichier devrait de\*'finir les me\*'thodes
suivantes\ :
.Sp
.Vb 10
\&    TIEHANDLE classname, LISTE
\&    READ this, scalar, length, offset
\&    READLINE this
\&    GETC this
\&    WRITE this, scalar, length, offset
\&    PRINT this, LISTE
\&    PRINTF this, format, LISTE
\&    BINMODE this
\&    EOF this
\&    FILENO this
\&    SEEK this, position, whence
\&    TELL this
\&    OPEN this, mode, LIST
\&    CLOSE this
\&    DESTROY this
\&    UNTIE this
.Ve
.Sp
Une classe imple\*'mentant un scalaire devrait de\*'finir les me\*'thodes suivantes\ :
.Sp
.Vb 5
\&    TIESCALAR classname, LISTE
\&    FETCH this
\&    STORE this, value
\&    DESTROY this
\&    UNTIE this
.Ve
.Sp
Il n'est pas absolument ne\*'cessaire d'imple\*'menter toutes les me\*'thodes de\*'crites
ci\-dessus. Voir perltie, Tie::Hash, Tie::Array, Tie::Scalar, et
Tie::Handle.
.Sp
Au contraire de \f(CW\*(C`dbmopen()\*(C'\fR, la fonction \f(CW\*(C`tie()\*(C'\fR n'effectue pas pour vous le
\&'use' ou le 'require' du module \*(-- vous devez le faire vous\-me\*^me
explicitement. Voir les modules \fIDB_File\fR ou \fIConfig\fR pour des utilisations
inte\*'ressantes de \f(CW\*(C`tie()\*(C'\fR.
.Sp
Pour de plus amples informations, voir perltie et \*(L"tied \s-1VARIABLE\s0\*(R".
.IP "tied \s-1VARIABLE\s0" 8
.IX Item "tied VARIABLE"
Retourne une re\*'fe\*'rence vers l'objet cache\*' derrie\*`re \s-1VARIABLE\s0 (la me\*^me valeur
que celle retourne\*'e par l'appel \f(CW\*(C`tie()\*(C'\fR qui a lie\*' cette variable a\*` un
package). Retourne la valeur undef si \s-1VARIABLE\s0 n'est pas lie\*' a\*` un package.
.IP "time" 8
.IX Item "time"
Retourne le nombre de secondes e\*'coule\*'es depuis ce que le syste\*`me conside\*`re
comme e\*'tant l'origine des temps (C'est le 1er janvier 1904 a\*` minuit pour Mac
\&\s-1OS\s0 et le 1er janvier 1970 a\*` minuit pour la plupart des autres syste\*`mes). Peut
servir comme argument de \f(CW\*(C`gmtime()\*(C'\fR et de \f(CW\*(C`localtime()\*(C'\fR.
.Sp
Pour mesurer le temps avec une meilleure granularite\*' que la seconde, vous
pouvez utiliser le module Time::HiRes disponible sur \s-1CPAN\s0 ou, si vous avec
\&\fIgettimeofday\fR\|(2), vous pouvez utiliser l'interface \f(CW\*(C`syscall\*(C'\fR de Perl. Voir
perlfaq8 pour les de\*'tails.
.IP "times" 8
.IX Item "times"
Retourne une liste de quatre e\*'le\*'ments donnant le temps utilisateur et syste\*`me
en secondes, pour ce process et pour les enfants de ce process.
.Sp
.Vb 1
\&    ($user,$system,$cuser,$csystem) = times;
.Ve
.Sp
Dans un contexte scalaire \f(CW\*(C`times\*(C'\fR retourne \f(CW$user\fR.
.IP "tr///" 8
.IX Item "tr///"
L'ope\*'rateur de translitte\*'ration. La me\*^me chose que \f(CW\*(C`y///\*(C'\fR. Voir perlop.
.IP "truncate \s-1DESCRIPTEUR\s0,LONGUEUR" 8
.IX Item "truncate DESCRIPTEUR,LONGUEUR"
.PD 0
.IP "truncate \s-1EXPR\s0,LONGUEUR" 8
.IX Item "truncate EXPR,LONGUEUR"
.PD
Tronque le fichier ouvert par \s-1DESCRIPTEUR\s0 ou nomme\*' par \s-1EXPR\s0 a\*` la taille
\&\s-1LONGUEUR\s0 spe\*'cifie\*'e. Produit une erreur fatale si la troncature n'est pas
imple\*'mente\*'e sur votre syste\*`me. Retourne true (vrai) en cas de succe\*`s ou la
valeur undef autrement.
.Sp
Le comportement de \fItruncate()\fR est inde\*'fini si \s-1LONGUEUR\s0 est plus grand que la
longueur actuelle du fichier.
.IP "uc \s-1EXPR\s0" 8
.IX Item "uc EXPR"
.PD 0
.IP "uc" 8
.IX Item "uc"
.PD
Retourne la version en majuscule de \s-1EXPR\s0. C'est la fonction interne qui
imple\*'mente la se\*'quence d'e\*'chappement \f(CW\*(C`\eU\*(C'\fR des chai\*^nes entre
guillemets. Respecte le locale \s-1LC_CTYPE\s0 courant si \f(CW\*(C`use locale\*(C'\fR est
actif. Voir perllocale et perlunicode pour plus de de\*'tails. Ne ge\*`re pas
la table spe\*'cifique aux majuscules apparaissant en de\*'but de mot. Voir
ucfirst pour cela.
.Sp
Si \s-1EXPR\s0 est omis, s'applique a\*` \f(CW$_\fR.
.IP "ucfirst \s-1EXPR\s0" 8
.IX Item "ucfirst EXPR"
.PD 0
.IP "ucfirst" 8
.IX Item "ucfirst"
.PD
Retourne la valeur de \s-1EXPR\s0 avec le premier caracte\*`re en majuscule. C'est la
fonction interne qui imple\*'mente la se\*'quence d'e\*'chappement \f(CW\*(C`\eu\*(C'\fR des chai\*^nes
entre guillemets. Respecte le locale \s-1LC_CTYPE\s0 courant si \f(CW\*(C`use locale\*(C'\fR est
actif.  Voir perllocale et perlunicode pour plus de de\*'tails.
.Sp
Si \s-1EXPR\s0 est omis, s'applique a\*` \f(CW$_\fR.
.IP "umask \s-1EXPR\s0" 8
.IX Item "umask EXPR"
.PD 0
.IP "umask" 8
.IX Item "umask"
.PD
Positionne le umask du process a\*` \s-1EXPR\s0 et retourne la valeur pre\*'ce\*'dente. Si
\&\s-1EXPR\s0 est omis, retourne la valeur courante du umask.
.Sp
Les droits Unix \f(CW\*(C`rwxr\-x\-\-\-\*(C'\fR sont repre\*'sente\*'s par trois ensembles de trois
bits ou par trois nombres octaux\ : \f(CW0750\fR (le 0 initial indique une valeur
octale et ne fait pas partie des chiffres). La valeur de \f(CW\*(C`umask\*(C'\fR est un tel
nombre qui repre\*'sente les bits de permissions de\*'sactive\*'s. Les valeurs de
permissions (ou \*(L"droits\*(R" ou \*(L"mode\*(R") que vous passez a\*` \f(CW\*(C`mkdir\*(C'\fR ou \f(CW\*(C`sysopen\*(C'\fR
sont modifie\*'es par votre umask. Par exemple, si vous dites a\*` \f(CW\*(C`sysopen\*(C'\fR de
cre\*'er un fichier avec les droits \f(CW0777\fR et si votre umask vaut \f(CW0022\fR alors
le fichier sera re\*'ellement cre\*'e\*' avec les droits \f(CW0755\fR. Si votre umask vaut
\&\f(CW0027\fR (le groupe ne peut e\*'crire\ ; les autres ne peuvent ni lire, ni e\*'crire,
ni exe\*'cuter) alors passer \f(CW0666\fR a\*` \f(CW\*(C`sysopen\*(C'\fR cre\*'era un fichier avec les
droits \f(CW0640\fR (\f(CW\*(C`0666 &~ 027\*(C'\fR vaut \f(CW0640\fR).
.Sp
Voici quelques conseils\ : fournissez un mode de cre\*'ation de \f(CW0666\fR pour
les fichiers normaux (dans \f(CW\*(C`sysopen\*(C'\fR) et de \f(CW0777\fR pour les re\*'pertoires
(dans \f(CW\*(C`mkdir\*(C'\fR) et les fichiers exe\*'cutables. Cela donne la liberte\*' a\*`
l'utilisateur de choisir\ : si il veut des fichiers prote\*'ge\*'s, il peut
choisir un umask de \f(CW022\fR ou \f(CW027\fR ou me\*^me le umask particulie\*`rement
antisocial \f(CW077\fR. Dans ce domaine, les programmes peuvent rarement (si ce
n'est jamais) prendre de meilleures de\*'cisions que l'utilisateur. L'exception
concerne les fichiers qui doivent e\*^tre garde\*'s prive\*'\ : fichiers de mail,
fichiers de cookies des navigateurs, fichiers \fI.rhosts\fR et autres.
.Sp
Si \fIumask\fR\|(2) n'est pas imple\*'mente\*' sur votre syste\*`me et que vous e\*^tes en train
de restreindre les droits d'acce\*`s pour \fIvous\-me\*^me\fR (i.e. (\s-1EXPR\s0 & 0700) > 0),
cela produit une erreur fatale lors de l'exe\*'cution. Si \fIumask\fR\|(2) n'est pas
imple\*'mente\*' et que vous ne modifiez pas vos propres droits d'acce\*`s, retourne
\&\f(CW\*(C`undef\*(C'\fR.
.Sp
Souvenez-vous que umask est un nombre, habituellement donne\*' en octal\ ; Ce
n'est \fIpas\fR une chai\*^ne de chiffres en octal. Voir aussi \*(L"oct\*(R", si vous
disposez d'une chai\*^ne.
.IP "undef \s-1EXPR\s0" 8
.IX Item "undef EXPR"
.PD 0
.IP "undef" 8
.IX Item "undef"
.PD
Donne a\*` \s-1EXPR\s0 la valeur inde\*'finie (undef). \s-1EXPR\s0 doit e\*^tre une lvalue. A\*`
n'utiliser que sur des scalaires, des tableaux (en utilisant \f(CW\*(C`@\*(C'\fR), des tables
de hachage (en utilisant \f(CW\*(C`%\*(C'\fR), des subroutines (en utilisant \f(CW\*(C`&\*(C'\fR) ou des
typeglob (en utilisant \f(CW\*(C`*\*(C'\fR). (Dire \f(CW\*(C`undef $hash{$key}\*(C'\fR ne fera probablement
pas ce que vous espe\*'rez sur la plupart des variables pre\*'de\*'finies ou sur les
liste de valeurs \s-1DBM\s0. Ne le faites donc pas\ ; voir \*(L"delete\*(R".) Retourne
toujours la valeur undef. Vous pouvez omettre \s-1EXPR\s0, auquel cas rien ne sera
inde\*'fini mais vous re\*'cupe\*'rerez encore la valeur undef afin, par exemple, de
la retourner depuis une subroutine, de l'affecter a\*` une variable ou de la
passer comme argument. Exemples\ :
.Sp
.Vb 9
\&    undef $foo;
\&    undef $bar{'blurfl'};      # A\*` comparer a\*` : delete $bar{'blurfl'};
\&    undef @ary;
\&    undef %hash;
\&    undef &mysub;
\&    undef *xyz;       # de\*'truit $xyz, @xyz, %xyz, &xyz, etc.
\&    return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;
\&    select undef, undef, undef, 0.25;
\&    ($a, $b, undef, $c) = &foo;       # Ignorer la troisie\*`me valeur retourne\*'e
.Ve
.Sp
Remarquez que c'est un ope\*'rateur unaire et non un ope\*'rateur de liste.
.IP "unlink \s-1LISTE\s0" 8
.IX Item "unlink LISTE"
.PD 0
.IP "unlink" 8
.IX Item "unlink"
.PD
Efface une liste de fichiers. Retourne le nombre de fichiers efface\*'s avec
succe\*`s.
.Sp
.Vb 3
\&    $cnt = unlink 'a', 'b', 'c';
\&    unlink @goners;
\&    unlink <*.bak>;
.Ve
.Sp
Remarque\ : \f(CW\*(C`unlink()\*(C'\fR n'effacera pas de re\*'pertoires a\*` moins que vous ne soyez
le super-utilisateur (root) et que l'option \fB\-U\fR soit donne\*'e a\*` Perl. Me\*^me
si ces conditions sont remplies, soyez conscient que l'effacement d'un
re\*'pertoire par unlink peut endommager votre syste\*`me de fichiers. Utilisez
\&\f(CW\*(C`rmdir()\*(C'\fR a\*` la place.
.Sp
Si \s-1LISTE\s0 est omis, s'applique a\*` \f(CW$_\fR.
.IP "unpack \s-1TEMPLATE\s0,EXPR" 8
.IX Item "unpack TEMPLATE,EXPR"
\&\f(CW\*(C`unpack()\*(C'\fR re\*'alise l'ope\*'ration inverse de \f(CW\*(C`pack()\*(C'\fR\ : il prend une chai\*^ne
repre\*'sentant une structure, la de\*'compose en une liste de valeurs et retourne
la liste de ces valeurs. (Dans un contexte scalaire, il retourne simplement la
premie\*`re valeur produite.)
.Sp
La chai\*^ne est de\*'coupe\*'e en morceaux selon le format \s-1TEMPLATE\s0 fourni. Chaque
morceau est converti se\*'pare\*'ment en une valeur. Typiquement, soit la chai\*^ne est
le re\*'sultat d'un \f(CW\*(C`pack\*(C'\fR soit les octets de la chai\*^ne repre\*'sentent une
structure C d'un certain type.
.Sp
Le \s-1TEMPLATE\s0 a le me\*^me format que pour la fonction \f(CW\*(C`pack()\*(C'\fR. Voici une
subroutine qui extrait une sous\-chai\*^ne\ :
.Sp
.Vb 4
\&    sub substr {
\&        my($what,$where,$howmuch) = @_;
\&        unpack("x$where a$howmuch", $what);
\&    }
.Ve
.Sp
et un autre exemple\ :
.Sp
.Vb 1
\&    sub ordinal { unpack("c",$_[0]); } # identique a\*` ord()
.Ve
.Sp
En plus, vous pouvez pre\*'fixer un champ avec un %<nombre> pour indiquer
que vous voulez un checksum des items sur <nombre> bits a\*` la place des
items eux\-me\*^mes. Par de\*'faut, c'est un checksum sur 16 bits. Le checksum est
calcule\*' en additionnant les valeurs nume\*'riques des valeurs extraites (pour les
champs alphanume\*'riques, c'est la somme des \f(CW\*(C`ord($caractere)\*(C'\fR qui est prise et
pour les champs de bits, c'est la somme des 1 et des 0).
.Sp
Par exemple, le code suivant calcule le me\*^me nombre que le programme sum
System V\ :
.Sp
.Vb 4
\&    $checksum = do {
\&        local $/;  # slurp!
\&        unpack("%32C*",<>) % 65535;
\&    };
.Ve
.Sp
Le code suivant calcule de manie\*`re efficace le nombre de bits a\*` un dans un
vecteur de bits\ :
.Sp
.Vb 1
\&    $setbits = unpack("%32b*", $selectmask);
.Ve
.Sp
Les formats \f(CW\*(C`p\*(C'\fR et \f(CW\*(C`P\*(C'\fR doivent e\*^tre utilise\*'s avec pre\*'cautions. Puisque Perl
n'a aucun moyen de ve\*'rifier que les valeurs passe\*'es a\*` \f(CW\*(C`unpack()\*(C'\fR
correspondent a\*` des emplacements me\*'moires valides, le passage d'un pointeur
dont on n'est pas su\*^r de la validite\*' peut avoir des conse\*'quences de\*'sastreuses.
.Sp
Si la valeur de re\*'pe\*'tition d'un champ est plus grande que ce que le reste de
la chai\*^ne d'entre\*'e autorise, la valeur est diminue\*'e. Si la chai\*^ne d'entre\*'e est
plus longue que ce qui est de\*'crit par \s-1TEMPLATE\s0, le reste est ignore\*'.
.Sp
Voir \*(L"pack\*(R" pour plus d'exemples et de remarques.
.IP "untie \s-1VARIABLE\s0" 8
.IX Item "untie VARIABLE"
Casse le lien entre une variable et un package. (Voir \f(CW\*(C`tie()\*(C'\fR.)  N'a aucun
effet si la variable n'est lie\*'e a\*` aucun package.
.IP "unshift \s-1TABLEAU\s0,LISTE" 8
.IX Item "unshift TABLEAU,LISTE"
Fait le contraire de \f(CW\*(C`shift()\*(C'\fR. Ou le contraire de \f(CW\*(C`push()\*(C'\fR, selon le point
de vue. Ajoute la liste \s-1LISTE\s0 au de\*'but du tableau \s-1TABLEAU\s0 et retourne le
nouveau nombre d'e\*'le\*'ments du tableau.
.Sp
.Vb 1
\&    unshift(@ARGV, '\-e') unless $ARGV[0] =~ /^\-/;
.Ve
.Sp
Remarquez que \s-1LISTE\s0 est ajoute\*'e d'un seul coup et non e\*'le\*'ment par
e\*'le\*'ment. Donc les e\*'le\*'ments restent dans le me\*^me ordre. Utilisez \f(CW\*(C`reverse()\*(C'\fR
pour faire le contraire.
.IP "use Module \s-1VERSION\s0 \s-1LISTE\s0" 8
.IX Item "use Module VERSION LISTE"
.PD 0
.IP "use Module \s-1VERSION\s0" 8
.IX Item "use Module VERSION"
.IP "use Module \s-1LISTE\s0" 8
.IX Item "use Module LISTE"
.IP "use Module" 8
.IX Item "use Module"
.IP "use \s-1VERSION\s0" 8
.IX Item "use VERSION"
.PD
Importe dans le package courant quelques \*(L"se\*'mantiques\*(R" du module spe\*'cifie\*',
ge\*'ne\*'ralement en les attachant a\*` certains noms de subroutines ou de variables
de votre package. C'est exactement e\*'quivalent a\*`\ :
.Sp
.Vb 1
\&    BEGIN { require Module; import Module LISTE; }
.Ve
.Sp
sauf que Module \fIdoit\fR e\*^tre un mot (bareword).
.Sp
\&\s-1VERSION\s0 peut e\*^tre soit une valeur nume\*'rique telle que 5.006 qui sera alors
compare\*'e a\*` $], soit une valeur litte\*'rale de la forme v5.6.1 qui sera alors
compare\*'e a\*` $^V (c.\-a\*`\-d. \f(CW$PERL_VERSION\fR). Si \s-1VERSION\s0 est plus grand que la
version courante de l'interpre\*'teur Perl alors il se produira une erreur
fatale\ ; Perl n'essaiera me\*^me pas de lire le reste du fichier. A\*`
comparer avec \*(L"require\*(R" qui fait la me\*^me ve\*'rification mais lors de
l'exe\*'cution.
.Sp
L'utilisation d'une \s-1VERSION\s0 sous forme litte\*'rale (ex: v5.6.1) devrait e\*^tre
e\*'vite\*'e puisque cela entrai\*^ne la production de messages d'erreurs errone\*'s par
les vieilles versions de Perl qui ne reconnaissent pas cette
syntaxe. L'e\*'quivalent nume\*'rique est pre\*'fe\*'rable.
.Sp
.Vb 4
\&    use v5.6.1;         # ve\*'rification de version a\*` la compilation
\&    use 5.6.1;          # idem
\&    use 5.005_03;       # nume\*'ro de version nume\*'rique
\&                        # (pre\*'fe\*'rable pour des raisons de compatibilite\*')
.Ve
.Sp
C'est pratique si vous devez ve\*'rifier la version courante de Perl avant
d'utiliser (via \f(CW\*(C`use\*(C'\fR) des modules qui ont change\*' de manie\*`re incompatible
depuis les anciennes versions. (Nous essayons de le faire le moins souvent
possible).
.Sp
Le \f(CW\*(C`BEGIN\*(C'\fR force le \f(CW\*(C`require\*(C'\fR et le \f(CW\*(C`import\*(C'\fR lors de la compilation. Le
\&\f(CW\*(C`require\*(C'\fR assure que le module est charge\*' en me\*'moire si il ne l'a pas de\*'ja\*`
e\*'te\*'. \f(CW\*(C`import\*(C'\fR n'est pas une fonction interne \*(-- c'est juste un appel a\*` une
me\*'thode statique ordinaire dans le package "\f(CW\*(C`Module\*(C'\fR" pour lui demander
d'importer dans le package courant la liste de ses fonctionnalite\*'s. Le module
peut imple\*'menter sa me\*'thode \f(CW\*(C`import()\*(C'\fR comme il le veut, bien que la plupart
des modules pre\*'fe\*`rent simplement la de\*'finir par he\*'ritage de la classe
\&\f(CW\*(C`Exporter\*(C'\fR qui est de\*'finie dans le module \f(CW\*(C`Exporter\*(C'\fR. Voir Exporter. Si
aucune me\*'thode \f(CW\*(C`import()\*(C'\fR ne peut e\*^tre trouve\*'e alors l'appel est ignore\*'.
.Sp
Si vous voulez e\*'viter l'appel a\*` la me\*'thode \*(L"import\*(R" d'un package (par exemple
pour e\*'viter que votre espace de noms soit modifie\*'), fournissez explicitement
une liste vide\ :
.Sp
.Vb 1
\&    use Module ();
.Ve
.Sp
C'est exactement e\*'quivalent a\*`\ :
.Sp
.Vb 1
\&    BEGIN { require Module }
.Ve
.Sp
Si l'argument \s-1VERSION\s0 est pre\*'sent entre Module et \s-1LISTE\s0 alors \f(CW\*(C`use\*(C'\fR appelle
la me\*'thode \s-1VERSION\s0 de la classe Module avec la version spe\*'cifie\*'e comme
argument. La me\*'thode \s-1VERSION\s0 par de\*'faut, he\*'rite\*'e de la classe Universal, crie
(via croak) si la version demande\*'e est plus grande que celle fournie par la
variable \f(CW$Module::VERSION\fR.
.Sp
A\*` nouveau, il y a une diffe\*'rence entre omettre \s-1LISTE\s0 (\f(CW\*(C`import\*(C'\fR appele\*' sans
argument) et fournir une \s-1LISTE\s0 explicitement vide \f(CW\*(C`()\*(C'\fR (\f(CW\*(C`import\*(C'\fR n'est pas
appele\*').  Remarquez qu'il n'y a pas de virgule apre\*`s \s-1VERSION\s0\ !
.Sp
Puisque c'est une interface largement ouverte, les pragmas (les directives du
compilateur) sont aussi imple\*'mente\*'s en utilisant ce moyen. Les pragmas
actuellement imple\*'mente\*'s sont\ :
.Sp
.Vb 8
\&      use constant;
\&      use diagnostics;
\&      use integer;
\&      use sigtrap  qw(SEGV BUS);
\&      use strict   qw(subs vars refs);
\&      use subs     qw(afunc blurfl);
\&      use warnings qw(all);
\&      use sort     qw(stable _quicksort _mergesort);
.Ve
.Sp
Certains d'entre eux sont des pseudo-modules qui importent de nouvelles
se\*'mantiques uniquement dans la porte\*'e du bloc courant (comme \f(CW\*(C`strict\*(C'\fR or
\&\f(CW\*(C`integer\*(C'\fR) contrairement aux modules ordinaires qui importent des symboles
dans le package courant (qui sont donc effectifs jusqu'a\*` la fin du fichier
lui\-me\*^me).
.Sp
Il y a une commande "\f(CW\*(C`no\*(C'\fR\*(L" permettant de \*(R"de\*'simporter" des choses importe\*'es
par \f(CW\*(C`use\*(C'\fR, i.e. elle appelle \f(CW\*(C`unimport Module LISTE\*(C'\fR a\*` la place de
\&\f(CW\*(C`import\*(C'\fR.
.Sp
.Vb 3
\&    no integer;
\&    no strict 'refs';
\&    no warnings;
.Ve
.Sp
Voir perlmodlib pour une liste des modules et pragmas standard. Voir
perlrun pour les options \f(CW\*(C`\-M\*(C'\fR et \f(CW\*(C`\-m\*(C'\fR qui permettent d'utiliser la
fonctionnalite\*' \f(CW\*(C`use\*(C'\fR depuis la ligne de commande.
.IP "utime \s-1LISTE\s0" 8
.IX Item "utime LISTE"
Change la date d'acce\*`s et de modification de chaque fichier d'une liste de
fichiers. Les deux premiers e\*'le\*'ments de la liste doivent e\*^tre, dans l'ordre,
les dates NUME\*'\s-1RIQUES\s0 d'acce\*`s et de modification. Retourne le nombre de
fichiers modifie\*'s avec succe\*`s. La date de modification de l'inode de chaque
fichier est mis a\*` l'heure courante. Le code suivant a exactement le me\*^me effet
que la commande "\f(CW\*(C`touch\*(C'\fR" si les fichiers existent de\*'ja\*`\ :
.Sp
.Vb 3
\&    #!/usr/bin/perl
\&    $now = time;
\&    utime $now, $now, @ARGV;
.Ve
.Sp
Si les deux premiers e\*'le\*'ments de \s-1LIST\s0 valent \f(CW\*(C`undef\*(C'\fR alors la fonction
\&\fIutime\fR\|(2) de la bibliothe\*`que C est appele\*'e avec un second argument nul. Sur la
plupart des syste\*`mes, cela positionnera les dates d'acce\*`s et de modification
des fichiers a\*` l'heure courante (comme dans l'exemple ci\-dessus).
.Sp
.Vb 1
\&   utime undef, undef, @ARGV;
.Ve
.IP "values \s-1HASH\s0" 8
.IX Item "values HASH"
Retourne la liste de toutes les valeurs contenues dans la table de hachage
\&\s-1HASH\s0. (Dans un contexte scalaire, retourne le nombre de valeurs.) Les valeurs
sont retourne\*'es dans un ordre apparemment ale\*'atoire. Cet ordre peut changer
avec les nouvelles versions de Perl mais vous avez la garantie qu'il est
identique a\*` celui produit par les fonctions \f(CW\*(C`keys()\*(C'\fR ou \f(CW\*(C`each()\*(C'\fR applique\*'es
a\*` la me\*^me table de hachage (tant qu'elle n'est pas modifie\*'e).
.Sp
Notez que les valeurs ne sont pas copie\*'es. Ce qui signifie que leur
modification entrai\*^ne la modification du contenu de la table de
hachage\ :
.Sp
.Vb 2
\&    for (values %hash)      { s/foo/bar/g }   # modifie les valeurs de %hash
\&    for (@hash{keys %hash}) { s/foo/bar/g }   # idem
.Ve
.Sp
L'appel a\*` values a\*` pour effet de re\*'initialiser l'ite\*'rateur interne de
\&\s-1HASH\s0. Voir aussi \f(CW\*(C`keys\*(C'\fR, \f(CW\*(C`each\*(C'\fR et \f(CW\*(C`sort\*(C'\fR.
.IP "vec \s-1EXPR\s0,OFFSET,BITS" 8
.IX Item "vec EXPR,OFFSET,BITS"
Traite la chai\*^ne contenue dans \s-1EXPR\s0 comme un vecteur de bits dont les e\*'le\*'ments
sont de la largeur de \s-1BITS\s0 et retourne un entier non signe\*' contenant la valeur
du champ de bits spe\*'cifie\*' par \s-1OFFSET\s0. \s-1BITS\s0 spe\*'cifie le nombre de bits qui est
occupe\*' par chaque entre\*'e dans le vecteur de bits. Cela doit e\*^tre une puissance
de deux entre 1 et 32 (ou 64 si votre plateforme le supporte).
.Sp
Si \s-1BITS\s0 vaut 8, les \*(L"e\*'le\*'ments\*(R" coi\*:ncident avec les octets de la chai\*^ne
d'entre\*'e.
.Sp
Si \s-1BITS\s0 vaut 16 ou plus, les octets de la chai\*^ne d'entre\*'e sont groupe\*'s par
morceau de taille \s-1BITS/8\s0 puis chaque groupe est converti en un nombre comme le
feraient \fIpack()\fR et \fIunpack()\fR avec les formats big-endian \f(CW\*(C`n\*(C'\fR/\f(CW\*(C`N\*(C'\fR. Voir
\&\*(L"pack\*(R" pour plus de de\*'tails.
.Sp
Si \s-1BITS\s0 vaut 4 ou moins, la chai\*^ne est de\*'coupe\*'e en octets puis les bits de
chaque octet sont de\*'coupe\*'s en 8/BITS groupes. Les bits d'un octet sont
nume\*'rote\*'s a\*` la manie\*`re little-endian comme dans \f(CW0x01\fR, \f(CW0x02\fR, \f(CW0x04\fR,
\&\f(CW0x08\fR, \f(CW0x10\fR, \f(CW0x20\fR, \f(CW0x40\fR, \f(CW0x80\fR. Par exemple, le de\*'coupage d'un
seul octet d'entre\*'e \f(CW\*(C`chr(0x36)\*(C'\fR en deux groupes donnera la liste \f(CW\*(C`(0x6,
0x3)\*(C'\fR\  ; son de\*'coupage en 4 groupes donnera \f(CW\*(C`(0x2, 0x1, 0x3, 0x0)\*(C'\fR.
.Sp
\&\f(CW\*(C`vec\*(C'\fR peut aussi e\*^tre affecte\*' auquel cas les parenthe\*`ses sont ne\*'cessaires
pour donner les bonnes priorite\*'s\ :
.Sp
.Vb 1
\&    vec($image, $max_x * $x + $y, 8) = 3;
.Ve
.Sp
Si l'e\*'le\*'ment se\*'lectionne\*' est en dehors de la chai\*^ne, la valeur retourne\*'e sera
ze\*'ro. Si, au contraire, vous cherchez a\*` e\*'crire dans un e\*'le\*'ment en dehors de la
chai\*^ne, Perl agrandira suffisamment la chai\*^ne au pre\*'alable en la comple\*'tant
par des octets nuls. L'e\*'criture avant le de\*'but de la chai\*^ne (c.\-a\*`\-d avec un
\&\s-1OFFSET\s0 ne\*'gatif) est une erreur.
.Sp
La chai\*^ne ne devrait pas contenir de caracte\*`res ayant une valeur > 255 (ceci
ne peut arriver que si vous utilisez l'encodage \s-1UTF8\s0). Quoiqu'il en soit, elle
sera traite\*'e sans tenir compte de son encodage \s-1UTF8\s0. Apre\*`s une affectation via
\&\f(CW\*(C`vec\*(C'\fR, les autres parties de votre programme ne conside\*'reront plus cette
chai\*^ne comme e\*'tant encode\*'e en \s-1UTF8\s0. En d'autres termes, si vous avez de tels
caracte\*`res dans votre chai\*^ne, \fIvec()\fR conside\*'rera les octets de la chai\*^ne et non
les caracte\*`res conceptuels qui la composent.
.Sp
Les chai\*^nes cre\*'e\*'es par \f(CW\*(C`vec\*(C'\fR peuvent aussi e\*^tre manipule\*'es par les ope\*'rateurs
logiques \f(CW\*(C`|\*(C'\fR, \f(CW\*(C`&\*(C'\fR et \f(CW\*(C`^\*(C'\fR qui supposent qu'une ope\*'ration bit a\*` bit est
voulue lorsque leurs deux ope\*'randes sont des chai\*^nes. Voir
\&\*(L"Ope\*'rateurs bit a\*` bit sur les chai\*^nes\*(R" in perlop.
.Sp
Le code suivant construit une chai\*^ne \s-1ASCII\s0 disant \f(CW'PerlPerlPerl'\fR. Les
commentaires montrent la chai\*^ne apre\*`s chaque pas. Remarquez que ce code
fonctionne de la me\*^me manie\*`re sur des machines big-endian ou little\-endian.
.Sp
.Vb 2
\&    my $foo = '';
\&    vec($foo,  0, 32) = 0x5065726C;     # 'Perl'
\&
\&    # $foo eq "Perl" eq "\ex50\ex65\ex72\ex6C", 32 bits
\&    print vec($foo, 0, 8);              # affiche 80 == 0x50 == ord('P')
\&
\&    vec($foo,  2, 16) = 0x5065;         # 'PerlPe'
\&    vec($foo,  3, 16) = 0x726C;         # 'PerlPerl'
\&    vec($foo,  8,  8) = 0x50;           # 'PerlPerlP'
\&    vec($foo,  9,  8) = 0x65;           # 'PerlPerlPe'
\&    vec($foo, 20,  4) = 2;              # 'PerlPerlPe'   . "\ex02"
\&    vec($foo, 21,  4) = 7;              # 'PerlPerlPer'
\&                                        # 'r' is "\ex72"
\&    vec($foo, 45,  2) = 3;              # 'PerlPerlPer'  . "\ex0c"
\&    vec($foo, 93,  1) = 1;              # 'PerlPerlPer'  . "\ex2c"
\&    vec($foo, 94,  1) = 1;              # 'PerlPerlPerl'
\&                                        # 'l' is "\ex6c"
.Ve
.Sp
Pour transformer un vecteur de bits en une chai\*^ne ou en un tableau de 0 et de
1, utilisez ceci\ :
.Sp
.Vb 2
\&    $bits = unpack("b*", $vector);
\&    @bits = split(//, unpack("b*", $vector));
.Ve
.Sp
Si vous connaissez pre\*'cise\*'ment la longueur du vecteur, vous pouvez l'utiliser
a\*` la place de \f(CW\*(C`*\*(C'\fR.
.Sp
Voici un exemple qui illustre comment les bits sont re\*'ellement place\*'s\ :
.Sp
.Vb 1
\&    #!/usr/bin/perl \-wl
\&
\&    print <<'EOT';
\&                                      0         1         2         3  
\&                       unpack("V",$_) 01234567890123456789012345678901
\&    \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
\&    EOT
\&
\&    for $w (0..3) {
\&        $width = 2**$w;
\&        for ($shift=0; $shift < $width; ++$shift) {
\&            for ($off=0; $off < 32/$width; ++$off) {
\&                $str = pack("B*", "0"x32);
\&                $bits = (1<<$shift);
\&                vec($str, $off, $width) = $bits;
\&                $res = unpack("b*",$str);
\&                $val = unpack("V", $str);
\&                write;
\&            }
\&        }
\&    }
\&
\&    format STDOUT =
\&    vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
\&    $off, $width, $bits, $val, $res
\&    .
\&    _\|_END_\|_
.Ve
.Sp
Inde\*'pendamment de l'architecture de la machine qui exe\*'cute ce code, l'exemple
ci-dessus devrait produire la table suivante\ :
.Sp
.Vb 10
\&                                      0         1         2         3  
\&                       unpack("V",$_) 01234567890123456789012345678901
\&    \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
\&    vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
\&    vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
\&    vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
\&    vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
\&    vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
\&    vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
\&    vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
\&    vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
\&    vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
\&    vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
\&    vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
\&    vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
\&    vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
\&    vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
\&    vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
\&    vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
\&    vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
\&    vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
\&    vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
\&    vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
\&    vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
\&    vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
\&    vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
\&    vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
\&    vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
\&    vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
\&    vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
\&    vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
\&    vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
\&    vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
\&    vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
\&    vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
\&    vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
\&    vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
\&    vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
\&    vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
\&    vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
\&    vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
\&    vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
\&    vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
\&    vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
\&    vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
\&    vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
\&    vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
\&    vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
\&    vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
\&    vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
\&    vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
\&    vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
\&    vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
\&    vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
\&    vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
\&    vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
\&    vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
\&    vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
\&    vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
\&    vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
\&    vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
\&    vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
\&    vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
\&    vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
\&    vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
\&    vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
\&    vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
\&    vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
\&    vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
\&    vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
\&    vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
\&    vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
\&    vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
\&    vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
\&    vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
\&    vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
\&    vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
\&    vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
\&    vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
\&    vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
\&    vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
\&    vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
\&    vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
\&    vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
\&    vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
\&    vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
\&    vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
\&    vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
\&    vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
\&    vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
\&    vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
\&    vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
\&    vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
\&    vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
\&    vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
\&    vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
\&    vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
\&    vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
\&    vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
\&    vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
\&    vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
\&    vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
\&    vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
\&    vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
\&    vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
\&    vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
\&    vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
\&    vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
\&    vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
\&    vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
\&    vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
\&    vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
\&    vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
\&    vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
\&    vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
\&    vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
\&    vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
\&    vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
\&    vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
\&    vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
\&    vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
\&    vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
\&    vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
\&    vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
\&    vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
\&    vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
\&    vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
\&    vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
\&    vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
\&    vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
\&    vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001
.Ve
.IP "wait" 8
.IX Item "wait"
Se comporte comme l'appel syste\*`me \fIwait\fR\|(2) sur votre syste\*`me\ : attend qu'un
processus fils se termine et retourne le pid de ce processus ou \f(CW\*(C`\-1\*(C'\fR s'il
n'y a pas de processus fils. Le statut est retourne\*' par \f(CW$?\fR. Remarquez
qu'une valeur de retour \f(CW\*(C`\-1\*(C'\fR peut signifier que les processus fils ont e\*'te\*'
automatiquement collecte\*'s tel que de\*'crit dans perlipc.
.IP "waitpid \s-1PID\s0,FLAGS" 8
.IX Item "waitpid PID,FLAGS"
Attend qu'un processus fils particulier se termine et retourne le pid de ce
processus ou \f(CW\*(C`\-1\*(C'\fR si ce processus n'existe pas. Sur certains syste\*`me, une
valeur \f(CW0\fR signifie qu'il y a encore des processus actifs. Le statut est
retourne\*' par \f(CW$?\fR. Si vous dites\ :
.Sp
.Vb 5
\&    use POSIX ":sys_wait_h";
\&    #...
\&    do { 
\&        $kid = waitpid(\-1,&WNOHANG);
\&    } until $kid == \-1;
.Ve
.Sp
alors vous pouvez re\*'aliser une attente non bloquante sur plusieurs
processus. Les attentes non bloquantes sont disponibles sur les machines qui
connaissent l'un des deux appels syste\*`me \fIwaitpid\fR\|(2) ou \fIwait4\fR\|(2). Par contre,
l'attente d'un process particulier avec \s-1FLAGS\s0 a\*` \f(CW0\fR est imple\*'mente\*'
partout. (Perl e\*'mule l'appel syste\*`me en se souvenant des valeurs du statut des
processus qui ont termine\*' mais qui n'ont pas encore e\*'te\*' collecte\*'es par le
script Perl.)
.Sp
Remarquez que sur certains syste\*`mes, une valeur de retour \f(CW\*(C`\-1\*(C'\fR peut signifier
que les processus fils ont e\*'te\*' automatiquement collecte\*'s. Voir perlipc pour
les de\*'tails et d'autres exemples.
.IP "wantarray" 8
.IX Item "wantarray"
Retourne true (vrai) si le contexte d'appel de la subroutine en cours
d'exe\*'cution attend une liste de valeurs. Retourne false (faux) si le contexte
attend un scalaire. Retourne la valeur undef si le contexte n'attend aucune
valeur (\*(L"void context\*(R" ou contexte vide).
.Sp
.Vb 3
\&    return unless defined wantarray;    # inutile d'en faire plus
\&    my @a = complex_calculation();
\&    return wantarray ? @a : "@a";
.Ve
.Sp
Cette fonction aurait du\*^ s'appeler \fIwantlist()\fR.
.IP "warn \s-1LISTE\s0" 8
.IX Item "warn LISTE"
Produit un message d'erreur sur \s-1STDERR\s0 exactement comme \f(CW\*(C`die()\*(C'\fR mais ne
quitte pas et ne ge\*'ne\*`re pas d'exception.
.Sp
Si \s-1LISTE\s0 est vide et si \f(CW$@\fR contient encore une valeur (provenant par
exemple d'un eval pre\*'ce\*'dent) alors cette valeur est utilise\*'e apre\*`s y avoir
ajoute\*' \f(CW"\et...caught"\fR. C'est pratique pour s'approcher d'un comportement
presque similaire a\*` celui de \f(CW\*(C`die()\*(C'\fR.
.Sp
Si \f(CW$@\fR est vide alors la chai\*^ne \f(CW"Warning: Something's wrong"\fR (N.d.t\ :
\&\f(CW"Attention: quelque chose va mal"\fR) est utilise\*'e.
.Sp
Aucun message n'est affiche\*' si une subroutine est attache\*'e a\*`
\&\f(CW$SIG{_\|_WARN_\|_}\fR. C'est de la responsabilite\*' de cette subroutine de ge\*'rer le
message comme elle le veut (en le convertissant en un \f(CW\*(C`die()\*(C'\fR par
exemple). La plupart des subroutines du genre devraient s'arranger pour
afficher re\*'ellement les messages qu'elles ne sont pas pre\*^tes a\*` recevoir en
appelant a\*` nouveau \f(CW\*(C`warn()\*(C'\fR. Remarquez que cela fonctionne sans produire une
boucle sans fin puisque les subroutines attache\*'es a\*` \f(CW\*(C`_\|_WARN_\|_\*(C'\fR ne sont pas
appele\*'s a\*` partir d'une subroutine attache\*'e.
.Sp
Ce comportement est comple\*`tement diffe\*'rent de celui des subroutine attache\*'es a\*`
\&\f(CW$SIG{_\|_DIE_\|_}\fR (qui ne peuvent pas supprimer le texte d'erreur mais
seulement le remplacer en appelant a\*` nouveau \f(CW\*(C`die()\*(C'\fR).
.Sp
L'utilisation d'une subroutine attache\*'e a\*` \f(CW\*(C`_\|_WARN_\|_\*(C'\fR fournit un moyen
puissant pour supprimer tous les messages d'avertissement (me\*^me ceux
conside\*'re\*'s comme obligatoires). Un exemple\ :
.Sp
.Vb 7
\&    # supprime *tous* les messages d'avertissement lors de la compilation
\&    BEGIN { $SIG{'_\|_WARN_\|_'} = sub { warn $_[0] if $DOWARN } }
\&    my $foo = 10;
\&    my $foo = 20;          # pas d'avertissement pour la duplication de
\&                           # $foo... mais c'est ce qu'on voulait !
\&    # pas de messages d'avertissement avant ici
\&    $DOWARN = 1;
\&
\&    # messages d'avertissement a\*` partir d'ici
\&    warn "\e$foo is alive and $foo!";     # devrait apparai\*^tre
.Ve
.Sp
Voir perlvar pour plus de de\*'tails sur la modification des entre\*'es de
\&\f(CW%SIG\fR et pour plus d'exemples. Voir le module Carp pour d'autres sortes
d'avertissement utilisant les fonctions \fIcarp()\fR et \fIcluck()\fR.
.IP "write \s-1DESCRIPTEUR\s0" 8
.IX Item "write DESCRIPTEUR"
.PD 0
.IP "write \s-1EXPR\s0" 8
.IX Item "write EXPR"
.IP "write" 8
.IX Item "write"
.PD
E\*'crit un enregistrement formate\*' (e\*'ventuellement multi\-lignes) vers le
\&\s-1DESCRIPTEUR\s0 spe\*'cifie\*' en utilisant le format associe\*' a\*` ce fichier. Par de\*'faut,
le format pour un fichier est celui qui a le me\*^me nom que le descripteur mais
le format du canal de sortie courant (voir la fonction \f(CW\*(C`select()\*(C'\fR) peut e\*^tre
spe\*'cifie\*' explicitement en stockant le nom du format dans la variable \f(CW$~\fR.
.Sp
Le calcul de l'en\-te\*^te est fait automatiquement\ : si il n'y a pas assez
de place sur la page courante pour l'enregistrement formate\*', on passe a\*` la
page suivante en affichant un format d'en\-te\*^te spe\*'cial puis on y e\*'crit
l'enregistrement formate\*'. Par de\*'faut, le nom du format d'en\-te\*^te spe\*'cial est
le nom du descripteur auquel on ajoute \*(L"_TOP\*(R" mais il peut e\*^tre dynamiquement
modifie\*' en affectant le nom du format voulu a\*` la variable \f(CW$^\fR lorsque le
descripteur est se\*'lectionne\*' (par \fIselect()\fR). Le nombre de lignes restant dans
la page courante est donne\*' par la variable \f(CW\*(C`$\-\*(C'\fR qui peut e\*^tre mise a\*` \f(CW0\fR
pour forcer le passage a\*` la page suivante.
.Sp
Si \s-1DESCRIPTEUR\s0 n'est pas spe\*'cifie\*', le sortie se fait sur le canal de sortie
courant qui, au de\*'but, est \s-1STDOUT\s0 mais qui peut e\*^tre change\*' par l'ope\*'rateur
\&\f(CW\*(C`select()\*(C'\fR. Si le \s-1DESCRIPTEUR\s0 est une expression \s-1EXPR\s0 alors l'expression est
e\*'value\*'e et la chai\*^ne re\*'sultante est utilise\*'e comme nom du descripteur a\*`
utiliser. Pour en savoir plus sur les formats, voir perlform.
.Sp
Notez que write n'est \fI\s-1PAS\s0\fR le contraire de \f(CW\*(C`read()\*(C'\fR. Malheureusement.
.IP "y///" 8
.IX Item "y///"
L'ope\*'rateur de translitte\*'ration. Identique a\*` \f(CW\*(C`tr///\*(C'\fR. Voir perlop.
.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.0.  Pour en savoir plus concernant ces traductions, consultez
<http://perl.enstimac.fr/>.
.Sh "Traducteur"
.IX Subsection "Traducteur"
Traduction initiale : Paul Gaborit (paul.gaborit @ enstimac.fr), Jean-Pascal
Peltier (jp_peltier @ altavista.net).
.PP
Mise a\*` jour en 5.6.0 puis en 5.8.0 : Paul Gaborit (paul.gaborit @ enstimac.fr).
.Sh "Relecture"
.IX Subsection "Relecture"
Ge\*'rard Delafond. Jean-Louis Morel.