=encoding iso-8859-1

=head1 NOM

perlfunc - Fonctions Perl prédéfinies

=head1 DESCRIPTION

Les fonctions de cette section peuvent être utilisées en tant que
termes dans une expression. Elles se séparent en deux catégories
S<principales :> les opérateurs de listes et les opérateurs unaires
nommés. Ceux-ci diffèrent dans leurs relations de précédence avec une
virgule les suivant. (Cf. la table de précédence dans L<perlop>.)  Les
opérateurs de liste prennent plusieurs arguments alors que les
opérateurs unaires n'en prennent jamais plus d'un. Une virgule termine
alors l'argument d'un opérateur unaire mais sépare les arguments d'un
opérateur de liste. Un opérateur unaire fournit en général un contexte
scalaire à son argument, alors qu'un opé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, splice() a trois arguments scalaires
suivis d'une liste.

Dans la description syntaxique qui suit, les opérateurs de liste qui
attendent une liste (et fournissent un contexte de liste pour ses
éléments) ont pour argument LISTE. Une telle liste peu consister de
toute combinaison de valeurs d'arguments scalaires ou de S<listes ;>
les valeurs de listes seront incluses dans la liste comme si chaque
élément individuel était interpolé à cet emplacement de la liste,
formant ainsi la valeur d'une longue liste unidimensionnelle. Les
éléments de LISTE doivent être séparés par des virgules.

Toute fonction de la liste ci-dessous peut être utilisée avec ou sans
parenthèses autour de ses arguments. (Les descriptions syntaxiques les
omettent) Si vous utilisez les parenthèses, la simple (mais suprenante
parfois) règle est la S<suivante :> ça I<RESSEMBLE> à une fonction,
donc c'I<EST> une fonction, et la précédence importe peu. Autrement,
c'est une opérateur de liste ou un opérateur unaire, et la précédence
a son importance. Les expaces entre la fonction et les parenthèses ne
comptent pas, vous devez donc faire parfois très S<attention :>

    print 1+2+4;        # Prints 7.
    print(1+2) + 4;     # Prints 3.
    print (1+2)+4;      # Also prints 3!
    print +(1+2)+4;     # Prints 7.
    print ((1+2)+4);    # Prints 7.

Si vous exécutez Perl avec l'option B<-w>, vous pourrez en être
averti. Par exemple, la troisième ligne ci-dessus S<génère :>

    print (...) interpreted as function at - line 1.
    Useless use of integer addition in void context at - line 1.

Pour les fonctions qui peuvent être utilisées dans un contexte
scalaire ou de liste, une erreur non fatale est généralement indiquée
dans un contexte scalaire en retournant la valeur indéfinie, et dans
un contexte de liste en retournant la liste nulle.

Rappelez-vous de l'importante règle S<suivante :> il n'y a B<aucune
règle> qui lie le comportement d'une expression dans un contexte de
liste à son comportement dans un contexte scalaire, et
réciproquement. Cela peut générer deux résultats complètement
différents. Chaque opérateur et chaque fonction décide quel type de
valeur il serait plus approprié de retourner dans un contexte
scalaire. Certains opérateurs retournent la longueur de la liste qui
aurait été retournée dans un contexte de liste. D'autres opérateurs
en retournent la première valeur. D'autres encore en retournent la
dernière valeur. D'autres enfin retournent un nombre d'opérations
réussies. En général, ils font ce que vous souhaitez, à moins que vous
ne vouliez de la consistence.

Un tableau nommé en contexte scalaire est assez différent de ce qui
apparaitrait au premier coup d'oeil comme une liste dans un contexte
scalaire. Vous ne pouvez pas transformer une liste comme C<(1,2,3)> dans un
contexte scalaire, car le compilateur connaît le contexte à la
compilation. Il générerait ici l'opérateur scalaire virgule, et non
pas la version contruction de liste de la virgule. Ce qui signifie que
ça n'a jamais été une liste avec laquelle commencer.

En général, les fonctions en Perl qui servent comme wrappers pour les
appels système du même nom (comme chown(2), fork(2), closedir(2),
etc.) retournent toutes vrai quand elles réussissent et C<undef>
sinon, comme c'est souvent mentionné ci-dessous. C'est différent des
S<interfaces C> qui retournent C<-1> en cas d'erreur. Les exceptions à
cette règle sont C<waitpid()> et C<syscall()>. Les appels système
fixent aussi la variable spéciale C<$!> en cas d'erreur. Les autres
fonctions ne le font pas, sauf de manière accidentelle.

=head2 Fonctions Perl par catégories

Voici les fonctions Perl (en incluant ce qui ressemble à des
fonctions, comme certains mot-clefs et les opérateurs nommés) triées
par catégorie. Certaines fonctions apparaissent dans plusieurs
catégories à la fois.

=over

=item fonctions de SCALAIREs ou de chaînes de caractères

C<chomp>, C<chop>, C<chr>, C<crypt>, C<hex>, C<index>, C<lc>, C<lcfirst>,
C<length>, C<oct>, C<ord>, C<pack>, C<q/STRING/>, C<qq/STRING/>, C<reverse>,
C<rindex>, C<sprintf>, C<substr>, C<tr///>, C<uc>, C<ucfirst>, C<y///>

=item Expression régulières et reconnaissance de motifs

C<m//>, C<pos>, C<quotemeta>, C<s///>, C<split>, C<study>, C<qr//>

=item Fonctions numériques

C<abs>, C<atan2>, C<cos>, C<exp>, C<hex>, C<int>, C<log>, C<oct>, C<rand>,
C<sin>, C<sqrt>, C<srand>

=item Fonctions de véritables @TABLEAUx

C<pop>, C<push>, C<shift>, C<splice>, C<unshift>

=item Fonctions de listes de données

C<grep>, C<join>, C<map>, C<qw/STRING/>, C<reverse>, C<sort>, C<unpack>

=item Fonctions de véritables %TABLEs DE HACHAGE

C<delete>, C<each>, C<exists>, C<keys>, C<values>

=item Fonctions d'entrée/sortie

C<binmode>, C<close>, C<closedir>, C<dbmclose>, C<dbmopen>, C<die>, C<eof>,
C<fileno>, C<flock>, C<format>, C<getc>, C<print>, C<printf>, C<read>,
C<readdir>, C<rewinddir>, C<seek>, C<seekdir>, C<select>, C<syscall>,
C<sysread>, C<sysseek>, C<syswrite>, C<tell>, C<telldir>, C<truncate>,
C<warn>, C<write>

=item Fonctions pour données de longueur fixe ou pour enregistrements

C<pack>, C<read>, C<syscall>, C<sysread>, C<syswrite>, C<unpack>, C<vec>

=item Fonctions de descripteurs de fichiers, de fichiers ou de répertoires

C<-I<X>>, C<chdir>, C<chmod>, C<chown>, C<chroot>, C<fcntl>, C<glob>,
C<ioctl>, C<link>, C<lstat>, C<mkdir>, C<open>, C<opendir>, C<readlink>,
C<rename>, C<rmdir>, C<stat>, C<symlink>, C<umask>, C<unlink>, C<utime>

=item Mots-clefs liés à la gestion de flux de votre programme perl

C<caller>, C<continue>, C<die>, C<do>, C<dump>, C<eval>, C<exit>,
C<goto>, C<last>, C<next>, C<redo>, C<return>, C<sub>, C<wantarray>

=item Mots-clefs liés à la portée

C<caller>, C<import>, C<local>, C<my>, C<package>, C<use>

=item Fonctions diverses

C<defined>, C<dump>, C<eval>, C<formline>, C<local>, C<my>, C<reset>,
C<scalar>, C<undef>, C<wantarray>

=item Fonctions de processus et groupes de processus

C<alarm>, C<exec>, C<fork>, C<getpgrp>, C<getppid>, C<getpriority>, C<kill>,
C<pipe>, C<qx/STRING/>, C<setpgrp>, C<setpriority>, C<sleep>, C<system>,
C<times>, C<wait>, C<waitpid>

=item Mots-clefs liés aux modules perl

C<do>, C<import>, C<no>, C<package>, C<require>, C<use>

=item Mots-clefs liés aux classes et à l'orienté-objet

C<bless>, C<dbmclose>, C<dbmopen>, C<package>, C<ref>, C<tie>, C<tied>,
C<untie>, C<use>

=item Fonctions de sockets de bas niveau

C<accept>, C<bind>, C<connect>, C<getpeername>, C<getsockname>,
C<getsockopt>, C<listen>, C<recv>, C<send>, C<setsockopt>, C<shutdown>,
C<socket>, C<socketpair>

=item Fonctions IPC (communication inter-processus) System V

C<msgctl>, C<msgget>, C<msgrcv>, C<msgsnd>, C<semctl>, C<semget>, C<semop>,
C<shmctl>, C<shmget>, C<shmread>, C<shmwrite>

=item Manipulation des informations sur les utilisateurs et les groupes

C<endgrent>, C<endhostent>, C<endnetent>, C<endpwent>, C<getgrent>,
C<getgrgid>, C<getgrnam>, C<getlogin>, C<getpwent>, C<getpwnam>,
C<getpwuid>, C<setgrent>, C<setpwent>

=item Manipulation des informations du réseau

C<endprotoent>, C<endservent>, C<gethostbyaddr>, C<gethostbyname>,
C<gethostent>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getprotobyname>, C<getprotobynumber>, C<getprotoent>,
C<getservbyname>, C<getservbyport>, C<getservent>, C<sethostent>,
C<setnetent>, C<setprotoent>, C<setservent>

=item Fonction de date et heure

C<gmtime>, C<localtime>, C<time>, C<times>

=item Nouvelles fonctions de perl5

C<abs>, C<bless>, C<chomp>, C<chr>, C<exists>, C<formline>, C<glob>,
C<import>, C<lc>, C<lcfirst>, C<map>, C<my>, C<no>, C<prototype>, C<qx>,
C<qw>, C<readline>, C<readpipe>, C<ref>, C<sub*>, C<sysopen>, C<tie>,
C<tied>, C<uc>, C<ucfirst>, C<untie>, C<use>

* - C<sub> était un mot-clef dans perl4, mais dans perl5 c'est un
opérateur qui peut être utilisé au sein d'expressions.

=item Fonctions obsolètes en perl5

C<dbmclose>, C<dbmopen>

=back

=head2 Fonctions Perl par ordre alphabétique

=over 8

=item I<-X> DESCRIPTEUR

=item I<-X> EXPR

=item I<-X>

Un test de fichier, où X est une des lettres présentées
ci-dessous. Cet opérateur unaire prend un argument, un nom de fichier
ou un descripteur de fichier, et teste le fichier associé pour
constater si quelque chose est vérifié à son sujet. Si l'argument est
omis, il teste C<$_>, sauf pour C<-t> qui teste STDIN. Sauf
documentation contraire, il retourne C<1> pour VRAI et C<''> pour
FAUX, ou la valeur undéfinie si le fichier n'existe pas. Malgré leurs
noms originaux, la précédence est la même que pour tout autre
opérateur unaire nommé, et l'argument peut-être mis de même entre
parenthèses. L'opérateur peut S<être :>
X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p>
X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>

    -r  Le fichier est en lecture par le uid/gid effectif.
    -w  Le fichier est en écriture par le uid/gid effectif.
    -x  Le fichier est exécutable par le uid/gid effectif.
    -o  Le fichier appartient au uid effectif.

    -R  Le fichier est en lecture par le uid/gid réel.
    -W  Le fichier est en écriture par le uid/gid réel.
    -X  Le fichier est exécutable par le uid/gid réel.
    -O  Le fichier appartient au uid réel.

    -e  Le fichier existe.
    -z  Le fichier a une taille nulle.
    -s  Le fichier n'a pas une taille nulle (retourne sa taille).

    -f  Le fichier est un fichier normal.
    -d  Le fichier est un répertoire.
    -l  Le fichier est un lien symbolique.
    -p  Le fichier est un pipe nommée (FIFO), ou le descripteur est un pipe.
    -S  Le fichier est une socket.
    -b  Le fichier est un fichier de blocs spéciaux.
    -c  Le fichier est un fichier de caractères spéciaux.
    -t  Le fichier est ouvert sur une console tty.

    -u  Le fichier a le bit setuid.
    -g  Le fichier a le bit setgid.
    -k  Le fichier a le sticky bit.

    -T  Le fichier est un fichier texte.
    -B  Le fichier est un fichier binaire (contraire de -T).

    -M  Age du fichier en jours quand le script a été lancé.
    -A  Idem pour le dernier accès au fichier.
    -C  Idem pour le dernier changement sur le fichier.

L'interprétation des opérateurs de permission sur le fichier C<-r>, C<-R>, C<-w>,
C<-W>, C<-x>, et C<-X> est uniquement basée sur le mode du fichier et
les uids/gids de l'utilisateur. Il eut y avoir d'autres raisons pour
lesquelles vous ne pouvez en fait pas lire, écrire ou exécuter le
fichier, telles que les listes de contrôle d'accès AFS. Notez aussi
que, pour le super-utilisateur, C<-r>, C<-R>, C<-w>, et C<-W>
retournent toujours C<1>, et C<-x> ainsi que C<-X> retournent C<1> si
un bit d'exécution est fixé dans le mode. Les scripts lancés par le
super-utilisateur pourraient ainsi nécessiter un C<stat()> pour
déterminer le mode exact du fichier, ou alors d'effectuer un
changement temporaire d'uid.

S<Exemple :>

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

Notez que C<-s/a/b/> n'effectue pas une substitution
négative. Toutefois, écrire
C<-exp($foo)> fonctionne toujours comme prévu -- seule une lettre
isolée après un tiret est interprétée comme un test de fichier.

Les tests C<-T> et C<-B> fonctionnent de la manière suivante. Le
premier bloc du fichier est examiné, à la recherche de caractères
spéciaux tels que les codes de contrôle ou les octets ayant le bit de
poids fort. Si trop de caractères spéciaux S<(E<gt> 30 %)> sont
rencontrés, c'est un fichier C<-B>, sinon c'est un fichier C<-T>. De
plus, tout fichier contenant un octet nul dans le premier bloc est
considéré comme binaire. Si C<-T>
ou C<-B> est utilisé sur un descripteur de fichier, le tampon stdio
courant est examiné à la place du premier bloc. C<-T> et C<-B>
retournent tous les deux VRAI 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 C<-T>, vous allez d'abord utiliser, la plupart du temps, un
C<-f> sur le fichier, comme dans C<next unless -f $file && -T $file>.

Si le descripteur spécial, constitué d'un seul underscore (S<ndt :>
caractère souligné), est fourni comme argument d'un test de fichier
(ou pour les opérateurs C<stat()> et C<lstat()>), alors la structure
du dernier fichier traité par un test (ou opérateur) est utilisée,
épargnant un appel système. (Ceci ne fonctionne pas avec C<-t>, et
vous ne devez pas oublier que lstat() et C<-l> laisseront des
informations dans la structure de stat du fichier symbolique, pas du
fichier réel.)  S<Exemple :>

    print "Can do.\n" if -r $a || -w _ || -x _;

    stat($filename);
    print "Readable\n" if -r _;
    print "Writable\n" if -w _;
    print "Executable\n" if -x _;
    print "Setuid\n" if -u _;
    print "Setgid\n" if -g _;
    print "Sticky\n" if -k _;
    print "Text\n" if -T _;
    print "Binary\n" if -B _;

=item abs VALEUR

=item abs

Retourne la valeur absolue de son argument.
Si VALEUR est omis, utilise C<$_>.

=item accept NOUVELLESOCKET,GENERIQUESOCKET

Accepte une connexion entrante de socket, tout comme l'appel système
accept(2). Retourne l'adresse compacte en cas de succès, FAUX sinon.
Voir l'exemple de L<perlipc/"S<Sockets :> communication client/serveur">.

=item alarm SECONDES

=item alarm

Met en place un SIGALRM à délivrer au processus après le nombre
spécifié de secondes. Si SECONDES est omis, la valeur de C<$_> est
utilisée. (Sur certaines machines, malheureusement, le temps écoulé
peut être jusqu'à une seconde de plus que celui spécifié, en fonction
de la façon dont les secondes sont comptées.) Une seule horloge
à la fois devrait faire le décompte. Chaque appel annule l'horloge
précédente et la valeur C<0> peut être fournie pour annuler le
décompte précédent sans en lancer un nouveau. La valeur retournée est
le temps restant de l'horloge précédente.

Pour des délais d'une précision en-deçà de la seconde, vous pouvez
utiliser l'interface C<syscall()> de Perl pour accéder à setitimer(2)
si votre système le supporte, ou alors allez voir L</select()>. C'est
souvent une erreur de mélanger les appels C<alarm()>
et C<sleep()>.

Si vous souhaitez utiliser C<alarm()> pour contrôler un appel système,
il vous faut utiliser le couple C<eval()>/C<die()>. Vous ne pouvez pas
compter sur l'alarme causant l'échec de l'appel système lorsque C<$!>
est à C<EINTR> car Perl met en place des descripteurs de signaux pour
redémarrer ces appels sur certains systèmes. Utiliser
C<eval()>/C<die()> fonctionne toujours, modulo l'avertissement signalé
dans L<perlipc/"Signaux">.

    eval {
        local $SIG{ALRM} = sub { die "alarm\n" }; # N.B. : \n obligatoire
        alarm $timeout;
        $nread = sysread SOCKET, $buffer, $size;
        alarm 0;
    };
    if ($@) {
        die unless $@ eq "alarm\n";   # propage des erreurs inatendues
        # délai dépassé : time out
    }
    else {
        # délai non dépassé
    }

=item atan2 Y,X

Retourne l'arctangent de Y/X dans l'intervalle -PI à PI.

Pour l'opération tangent, vous pouvez utiliser la fonction
C<POSIX::tan()> ou la relation S<habituelle :>

    sub tan { sin($_[0]) / cos($_[0])  }

=item bind SOCKET,NOM

Associe une adresse réseau à une socket, tout comme l'appel système
bind. Retourne VRAI en cas de succès, FAUX sinon. NOM est une adresse
compacte du type aproprié pour la socket. Voir les exemples de 
L<perlipc/"S<Sockets :> communication client/serveur">.

=item binmode DESCRIPTEUR

Positionne le fichier pour être lu ou écrit en mode "binaire" sur les
systèmes d'exploitation qui font la distinction entre fichiers texte
et binaire. Les fichiers non binaires ont les séquences CR LF
traduites en LF en entrée et LF traduite en CR LF en sortie. Le mode
binaire n'a aucun effet sous Unix, sous MS-DOS ou autre système
archaïque similaire, cela peut s'avérer nécessaire -- autrement, votre
bibliothèque C endommagée MS-DOS pourrait mutiler votre fichier. La
distinction principale entre les systèmes nécessitant C<binmode()> et
les autres est leur format de fichier texte. Les systèmes comme Unix,
MacOS at Plan9 qui délimitent les lignes par un simple caractère et
qui l'encodent en C par C<"\n"> n'ont pas besoin de C<binmode()>. Les
autres, si. Si DESCRIPTEUR est une expression, la valeur est
considérée comme le nom du descripteur.

=item bless REF,NOMCLASSE

=item bless REF

Cette fonction précise à la chose référencée par REF qu'elle est
désormais un objet du paquetage NOMCLASSE -- ou le paquetage courant
si aucun NOMCLASSE n'est spécifié, ce qui est souvent le cas. Pour
raison pratique, elle retourne la référence car un C<bless()> est
souvent la dernière instruction d'un constructeur. Utilisez toujours
la version à deux arguments si la fonction effectuant la "bénédiction"
C<bless()> peut être héritée par une classe dérivée. Cf. L<perltoot>
et L<perlobj> pour de plus amples informations sur la bénédiction (et
les bénédictions) d'objets.

=item caller EXPR

=item caller

Retourne le contexte de l'appel de routine en cours. En contexte
scalaire, retourne le nom du paquetage de l'appelant, s'il existe,
c'est-à-dire si nous sommes dans une routine, un C<eval()> ou un
C<require()>, et retourne la valeur indéfinie sinon. En contexte de
liste, retourne

    ($package, $filename, $line) = caller;

Avec EXPR, il retourne des informations supplémentaires que le
débogueur utilise pour afficher un historique de la pile. La valeur de
EXPR donne le nombre de cadres d'appels à rempiler avant celui en cours.

    ($package, $filename, $line, $subroutine,
     $hasargs, $wantarray, $evaltext, $is_require) = caller($i);

Ici, C<$subroutine> peut être C<"(eval)"> si le cadre n'est pas un
appel de routine mais un C<eval()>. Dans un tel cas, les éléments
supplémentaires C<$evaltext> et C<$is_require> sont S<affectés :>
C<$is_require> est vrai si le cadre est créé par un C<require> ou un
C<use>, C<$evaltext> contient le texte de l'instruction C<eval
EXPR>. En particulier, pour une instruction C<eval BLOCK>,
C<$filename> vaut C<"(eval)"> mais C<$evaltext> est indéfini. (Notez
aussi que chaque instruction C<use> créée un cadre C<require> à
l'intérieur d'un cadre C<eval EXPR>.)

De plus, s'il est appelé du paquetage DB, C<caller> retourne plus de
S<détails :> il affecte à la liste de variables C<@DB::args> les
arguments avec lesquels la routine a été appelée.

Prenez garde à l'optimiseur qui peut avoir optimisé des cadres d'appel
avant que C<caller()> ait une chance de récupérer les informations. Ce
qui signifie que C<caller(N)> pourrait ne pas retourner les
informations concernant le cadre d'appel attendu, pour C<N E<gt>
1>. En particulier, C<@DB::args> peut contenir les informations
relatives au dernier C<caller()> exécuté.

=item chdir EXPR

Change le répertoire courant à EXPR, si c'est possible. Si EXPR est
omis, change au répertoire racine de l'utilisateur. Retourne VRAI en
cas de succès, FAUX sinon. Cf. exemple de C<die()>.

=item chmod LISTE

change les permissions d'une liste de fichiers. Le premier élément de
la liste doit être le mode numérique, qui devrait être un nombre en
octal et I<non> une chaîne de chiffres en S<octal :> C<0644> est
correct, mais pas C<'0644'>. Retourne le nombre de fichiers changés
avec succès. Voir aussi L</oct>, si vous ne disposez que d'une chaîne
de chiffres.

    $cnt = chmod 0755, 'foo', 'bar';
    chmod 0755, @executables;
    $mode = '0644'; chmod $mode, 'foo';      # !!! fixe le mode sur
                                             # --w----r-T
    $mode = '0644'; chmod oct($mode), 'foo'; # ceci est mieux
    $mode = 0644;   chmod $mode, 'foo';      # cela est le meilleur

=item chomp VARIABLE

=item chomp LISTE

=item chomp

Ceci est une version légèrement plus sûre de L</chop>. Il efface toute
fin de ligne correspondant à la valeur courante de C<$/> (connue aussi
sous le nom de $INPUT_RECORD_SEPARATOR dans le module C<English>). Il
retourne le nombre total de caractères effacés de tous ses
arguments. Il est souvent utilisé pour effacer le saut de ligne de la
fin d'une entrée quand vous vous souciez que l'enregistrement final
pourrait ne pas avoir ce saut de ligne. En mode paragraphe (C<$/ =
"">), il efface tous les sauts de ligne de la chaîne de caractères. Si
VARIABLE est omis, il tronque C<$_>. S<Exemple :>

    while (<>) {
        chomp;  # evite le \n du dernier champ
        @array = split(/:/);
        # ...
    }

Vous pouvez en fait tronquer tout ce qui est une lvalue, en incluant
les S<affectations :>

    chomp($cwd = `pwd`);
    chomp($answer = <STDIN>);

Si vous tronquez une liste, chaque élément est tronqué, et le nombre
total de caractères effacés est retourné.

=item chop VARIABLE

=item chop LIST

=item chop

Efface le dernier caractère d'une chaîne et le retourne. Cet opérateur
est utilisé en premier lieu pour effacer le saut de ligne de la fin
d'une entrée, mais est plus efficace que C<s/\n//> car il ne scanne
pas et il ne copie pas la chaîne. Si VARIABLE est omis, tronque
C<$_>. S<Exemple :>

    while (<>) {
        chop;   # evite \n du dernier champ
        @array = split(/:/);
        #...
    }

Vous pouvez en fait tronquer tout ce qui est une lvalue, en incluant
les S<affectations :>

    chop($cwd = `pwd`);
    chop($answer = <STDIN>);

Si vous tronquez une liste, chaque élément est tronqué. Seul la valeur
du dernier C<chop()> est retournée.

Notez que C<chop()> retourne le dernier caractère. Pour retourner tout
sauf le dernier caractère, utilisez C<substr($string, 0, -1)>.

=item chown LISTE

Change le propriétaire (et le groupe) d'une liste de fichiers. Les
deux premiers éléments de la liste doivent être, dans l'ordre, les uid et gid
I<NUMERIQUES>. Retourne le nombre de fichiers modifiés avec succès.

    $cnt = chown $uid, $gid, 'foo', 'bar';
    chown $uid, $gid, @filenames;

Voici un exemple qui recherche les uid non numériques du fichier de
mots de S<passe :>

    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);      # liste les nom de fichiers
    chown $uid, $gid, @ary;

Sur la plupart des systèmes, vous n'êtes pas autorisé à changer la
propriété d'un fichier à moins que vous soyez le super-utilisateur,
même si avez la possibilité de changer un groupe en l'un de vos
propres sous-groupes. Sur les systèmes non sécurisés, ces restrictions
peuvent être ignorées, mais ceci n'est pas une hypothèse portable.

=item chr NOMBRE

=item chr

Retourne le caractère représenté par ce NOMBRE dans la table de
caractères. Par exemple, C<chr(65)> est C<"A"> en ASCII. Pour la
fonction réciproque, utilisez L</ord>.

Si NOMBRE est omis, utilise C<$_>.

=item chroot FICHIER

=item chroot

Cet opérateur fonctionne comme l'appel système du même S<nom :> il
fait du répertoire spécifié le nouveau répertoire racine pour tous
les chemins commençant par un C<"/"> utilisés par votre processus et
ses enfants. (Ceci n'affecte pas le répertoire courant qui reste
inchangé.) Pour des raisons de sécurité, cet appel est restreint au
super-utilisateur. Si FICHIER est omis, effectue un C<chroot()> sur C<$_>.

=item close DESCRIPTEUR

=item close

Ferme le fichier ou le tube associé au descripteur de fichier,
retournant VRAI seulement si stdio a réussi à purger ses tampons et à
fermer le descripteur du fichier système. Ferme le descripteur courant
si l'argument est omis.

Vous n'avez pas à fermer le DESCRIPTEUR si vous allez immédiatement
refaire un C<open()> sur celui-ci, car C<open()> le fermera pour
vous. (Cf. C<open()>.) Toutefois, un C<close()> explicite sur un
fichier d'entrée réinitialise le compteur (C<$.>), à l'inverse de la
fermeture implicite par un C<open()>.

Si le descripteur vient d'un tube ouvert, C<close()> va de plus
retourner FAUX si un des autres appels systèmes impliqués échoue ou si
le programme sort avec un statut non nul. (Si le seul problème
rencontré est une sortie de programme non nulle, C<$!> sera à C<0>.)
De même, la fermeture d'un tube attend que le programme exécuté sur le
tube soit achevé, au cas où vous souhaiteriez voir la sortie du tube
après coup. Fermer un tube met aussi la valeur du statut de sortie de
la commande dans C<$?>.

S<Exemple :>

    open(OUTPUT, '|sort >foo')  # tube sur 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: $!";

Le DESCRIPTEUR peut être une expression dont la valeur peut être
utilisée comme un descripteur indirect, habituellement le véritable
nom du descripteur.

=item closedir REPDESCRIPTEUR

Ferme un répertoire ouvert par C<opendir()> et retourne le résultat de
cet appel système.

Le REPDESCRIPTEUR peut être une expression dont la valeur peut être
utilisée comme un descripteur indirect de répertoire, habituellement le véritable
nom du descripteur de répertoire.

=item connect SOCKET,NOM

Tente une connexion sur une socket distante, tout comme le fait
l'appel système du même nom. Retourne VRAI en cas de succès, FAUX
sinon. Le NOM doit être une adresse compacte du type approprié
correspondant à la socket. Voir les exemples de L<perlipc/"Sockets :
communication Client/Server">.

=item continue BLOC

En fait, c'est une instruction de contrôle de flux plutôt qu'une
fonction. S'il y a un BLOC C<continue> rattaché à un BLOC (typiquement
dans un C<while> ou C<foreach>), il est toujours exécuté juste avant
le test à évaluer à nouveau, tout comme la troisième partie d'une
boucle C<for> en C. Il peut donc être utilisé pour incrémenter une
variable de boucle, même si la boucle a été continuée par
l'instruction C<next> (qui est similaire à l'instruction C<continue>
en C).

C<last>, C<next>, ou C<redo> peut apparaître dans un bloc
C<continue>.C<last> et C<redo> vont se comporter comme si ils avaient
été exécutés dans le bloc principal. De même pour C<next>, mais comme
il va exécuter un bloc C<continue>, il peut s'avérer encore plus divertissant.

    while (EXPR) {
        ### redo vient toujours ici
        do_something;
    } continue {
        ### next vient toujours ici
        do_something_else;
        # alors retour au sommet pour revérifier EXPR
    }
    ### last vient toujours ici

Omettre la section C<continue> est sémantiquement équivalent à en
utiliser une vide, de manière assez logique. Dans ce cas, C<next> retourne
directement vérifier la condition au sommet de la boucle.

=item cos EXPR

Retourne le cosinus de EXPR (exprimé en radians). Si EXPR est omis,
prend le cosinus de C<$_>.

Pour la foncion réciproque, vous pouvez utiliser C<POSIX::acos()> ou
alors utiliser cette S<relation :>

    sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }

=item crypt TEXTE,SEL

Crypte une chaîne de caractères exactement comme la fonction crypt(3)
de la libraire C (en supposant que vous en avez en fait une version
qui n'a pas été extirpée comme une munition potentielle). Ceci peut
s'avérer utile, parmi d'autres choses, pour vérifier le fichier de mots de passe à la
recherche de mots de passe bancals. Seuls les types portant un chapeau
blanc devraient faire ça.

Notez que C<crypt()> est conçu pour être une fonction à sens unique,
un peu comme les oeufs qu'on casse pour faire une omelette. Il n'y a
aucune fonction (connue) correspondante pour décrypter. En conséquence
de quoi, cette fonction n'est pas la seule utile pour en
cryptographie. (Pour ça, voyez votre mirroir CPAN le plus proche.)

Voici un exemple que quiconque lance ce programme connaît son propre
mot de S<passe :>

    $pwd = (getpwuid($<))[1];
    $salt = substr($pwd, 0, 2);

    system "stty -echo";
    print "Password: ";
    chop($word = <STDIN>);
    print "\n";
    system "stty echo";

    if (crypt($word, $salt) ne $pwd) {
        die "Sorry...\n";
    } else {
        print "ok\n";
    }

Bien évidemment, donner votre mot de passe à quiconque vous le demande
est très peu recommandé.

=item dbmclose HASH

[Cette fonction a été remplacée par la fonction C<untie()>.]

Rompt le lien entre un fichier DBM et une table de hachage.

=item dbmopen HASH,DBNOM,MODE

[Cette fonction a été remplacée par la fonction C<tie()>.]

Cette fonction lie un fichier de base dbm(3), ndbm(3), sdbm(3),
gdbm(3), ou Berkeley à une table de hachage. HASH est le nom de la
table de hachage. (A la différence du C<open()> normal, le premier
argument n'est I<PAS> un descripteur de fichier, même s'il en a
l'air). DBNOM est le nom de la base de données (sans l'extension
F<.dir> ou F<.pag>, le cas échéant). Si la base de données n'existe
pas, elle est créee avec la protection spécifiée par le MODE (comme
défini par C<umask()>). Si votre système supporte uniquement les
anciennes fonctions DBM, vous pouvez exécuter un seul C<dbmopen()>
dans votre programme. Dans les anciennes versions de Perl, si votre
système n'avait ni DBM ni ndbm, l'appel à C<dbmopen()> produisait une
erreur S<fatale ;> il revient maintenant à sdbm(3).

Si vous n'avez pas de droit en écriture sur le fichier DBM, vous
pouvez seulement lire les variables de la table de hachage, vous ne
pouvez pas y écrire. Si vous souhaitez tester si vous pouvez y écrire,
faites soit un test sur le fichier, soit essayez d'écrire une entrée
bidon dans la table de hachage, à l'intérieur d'un C<eval()>, qui
interceptera l'erreur.

Notez que les fonctions telles que C<keys()> et C<values()> peuvent
retourner des listes énormes si elles sont utilisées sur de gros
fichiers DBM. Vous devriez préférer la fonction C<each()> pour
parcourir des fichiers DBM volumineux. S<Exemple :>

    # 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), "\n";
    }
    dbmclose(%HIST);

Voir aussi L<AnyDBM_File> pour une description plus générale des
avantages et inconvénients des différentes approches dbm, de même que
L<DB_File> pour une implémentation particulièrement riche.

=item defined EXPR

=item defined

Retourne une valeur booléenne exprimant si EXPR a une valeur autre que
la valeur indéfinie C<undef>. Si EXPR est absent, C<$_> sera vérifiée
de la sorte.

De nombreux opérateurs retournent C<undef> pour signaler un échec,
la fin d'un fichier, une erreur système, une variable non initialisée
et d'autres conditions exceptionnelles. Cette fonction vous permet de
distinguer C<undef> d'autres valeurs. (Un simple test booléen ne
distinguera pas C<undef>, zéro, la chaîne de caractères vide et <"0">,
qui représentent tous faux.) Notez que puisque C<undef> est un
scalaire valide, sa présence n'indique pas I<nécessairement> une
condition S<exceptionnelle :> C<pop()> retourne C<undef> quand son
argument est un tableau vide I<ou> quand l'élément à retourner est C<undef>.

Vous pouvez aussi utiliser C<defined()> pour vérifier si une routine
existe, en écrivant C<defined &func> sans parenthèses. D'un autre
côté, l'utilisation de C<defined()> sur des aggrégats (tables de hachage et
tableaux) n'est pas garantie de produire des résultats intuitifs et
devrait donc probablement être évitée.

Utilisé sur un élément de table de hachage, il vous donne si la valeur
est définie, mais pas si la clé existe dans la table. Utilisez
L</exists> dans ce but.

S<Exemples :>

    print if defined $switch{'D'};
    print "$val\n" 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;

S<N.B. :> De nombreuses personnes tendent à sur-utiliser C<defined()>
et sont donc surprises de découvrir que le nombre C<0> et C<""> (la
chaîne de caractères vide) sont, en fait, des valeurs définies. Par
exemple, si vous écrivez

    "ab" =~ /a(.*)b/;

La recherche de motif réussit et C<$1> est définie, malgré le fait
qu'il ne correspond à "rien". Mais elle n'a pas véritablement rien
trouvé -- elle a plutôt trouvé quelque chose qui s'est avéré être
d'une longueur de C<0> caractères. Tout ceci reste très loyal et
honnête. Quand une fonction retourne une valeur indéfinie, il est
admis qu'elle ne pourrait pas vous donner une réponse honnête. Vous
devriez donc utiliser C<defined()> uniquement lorsque vous vous posez
des questions sur l'intégrité de ce que vous tentez de faire. Sinon,
une simple comparaison avec C<0> ou C<""> est ce que vous voulez.

Actuellement, utiliser C<defined()> sur un tableau entier ou un table
de hachage entière vous donne si la mémoire pour cet aggrégat n'a
jamais été allouée. Un tableau assigné à la liste vide apparaît donc
initialement indéfini et un tableau qui a été plein puis assigné à la
liste vide apparaît défini. Vous devriez utiliser à la place un simple
test de S<taille :>

    if (@an_array) { print "has array elements\n" }
    if (%a_hash)   { print "has hash members\n"   }

Utiliser C<undef()> sur ceux-ci efface toutefois leur mémoire et les
rend à nouveau indéfinis, mais vous ne devriez faire ça à moins de
prévoir de ne plus jamais les utiliser car cela gagne du temps quand
vous les rechargez pour avoir de la mémoire prête à remplir. La
manière normale de libérer de l'espace utilisé par un aggrégat est d'y
assigner la liste vide.

Ce comportement anti-intuitif de C<defined()> sur les aggrégats
pourrait toutefois être modifié, corrigé ou brisé dans une version
future de Perl.

Voir aussi L</undef>, L</exists>, L</ref>.

=item delete EXPR

Supprime les clés spécifiées et leur valeurs associées dans une table
de hachage. Pour chaque clé, il retourne la valeur supprimée
correspondante ou la valeur indéfinie si cette clé n'existait
pas. Supprimer des valeurs de C<$ENV{}> modifie
l'environnement. Supprimer des valeurs d'une table de hachage liée à
un fichier DBM supprime l'entrée dans le fichier DBM. (Mais supprimer
une valeur d'une table de hachage liée par C<tie()> ne retourne pas
forcément quelque chose.)

Le code suivant supprime toutes les valeurs d'une table de S<hachage :>

    foreach $key (keys %HASH) {
        delete $HASH{$key};
    }

De même que le code S<suivant :>

    delete @HASH{keys %HASH}

(Mais ces deux méthodes restent plus lentes que la simple assignation
de la liste vide ou l'utilisation de C<undef()>.) Notez que EXPR peut
être arbitrairement compliquée tant que l'opération finale est une
recherche d'élément de table de hachage ou de tranche de S<table :>

    delete $ref->[$x][$y]{$key};
    delete @{$ref->[$x][$y]}{$key1, $key2, @morekeys};

=item die LISTE

En dehors d'un C<eval()>, affiche la valeur de la LISTE sur C<STDERR> et
quitte avec la valeur actuelle de C<$!> (numéro d'erreur errno). Si
C<$!> est C<0>, sort avec la valeur C<($? E<gt>E<gt> 8)> (status
d'une `commande` entre simple quotes). Si C<($? E<gt>E<gt> 8)> est
C<0>, sort avec C<255>. A l'intérieur d'un C<eval()>, le message
d'erreur est mis dans C<$@> et le C<eval()> s'achève sur la valeur
indéfinie. Ce qui fait de C<die()> la façon de soulever une exception.

Exemples S<équivalents :>

    die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news';
    chdir '/usr/spool/news' or die "Can't cd to spool: $!\n"

Si la valeur de EXPR ne se termine pas par un saut de ligne, le numéro
de la ligne actuelle du script et le numéro de la ligne d'entrée (le
cas échéant) sont aussi affichés et un saut de ligne est
ajouté. S<Truc :> concaténer parfois C<", stopped"> à votre message
le rendra plus sensé quand la chaîne de caractères C<"at foo line
123"> sera ajoutée. Supposez que vous exécutiez le script "canasta".

    die "/etc/games is no good";
    die "/etc/games is no good, stopped";

va respectivement produire

    /etc/games is no good at canasta line 123.
    /etc/games is no good, stopped at canasta line 123.

Voir aussi C<exit()> et C<warn()>.

Si la LISTE est vide et que C<$@> contient déjà une valeur
(typiquement d'une évaluation précédente), cette valeur est réutilisée
après la concaténation de C<"\t...propagated">. Ceci est utile pour
propager des S<exceptions :>

    eval { ... };
    die unless $@ =~ /Expected exception/;

Si C<$@> est vide, alors la chaîne de caractères C<"Died"> est utilisée.

Vous pouvez vous arranger pour qu'un callback soit appelé juste après
le C<die()> en assignant le crochet C<$SIG{__DIE__}>. Le descripteur
associé sera appelé avec le texte de l'erreur et peut changer le
message de l'erreur, le cas échéant, en appelant C<die()> à
nouveau. Cf. L<perlvar/$SIG{expr}> pour les détails sur l'assignation
des entrées de C<%SIG> et L<"eval BLOCK"> pour des exemples.

Notez que le crochet C<$SIG{__DIE__}> est appelé même à l'intérieur de
blocs/chaînes évalués par eval(). Si on souhaite que le crochet ne
fasse rien dans de telles situations, mettez

        die @_ if $^S;

en première ligne du descripteur (cf. L<perlvar/$^S>).

=item do BLOC

Pas vraiment une fonction. Retourne la valeur de la dernière commande
dans la séquence de commandes indiquée par le BLOC. Modifié par un
modificateur de boucle, exécute le BLOC une fois avant le test de la
condition de boucle. (Sur d'autres expressions, le modificateur de
boucle teste la condition d'abord.)

=item do ROUTINE(LISTE)

Forme dépréciée d'appel de routine. Cf. L<perlsub>.

=item do EXPR

Utilise la valeur de EXPR comme un fichier et exécute le contenu de ce
fichier comme un script Perl. Son utilité première est d'inclure des
routines d'une librairie de routines Perl.

    do 'stat.pl';

est identique à

    scalar eval `cat stat.pl`;

sauf que c'est plus efficace et concis, qu'il garde une trace du
fichier courant pour les messages d'erreur et recherche toutes les
librairies B<-I> si le fichier n'est pas dans le répertoire courant
(voir aussi le tableau @INC dans L<perlvar/Predefined Names>). C'est
aussi différent dans la façon d'évaluer le code avec C<do FICHIER>
qui ne voit pas les lexèmes dans la portée courante comme c'est le cas
de C<eval CHAINE>. C'est la même chose, en revanche, par le fait qu'il
reparcourt le fichier à chaque fois que vous l'appelez, vous ne voulez
donc probablement pas faire ça dans une boucle.

Si C<do> ne peut pas lire le fichier, il retourne undef et assigne
l'erreur à C<$!>. Si C<do> peut lire le fichier mais pas le compiler,
il retourne undef et assigne une message d'erreur à C<$@>. Si le
fichier est compilé avec succès, C<do> retourne la valeur de la
dernière expression évaluée.

Notez que l'inclusion de modules de librairies est mieux fait avec les
opérateurs C<use()> et C<require()>, qui effectuent aussi une
vérification automatique des erreurs et soulèvent une exception s'il y
a le moindre problème.

Vous pourriez aimer utiliser C<do> pour lire le fichier de
configuration d'un programme. La vérification manuelle d'erreurs peut
être effectuer de la façon S<suivante :>

    # lecture des fichiers : d'abord le systè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;
        }
    }

=item dump LABEL

Ceci provoque immédiatement une copie du coeur du programme (core
dump). A l'origine, ceci permet d'utiliser le programme B<undump> pour
convertir votre core dump en un programme binaire exécutable. Quand le
nouveau binaire est exécuté, il va commencer par exécuter un C<goto
LABEL> (avec toutes les restrictions dont souffre C<goto>). Pensez-y
comme un branchement goto avec l'intervention d'un core dump et une
réincarnation. Si C<LABEL> est omis, relance le programme au
début. S<ATTENTION :> Tout fichier ouvert au moment de la copie ne
sera PAS ouvert à nouveau quand le programme est réincarné, avec pour
résultat une confusion possible sur la portion de Perl. Voir aussi
l'option B<-u> dans L<perlrun>.

S<Exemple :>

    #!/usr/bin/perl
    require 'getopt.pl';
    require 'stat.pl';
    %days = (
        'Sun' => 1,
        'Mon' => 2,
        'Tue' => 3,
        'Wed' => 4,
        'Thu' => 5,
        'Fri' => 6,
        'Sat' => 7,
    );

    dump QUICKSTART if $ARGV[0] eq '-d';

    QUICKSTART:
    Getopt('f');

Cet opérateur est très largement obsolète, en partie parce qu'il est
très difficile de convertir un fichier core en exécutable, et parce
que le véritable compilateur perl-en-C l'a surpassé.

=item each HASH

Appelé dans un contexte de liste, retourne une liste de deux éléments
consistant de la clé et de la valeur du prochain élément d'une table
de hachage, de sorte que vous puissiez itérer sur celui-ci. Appelé
dans un contexte scalaire, retourne la clé pour le seul élément
suivant de la table de hachage. (Notez que les clés peuvent être
C<"0"> et C<"">, qui sont logiquement fausses ; vous pourriez
souhaiter éviter des constructions comme C<while ($k = each %foo) {}>
pour cette raison.)

Les entrées sont apparemment retournées dans un ordre aléatoire. Quand
la table de hachage est entièrement lue, un tableau nul est retourné
dans un contexte de liste (qui, lorsqu'il est assigné, produit une
valeur FAUSSE C<0>), et C<undef> dans un contexte scalaire. Il y a une
simple opération pour chaque table de hachage, partagée par tous les
C<each()>, lisant tous les éléments de la table ou évaluant C<keys
HASH> ou C<values HASH>. Si vous ajoutez ou supprimez des éléments
d'une table de hachage pendant que cous itérez sur celle-ci, vous
pourriez avoir des entrées ignorées ou doublées, ne le faites donc pas.

Le code suivant affiche votre environnement comme le programme
printenv(1), seulement dans un ordre S<différent :>

    while (($key,$value) = each %ENV) {
        print "$key=$value\n";
    }

Voir aussi C<keys()> et C<values()>.

=item eof DESCRIPTEUR

=item eof ()

=item eof

Retourne 1 si la prochaine lecture sur un DESCRIPTEUR de fichier va
retourner une fin de fichier, ou si le DESCRIPTEUR n'est pas
ouvert. Le DESCRIPTEUR peut être une expression dont la valeur donne
un véritable descripteur de fichier. (Notez que cette fonction lit en
fait un caractère puis le retire comme C<ungetc()>, elle n'ets donc
pas vraiment utile dans un contexte itératif.) Ne faites pas de
lecture sur un fichier d'un terminal (ou d'appel à C<eof(FILEHANDLE)>
sur celui-ci) aprè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.

Un C<eof> sans un argument utilise le dernier fichier lu comme
argument. Utiliser C<eof()> avec des parenthèses vides est très
différent. Il indique le pseudo fichier formé par les fichiers listés
sur la ligne de commande, c'est-à-dire que C<eof()> est
raisonnablement à utiliser à l'intérieur une boucle C<while
(E<lt>E<gt>)> pour détecter la fin du dernier fichier. Utiliser
C<eof(ARGV)> ou C<eof> sans les parenthèses pour tester I<CHAQUE>
fichier dans une boucle (E<lt>E<gt>). S<Exemples :>

    # réinitialise le numérotage des lignes sur chaque fichier d'entrée
    while (<>) {
        next if /^\s*#/;        # saute les commentaires
        print "$.\t$_";
    } continue {
        close ARGV  if eof;     # ce n'est pas eof() !
    }

    # insère des tirets juste avant la dernière ligne du dernier fichier
    while (<>) {
        if (eof()) {            # vérifie la fin du fichier courant
            print "--------------\n";
            close(ARGV);        # ferme ou s'arrête ; nécessaire en cas
                                # de lecture sur le terminal
        }
        print;
    }

Truc S<pratique :> vous n'avez presque jamais besoin d'utiliser C<eof>
en Perl parce que les opérateurs d'entrée retournent des valeurs faux
quand ils n'ont plus d'informations, ou s'il y a eu une erreur.

=item eval EXPR

=item eval BLOC

Dans sa première forme, la valeur retournée par EXPR est parcourue
puis exécutée comme un petit programme Perl. La valeur de l'expression
(qui est elle-même déterminée dans un contexte scalaire) est d'abord
parcourue puis, s'il n'y a pas eu d'erreurs, exécutée dans le contexte
du programme courant, de telle sorte que toute assignation de variable,
de routine ou définition de format perdure après cette
exécution. Notez que la valeur est parcourue à chaque exécution
d'évaluation. Si EXPR est omis, évalue C<$_>. Cette forme est
typiquement utilisée pour repousser la compilation et l'exécution
du texte contenu dans EXPR jusqu'à l'exécution du programme.

Dans sa seconde forme, le code à l'intérieur du BLOC est parcouru une
seule fois -- au même moment que la compilation du code entourant
l'évaluation -- et exécuté dans le contexte du programme Perl
courant. Cette forme est typiquement utilisée pour intercepter des
exceptions plsu efficacement que la première (voir ci-dessous), en
fournissant aussi le bénéfice d'une vérification du code dans le BLOC
à la compilation.

Le point-virgule final, le cas échéant, peut être omis dans EXPR ou à
l'intérieur du BLOC.

Dans les deux formes, la valeur retournée est la valeur de la dernière
expression évaluée à l'intérieur du mini-programme ; un retour
explicite (return) peut être aussi utilisé, exactement comme pour les
routines. L'expression fournissant la valeur de retour est évaluée en
contexte vide, scalaire ou de liste, en fonction du contexte de
l'évaluation elle-même. Voir L</wantarray> pour de plus amples
informations sur la façon dont le contexte d'évaluation peut être déterminé.

En cas d'erreur de syntaxe ou d'exécution, ou si un C<die()> est
exécuté, une valeur indéfinie est retournée par C<eval()>, et le
message d'erreur est assigné à C<$@>. S'il n'y a pas d'erreur, C<$@>
est garantie d'être une chaîen de caractères nulle. Prenez garde
au fait qu'utiliser C<eval()> ne dispense pas Perl d'afficher des
messages d'alerte (warnings) sur STDERR, ni qu'il n'assigne ces messages
d'alerte dans C<$@>. Pour ce faire, il vous faudra utiliser les
capacités de C<$SIG{__WARN__}>. Cf. L</warn> et L<perlvar>.

Notez que puisque C<eval()> intercepte les erreurs non fatales, il est
utile pour déterminer si une fonctionnalité (telle que C<socket()> ou
C<symlink()>) est supportée. C'est aussi le mécanisme d'interception
d'erreurs de Perl wuand l'opérateur die est utilisé pour les soulever.

Si le code à exécuter ne varie pas, vous pourriez utilisez la seconde
forme avec un BLOC pour intercepter les erreurs d'exécution sans
supporter l'inconvénient de le recompiler à chaque fois. L'erreur, le
cas échéant, est toujours retournée dans C<$@>.
S<Exemples :>

    # rend une division par zero non fatale
    eval { $answer = $a / $b; }; warn $@ if $@;

    # meme chose, mais moins efficace
    eval '$answer = $a / $b'; warn $@ if $@;

    # une erreur de compilation
    eval { $answer = };                 # MAUVAIS

    # une erreur d'execution
    eval '$answer =';   # sets $@

En utilisant la forme C<eval{}> comme une interception d'exception
dans les librairies, vous pourriez souhaiter ne pas exécuter le
crochet C<__DIE__> que le code utilisateur pourrait avoir
installé. Vous pouvez utiliser la construction C<local $SIG{__DIE__}>
dans ce but, comme dans l'exemple S<ci-dessous :>

    # une interception d'exception de division par zero tres privee
    eval { local $SIG{'__DIE__'}; $answer = $a / $b; };
    warn $@ if $@;

Ceci est spécialement significatif, étant donné que les crochets
C<__DIE__> peuvent appeler C<die()> à nouveau, ce qui a pour effet de
changer leurs messages S<d'erreur :>

    # les crochets __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"
    }

Avec un C<eval()>, vous devriez faire particulièrement attention de
vous souvenir de ce qui est examiné, et S<quand :>

    eval $x;            # CAS 1
    eval "$x";          # CAS 2

    eval '$x';          # CAS 3
    eval { $x };        # CAS 4

    eval "\$$x++";      # CAS 5
    $$x++;              # CAS 6

Les cas 1 et 2 ci-dessus se comportent de la même S<façon :> ils
exécutent le code inclus dans la varaible C<$x>. (Bien que le cas 2 ait
des guillemets qui font se demander au lecteur ce qui se passe --
S<réponse :> rien.) Les cas 3 et 4 se comportent aussi de la même
S<façon :> ils exécutent le code C<'$x'> qui ne fait rien que
retourner la valeur de C<$x>. (Le cas 4 sera préféré pour des raisons
purement visuelles, mais il a aussi l'avantage d'être compilé à la
compilation plutôt qu'à l'exécution.) Le cas 5 est un endroit où vous
I<DEVRIEZ> normalement souhaiter utiliser des guillemets, sauf que
dans ce cas particulier, vous pouvez juste utiliser les références
symboliques à la place, comme dans le cas 6.

=item exec LISTE

=item exec PROGRAMME LISTE

La fonction C<exec()> exécute une commande système I<ET NE RETOURNE
JAMAIS> -- utilisez C<system()> à la place de C<exec()> si vous
soihaitez qu'elle retourne. Elle échoue et retourne FAUX seulement si
la commande n'existe pas I<et> est exécutée directement plutôt que par
votre système de commandes shell (cf. ci-dessous).

Comme c'est une erreur habituelle d'utiliser C<exec()> au lieu de
C<system()>, Perl vous alerte s'il y a une expression suivante qui
n'est pas C<die()>, C<warn()>, ou C<exit()> (si C<-w> est utilisé -- mais
vous le faites toujours.) Si vous voulez I<vraiment> faire suivre le
C<exec()> d'une autre expression, vous pouvez utiliser l'une de ces
méthodes pour éviter S<l'alerte :>

    exec ('foo')   or print STDERR "couldn't exec foo: $!";
    { exec ('foo') }; print STDERR "couldn't exec foo: $!";

S'il y a plus d'un argument dans la LISTE, ou si la LISTE est un
tableau de plus d'une valeur, appelle execvp(3) avec les arguments de
la LISTE. S'il n'y a qu'un seul argument scalaire ou un tableau à un
seul élément, l'argument est vérifié sur les méta-caractères du shell
et, s'il y en a, l'argument entier est passé au système de commandes
shell pour compilation (il s'agit de C</bin/sh -c> sur les plateformes
Unix, mais cela varifie en fonction des plateformes.) S'il n'y a aucun
méta-caractères du shell dans l'argument, il est découpé en mots et
passé directement à C<execvp()> qui est plus efficace. Notez que
C<exec()> et C<system()> ne purgent pas vos tampons de sortie, vous
aurez donc peut-être besoin d'utiliser C<$|> pour éviter la perte de
sorties. S<Exemples :>

    exec '/bin/echo', 'Your arguments are: ', @ARGV;
    exec "sort $outfile | uniq";

Si vous ne souhaitez vraiment pas exécuter le premier argument, mais
souhaitez mentir au programme à propos de son propre nom, vous pouvez
spécifier au programme que vous voulez en fait une exécution comme un
"objet indirect" (sans virgule) au début de la LISTE. (Ceci force
toujours l'interprétation de la LISTE comme une liste multi-valuée,
même s'il n'y a qu'un seul scalaire dedans.) S<Exemple :>

    $shell = '/bin/csh';
    exec $shell '-sh';          # pretend qu'il s'agit d'un login shell

ou, plus directement,

    exec {'/bin/csh'} '-sh';    # pretend qu'il s'agit d'un login shell

Quand les arguments sont exécutés par le système shell, les résultats
seront dépendants de ses caprices et de ses capacités. Voir
L<perlop/"`STRING`"> pour plus de détails.

Utiliser un objet indirect avec C<exec()> ou C<system()> est aussi
plus sûr. Cet usage force l'interprétation des arguments comme une
liste multi-valuée, même si elle ne contient qu'un seul élément. De
cette façon, vous êtes sauvé des jokers étendus du shell ou de la
séparation des mots par des espaces.

    @args = ( "echo surprise" );

    system @args;               # sujet a des echappement du shell
                                # si @args == 1
    system { $args[0] } @args;  # sur meme avec une liste a un seul element

La premiere version, celle sans l'objet indirect, exécute le programme
I<echo>, en lui passant C<"surprise"> comme argument. La seconde
version ne le fait pas -- elle essaie d'exécuter un programme
littéralement appelé I<"echo surprise">, ne le trouve pas et assigne à
C<$?> une valeur non nulle indiquant une erreur.

Notez que C<exec()> n'appelera pas vos blocs C<END>, ni les méthodes
C<DESTROY> de vos objets.

=item exists EXPR

Retourne VRAI si la clé de table de hachage spécifiée existe dans
cette table, même si la valeur correspondante est indéfinie.

    print "Exists\n" if exists $array{$key};
    print "Defined\n" if defined $array{$key};
    print "True\n" if $array{$key};

Un élément de table de hachage peut être VRAI seulement s'il est
défini, et défini s'il existe, mais la réciproque n'est pas
nécessairement vraie.

Notez que l'expression EXPR peut être arbitrairement compliquée tant
que l'opération finale est une recherche de clé sur une table de
S<hachage :>

    if (exists $ref->{"A"}{"B"}{$key}) { ... }

Bien que le dernier élément ne va pas soudainement exister juste parce
son existence a été testée, ceux qui interviennent le seront. Par
conséquent, C<$ref-E<gt>{"A"}> C<$ref-E<gt>{"B"}> va exister
soudainement à cause du test d'existence pour un élément $key. Cette
auto-résurrection pourrait être corrigée dans une version postérieure
de Perl.

=item exit EXPR

Evalue EXPR puis sort immédiatement avec cette valeur. (En fait, il
appelle d'abord toute routine C<END> définie, mais les routines C<END>
ne peuvent pas annuler la sortie. De la même façon, tout destructeur
d'objet qui doivent être appelés le seront avant la sortie.) S<Exemple :>

    $ans = <STDIN>;
    exit 0 if $ans =~ /^[Xx]/;

Voir aussi C<die()>. Si l'expression EXPR est omise, sort avec le
status C<0>. Les seules valeurs universellement portables pour EXPR
sont C<0> en cas de réussite et C<1> en cas d'erreur ; toutes les
autres valeurs sont sujettes à des interprétations imprévisibles, en
fonction de l'environnement dans lequel le programme Perl est exécuté.

Vous ne derviez pas utiliser C<exit()> pour annuler une routine s'il
existeune chance pour que quelqu'un souhaite intercepter quelqu'erreur
qui arrive. Utilisez C<die()> à la place, qui peut être intercepté par
un C<eval()>.

Tous les blocs C<END{}> sont exécutés au moment de la sortie. Voir
L<perlsub> pour les détails.

=item exp EXPR

=item exp

Retourne I<e> (la base du logarithme naturel) à la puissance EXPR. Si
EXPR est omis, retourne C<exp($_)>.

=item fcntl DESCRIPTEUR, FONCTION, SCALAIRE

Implémente la fonction fcntl(2). Vous devrez probablement d'abord écrire

    use Fcntl;

pour avoir les définitions de constantes correctes. Le traitement de
l'argument et la valeur de retour se fait exactement de la même
manière que C<ioctl()> plus bas.
Par S<exemple :>

    use Fcntl;
    fcntl($filehandle, F_GETFL, $packed_return_buffer)
        or die "can't fcntl F_GETFL: $!";

Vous n'avez pas à vérifier C<defined()> sur le retour de
C<fnctl()>. Comme C<ioctl()>, elle transforme un retour C<0> de l'appel
système en un "C<0> mais vrai" en Perl. Cette chaîne est vraie dans un
contexte booléen et vaut C<0> dans un contexte numérique. Elle est
aussi exempte des alertes habituelles de B<-w> sur les conversions
numériques exotiques.

Notez que C<fcntl()> produira une erreur fatale si elle est utilisée
sur une machine n'implémentant pas fcntl(2).

=item fileno DESCRIPTEUR

Retourne le pointeur de fichier d'un descripteur de fichier. Ceci est
utile pour construire des bitmaps pour C<select()> et les opérations
de manipulation de terminaux tty en POSIX de bas niveau. Si
DESCRIPTEUR est une expression, la valeur est prise comme un
descripteur indirect, généralement son nom.

Vous pouvez utiliser ceci pour déterminer si deux descripteurs
réfèrent au même pointeur S<sous-jacent :>

    if (fileno(THIS) == fileno(THAT)) {
        print "THIS and THAT are dups\n";
    } 

=item flock DESCRIPTEUR,OPERATION

Appelle flock(2), ou une émulation, sur le DESCRIPTEUR. Retourne VRAI
en cas de succès, FAUX en cas d'échec. Produit une erreur fatale
lorsqu'il est utilisé sur une machine n'implémentant pas flock(2), le
verrouillage fcntl(2), ou lockf(3). C<flock()> est une interface Perl
portable de verrouillage de fichiers, bien qu'il ne verrouille que les
fichiers complets, et non pas des enregistrements.

Sur de nombreuses plateformes (incluant la plupart des versions et des
clones d'Unix), les verrous positionnés par C<flock()> sont B<à peine
conseillés>. De tels verrous discrets sont plus flexibles mais offrent
moins de garanties. Ceci signifie que les fichiers verrouillés avec
C<flock()> peuvent être modifiés par des programmes n'utilisant pas
C<flock()>. S<Windows NT> et OS/2 sont parmi les plateformes qui
renforce le verrouillage obligatoire. Consultez votre documentation
locale pour plus de détails.

OPERATION est LOCK_SH, LOCK_EX, ou LOCK_UN, éventuellement combinée
avec LOCK_NB. Ces constantes ont traditionnellement pour valeurs 1, 2,
8 et 4, mais vous pouvez utilisez les noms symboliques s'ils sont
importés du module Fcntl, soit individuellement, soit en tant que
groupe en utilisant la balise ':flock'. LOCK_SH demande un verrou
partagé, LOCK_EX demande un verrou exclusif et LOCK_UN libère un
verrou précédemment demandé. Si LOCK_NB est ajouté à LOCK_SH ou
LOCK_EX, alors C<flock()> retournera immédiatement plutôt qie de
bloquer en attendant le verrou (vérifiez le code de retour pour savoir
si vous l'avez obtenu).

Pour éviter la possibilité de mauvaise coordination, Perl vide le
tampon DESCRIPTEUR avant de le (dé)verrouiller.

Notez que l'émulation construite avec lockf(3) ne fournit pas de
verrous partagés et qu'il exige que DESCRIPTEUR soit ouvert en
écriture. Ce sont les sémantiques qu'implémente lockf(3). La plupart
(S<tous ?>) des systèmes implémentent toutefois lockf(3) en termes de
verrou fcntl(2), la différence de sémantiques ne devrait dont pas
mordre trop de gens.

Notez aussi que certaines versions de C<flock()> ne peuvent pas
verrouiller des objets sur le réseau, vous devriez utilisez le
C<fcntl()> plus spécifique au système dans ce but. Si vous le
souhaitez, vous pouvez forcer Perl à ignorer la fonction flock(2) de
votre systèmee et lui fournir ainsi sa propre émulation basée sur
fcntl(2), en passant la bascule C<-Ud_flock> au programme F<Configure>
lors de la configuration de perl.

Voici un empilage de mails pour les systèmes BSD.

    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,"\n\n";
    unlock();

Voir aussi L<DB_File> pour d'autres exemples avec flock().

=item fork

Effectue un appel système fork(2). Retourne l'identifiant (pid) de
l'enfant au processus père, C<0> au processus fils ou C<undef> en cas d'échec.

S<N.B. :> les tampons non vidés restent non vidés dans les deux
processi, ce qui signifie que vous devriez positionner C<$|>
($AUTOFLUSH en anglais) ou appeler la méthode C<autoflush()> de
C<IO::Handle> pour éviter des sorties doubles.

Si vous dupliquez avec C<fork()> sans attendre votre fils, vous allez
accumuler les S<zombis :>

    $SIG{CHLD} = sub { wait };

Il existe aussi l'astuce du double fork (la vérification des retours
d'erreur de C<fork()> sont omis).

    unless ($pid = fork) {
        unless (fork) {
            exec "what you really wanna do";
            die "no exec";
            # ... ou ...
            ## (code_perl_ici)
            exit 0;
        }
        exit 0;
    }
    waitpid($pid,0);

Voir aussi L<perlipc> pour d'autres exemples de duplication et de
suppression d'enfants moribonds.

Notez que si votre fils dupliqué hérite des descripteurs de fichier
systèmes comme STDIN et STDOUT, ils sont en fait connectés par un tube
ou une socket, même si vous sortez du programme, alors le serveur
distant (disons tels que httpd ou rsh) ne saura pas que vous êtes
parti. Vous devriez les réouvrir vers F</dev/null> en cas de problème.

=item format

Déclare un format visuel utilisable par la fonction C<write()>. Par
S<exemple :>

    format Something =
        Test: @<<<<<<<< @||||| @>>>>>
              $str,     $%,    '$' . int($num)
    .

    $str = "widget";
    $num = $cost/$quantity;
    $~ = 'Something';
    write;

Cf. L<perlform> pour de nombreux détails et exemples.

=item formline IMAGE,LISTE

C'est une fonction interne utilisée par les formatages (C<format>),
bien que vous puissiez aussi l'appeler. Elle formate (cf. L<perlform>)
une liste de valeur selon le contenu de IMAGE, plaçant la sortie dans
l'accumulateur du format de sortie C<$^A> (ou C<$ACCUMULATOR> en
anglais). Eventuellement, lorsqu'un C<write()> est effectué, le
contenu de C<$^A> est écrit dans un descripteur de fichier, mais vous
pouvez aussi lire C<$^A> vous-même et ré-assigner C<""> à
C<$^A>. Notez qu'un format se fiche typiquement du nombre de ligne
incluses dans l'IMAGE. Ceci signifie que les jetons C<~> et C<~~>
traiteront l'IMAGE complète comme une seule ligne. Vous pouvez donc
utiliser des formats de lignes multiples pour implémenter un seul
format d'enregistrement, tout comme le compilateur de formatage.

Faiets attention si vous utilisez des quillemets autour de l'image,
car un caractère "C<@>" pourrait être pris pour le début d'un nom de
tableau. C<formline()> retourne toujours VRAI. Cf. L<perlform> pour
d'autres exempleS.

=item getc DESCRIPTEUR

=item getc

Retourne le prochain caractère du fichier d'entrée attaché au
DESCRIPTEUR, et la valeur indéfinie à la fin du fichier ou en cas
d'échec. Si le DESCRIPTEUR est omis, utilise STDIN. Ceci n'est pas
particulièrement efficace. Il ne peut toutefois pas être utilisé pour
obtenir des caractères uniques qui ne sont pas en tampon. Pour ça,
essayez quelque chose S<comme :>

    if ($BSD_STYLE) {
        system "stty cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
        system "stty", '-icanon', 'eol', "\001";
    }

    $key = getc(STDIN);

    if ($BSD_STYLE) {
        system "stty -cbreak </dev/tty >/dev/tty 2>&1";
    }
    else {
        system "stty", 'icanon', 'eol', '^@'; # ASCII null
    }
    print "\n";

Déterminer si $BSD_STYLE devrait être positionné est laissé en
exercice au lecteur.

La fonction C<POSIX::getattr()> peut faire ceci de façon plus portable
sur des systèmes compatibles POSIX. Voir aussi le module
C<Term::ReadKey> de votre site CPAN le plus proche. Les détails sur
CPAN peuvent être trouvés en L<perlmod/CPAN>.

=item getlogin

Implémente la fonction de la bibliothèque C portant le même nom et qui, sur la
plupart des systèmes, retourne le login courant à partir de F</etc/utmp>, si
il existe. Si l'appel retourne null, utilisez C<getpwuid()>.

    $login = getlogin || getpwuid($<) || "Kilroy";

N'utilisez pas C<getlogin()> pour de l'authentification : ce n'est pas aussi
sûr que C<getpwuid()>.

=item getpeername SOCKET

Renvoie l'adresse sockaddr compactée de l'autre extremité de la connexion SOCKET.

    use Socket;
    $hersockaddr    = getpeername(SOCK);
    ($port, $iaddr) = unpack_sockaddr_in($hersockaddr);
    $herhostname    = gethostbyaddr($iaddr, AF_INET);
    $herstraddr     = inet_ntoa($iaddr);

=item getpgrp PID

Renvoie le groupe courant du processus dont on fournit le PID. Utilisez le PID
C<0> pour obtenir le groupe courant du processus courant. Cela engendra une
exception si on l'utilise sur une machine qui n'implémente pas getpgrp(2). Si
PID est omis, renvoie le groupe du processus courant. Remarquez que la version
POSIX de C<getpgrp()> ne prend pas d'argument PID donc seul C<PID==0> est
réellement portable.

=item getppid

Renvoie l'id du processus parent.

=item getpriority WHICH,WHO

Renvoie la priorité courant d'un processus, d'un groupe ou d'un
utilisateur. (Voir L<getpriority(2)>.) Cela engendra une exception si on
l'utilise sur une machine qui n'implémente pas getpriority(2).

=item getpwnam NAME

=item getgrnam NAME

=item gethostbyname NAME

=item getnetbyname NAME

=item getprotobyname NAME

=item getpwuid UID

=item getgrgid GID

=item getservbyname NAME,PROTO

=item gethostbyaddr ADDR,ADDRTYPE

=item getnetbyaddr ADDR,ADDRTYPE

=item getprotobynumber NUMBER

=item getservbyport PORT,PROTO

=item getpwent

=item getgrent

=item gethostent

=item getnetent

=item getprotoent

=item getservent

=item setpwent

=item setgrent

=item sethostent STAYOPEN

=item setnetent STAYOPEN

=item setprotoent STAYOPEN

=item setservent STAYOPEN

=item endpwent

=item endgrent

=item endhostent

=item endnetent

=item endprotoent

=item endservent

Ces routines réalisent exactement les mêmes fonctions que leurs homologues de
la bibliothèque système. Dans un contexte de liste, les valeurs retournées par
les différentes routines sont les suivantes :

    ($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*


(Si une entrée n'existe pas vous récupérerez une liste vide.)

Dans un contexte scalaire, vous obtenez le nom sauf lorsque la fonction fait
une recherche par nom auquelle cas vous récupérerez autre chose. (Si une
entrée n'existe pas vous récupérerez la valeur undef.) Par exemple :

    $uid   = getpwnam($name);
    $name  = getpwuid($num);
    $name  = getpwent();
    $gid   = getgrnam($name);
    $name  = getgrgid($num;
    $name  = getgrent();
    #etc.

Dans I<getpw*()>, les champs C<$quota>, C<$comment> et C<$expire> sont des cas
spéciaux dans le sens où ils ne sont pas supportés sur de nombreux
systèmes. Si C<$quota> n'est pas supporté, c'est un scalaire vide. Si il est
supporté, c'est habituellement le quota disque. Si le champ C<$comment> n'est
pas supporté, c'est un scalaire vide. Si il est supporté, c'est habituellement
le commentaire « administratif » associé à l'utilisateur. Sur certains
systèmes, le champ C<$quota> peut être C<$change> ou C<$age>, des champs qui
sont en rapport avec le vieillisement du mot de passe. Sur certains systèmes,
le champ C<$comment> peut être C<$class>. Le champ C<$expire>, s'il est
présent, exprime la période d'expiration du compte ou du mot de passe. Pour
connaître la disponibilité et le sens exacte de tous ces champs sur votre
système, consultez votre documentation de getpwnam(3) et le fichier
F<pwd.h>. À partir de Perl, vous pouvez trouver le sens de vos champs
C<$quota> et C<$comment> et savoir si vous avez le champ C<$expire> en
utilisant le module C<Config> pour lire les valeurs de C<d_pwquota>,
C<d_pwage>, C<d_pwchange>, C<d_pwcomment> et C<d_pwexpire>.

La valeur C<$members> renvoyée par les fonctions I<getgr*()> est la liste des
noms de login des membres du groupe séparés par des espaces.

Pour les fonctions I<gethost*()>, si la variable C<h_errno> est supportée en
C, sa valeur sera retournée via C<$?> si l'appel à la fonction échoue. La
valeur de C<@addrs> qui est retournée en cas de succès est une liste
d'adresses à plat telle que retournée par l'appel système correspondant. Dans
le domaine Internet, chaque adresse fait quatre octets de long et vous pouvez
la décompactée en disant quelque chose comme :

    ($a,$b,$c,$d) = unpack('C4',$addr[0]);

Si vous vous épuisez en tentant de vous souvenir à quel élément de la liste
retournée correspond une valeur, des interfaces par nom sont fournies par les
modules C<File::stat>, C<Net::hostent>, C<Net::netent>, C<Net::protoent>,
C<Net::servent>, C<Time::gmtime>, C<Time::localtime> et C<User::grent>. Ils
remplacent les appels internes normaux par des versions qui renvoient des
objets ayant le nom approprié pour chaque champ. Par exemple :

   use File::stat;
   use User::pwent;
   $is_his = (stat($filename)->uid == pwent($whoever)->uid);

Bien que les deux appels se ressemblent (appel à une méthode de même nom uid),
ça ne l'est pas parce que l'objet C<File::stat> est différent de l'objet
C<User::pwent>.

=item getsockname SOCKET

Renvoie l'adresse sockaddr compactée de cette extrémité de la connexion SOCKET.

    use Socket;
    $mysockaddr = getsockname(SOCK);
    ($port, $myaddr) = unpack_sockaddr_in($mysockaddr);

=item getsockopt SOCKET,LEVEL,OPTNAME

Renvoie l'option demandée de SOCKET ou undef en cas d'erreur.

=item glob EXPR

=item glob

Retourne la valeur de EXPR en tenant compte de l'expansion des noms de fichiers
tel que le shell standard Unix F</bin/sh> la ferait. C'est l'opération interne
qui implémente l'opérateur C<E<lt>*.cE<gt>> mais vous pouvez l'utiliser
directement. Si EXPR est omis, C<$_> est utilisé à la place. L'opérateur
C<E<lt>*.cE<gt>> est présenté plus en détail dans L<perlop/"Les opérateurs
d'E/S">.

=item gmtime EXPR

Convertit une date telle que celle retournée par la fonction time en un
tableau de 9 éléments avec la date lié au fuseau horaire standard du méridien
de Greenwich. On l'utilise typiquement de la manière suivante :

    #  0    1    2      3      4      5      6      7      8
    ($sec,$min,$heure,$mjour,$mois,$annee,$sjour,$ajour,$isdst) =
                                            gmtime(time);

Tous les éléments du tableau sont numériques et restent tels qu'ils
apparaissent dans une structure tm. En particulier, cela signifie que C<$mois>
est dans l'intervalle C<0..11> et que C<$sjour> est dans l'intervalle C<0..6>
avec le dimanche comme jour C<0>. D'autre part, C<$annee> est le nombre
d'années depuis 1900 et donc C<$annee> vaut C<123> en l'an 2023 et I<non pas>
simplement les deux derniers chiffres de l'année.

Si EXPR est omis, calcule C<gmtime(time())>.

Dans un contexte scalaire, retourne la valeur de ctime(3) :

    $now_string = gmtime;  # e.g., "Thu Oct 13 04:54:34 1994"

Voir aussi la fonction C<timegm()> fournit par le module C<Time::Local> et la
fonction strftime(3) disponible via le module POSIX.

La valeur scalaire n'est B<pas> dépendante du locale, voir L<perllocale>, mais
est construite de manière interne à Perl. Voir aussi le module C<Time::Local>
et les fonctions strftime(3) et mktime(3) du module POSIX. Pour obtenir
quelque chose de similaire mais dont les chaînes de caractères des dates
dépendent du locale, paramètrez vos variables d'environnement liées au locale
(voir L<perllocale>) et essayez par exemple :

    use POSIX qw(strftime);
        $now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;

Notez que C<%a> et C<%b>, les formes courtes du jour de la semaine et du mois
de l'année, n'ont pas obligatoirement 3 caractères de long.

=item goto LABEL

=item goto EXPR

=item goto &NAME

La forme C<goto-LABEL> trouve la ligne etiquettée par LABEL et continue
l'exécution à cette ligne. On en peut pas l'utiliser pour sauter à l'intérieur
d'une construction qui nécessite une initialisation telle qu'une subroutine ou
une boucle C<foreach>. On ne peut pas non plus l'utiliser pour aller dans une
construction qui peut être optimisée ou pour sortir d'un bloc ou d'une
subroutinee donné à C<sort()>. On peut par contre l'utiliser pour aller
n'importe où dans la portée actuelle même pour sortir des subroutines bien
qu'il soit meilleur d'utiliser pour cela d'autres constructions telles que
C<last> ou C<die()>. L'auteur de Perl n'a jamais ressenti le besoin d'utiliser
cette forme de C<goto> (en Perl bien sûr -- en C, c'est une autre histoire).

La forme C<goto-EXPR> attend un nom d'étiquette dont la portée sera résolue
dynamiquement. Cela autorise les C<goto> calculés à la FORTRAN mais ce n'est
pas vraiment recommandé si vous vous souciez de la maintenance.

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

La forme C<goto-&NAME> est de la vraie magie car il substitue l'appel de la
subroutine en cours d'exécution par un appel à la subroutine donnée en
argument. C'est utilisé par les routines C<AUTOLOAD> qui désirent charger une
autre subroutine puis tout faire comme si c'était cette autre subroutine qui
avait réellement été appelée (sauf que toutes les modifications faites à C<@_>
dans la subroutine courante sont propagées à l'autre subroutine). Après le
C<goto>, même C<caller()> est incapable de s'apercevoir que la subroutine
initiale a été appelée au préalable.

=item grep BLOCK LIST

=item grep EXPR,LIST

Cette fonction est similaire dans l'esprit mais pas identique à grep(1) et tous
ses dérivés. En particulier, elle n'est pas limitée à l'utilisation
d'expressions rationnelles.

Elle évalue le bloc BLOCK ou EXPR pour chaque élément de LIST (qui est
localement lié à C<$_>) et retourne la liste des valeurs constituée des
éléments pour lesquels l'expression est évaluée à TRUE (vrai). Dans un
contexte scalaire, retourne le nombre de fois où l'expression est vraie
(TRUE).

    @foo = grep(!/^#/, @bar);    # supprime les commentaires

ou de manière équivalente :

    @foo = grep {!/^#/} @bar;    # supprime les commentaires

Remarquez que, puisque C<$_> est un référence dans la liste de valeurs, il
peut être utilisé pour modifier les éléments du tableau. Bien que ce soit
supporté et parfois pratique, cela peut aboutir à des résultats bizarres si
LIST n'est pas un tableau nommé. De manière similaire, grep renvoie des alias
de la liste originale exactement comme le fait une variable de boucle for. Et
donc, modifier un élément d'une liste retournée par grep (par exemple dans un
C<foreach>, un C<map()> ou un autre C<grep()>) modifie réellement l'élément de
la liste originale.

Voir aussi L</map> pour obtenir un tableau composé des résultats de BLOCK ou EXPR.

=item hex EXPR

=item hex

Interprête EXPR comme une chaîne héxadécimale et retourne la valeur
correspondante. (Pour convertir des chaînes qui commencent soit par 0 soit par
0x voir L</oct>.) Si EXPR est omis, c'est C<$_> qui est utilisé.

    print hex '0xAf'; # affiche '175'
    print hex 'aF';   # idem

=item import

Il n'existe pas de fonction interne C<import()>. C'est juste une méthode
ordinaire (une subroutine) définie (ou héritée) par les modules qui veulent
exporter des noms vers d'autres modules. Le fonction C<use()> appelle la
méthode C<import()> du paquetage utilisé. Voir aussi L</use()>, L<perlmod> et
L<Exporter>.

=item index STR,SUBSTR,POSITION

=item index STR,SUBSTR

Retourne la position de la première occurrence du SUBSTR dans STR à partir de
POSITION inclu. Si POSITION est omis, le recherche commence au début de la
chaîne. La valeur retournée est relative à C<0> (ou à la valeur que vous avez
affectée à la variable C<$[> -- mais ce n'est pas à faire). Si la sous-chaîne
SUBSTR n'est pas trouvée, la valeur retournée est la valeur de référence moins 1
(habituellement C<-1>).

=item int EXPR

=item int

Retourne la partie entière de EXPR. Si EXPR est omis, c'est C<$_> qui est
utilisé. Vous ne devriez pas utiliser cette fonction pour faire des arrondis
parce qu'elle tronque la valeur vers C<0> et parce que la représentation
interne des nombre en virgule flottante produit parfois des résultat
contre-intuitifs. Habituellement C<sprintf()> et C<printf()> ou les fonctions
C<POSIX::floor> et C<POSIX::ceil> vous seront plus utiles.

=item ioctl FILEHANDLE,FUNCTION,SCALAR

Implémente la fonction ioctl(2). Vous aurez probablement à dire :

    require "ioctl.ph"; # probablement dans /usr/local/lib/perl/ioctl.ph

en premier lieu pour obtenir les définitions correctes des fonctions. Si
F<ioctl.ph> n'existe pas ou ne donne pas les définitions correctes, vous
devrez les fournir vous-même en vous basant sur des fichiers d'en-têtes C
tels que F<E<lt>sys/ioctl.hE<gt>>. (Il existe un script Perl appelé B<h2ph>
qui vient avec le kit Perl et qui devrait vous aider à faire cela mais il
n'est pas trivial.) SCALAR sera lu et/ou modifié selon la fonction FUNCTION --
un pointeur sur la valeur alphanumérique de SCALAR est passé comme troisième
argument du vrai appel système C<ioctl()>. (Si SCALAR n'a pas de valeur
alphanumérique mais a une valeur numérique, c'est cette valeur qui sera passée
plutôt que le pointeur sur la valeur alphanumérique. Pour garantir que c'est
bien ce qui se passera, ajouter C<0> au scalaire avant de l'utiliser.) Les
fonction C<pack()> et C<unpack()> permettent de manipuler les différentes
structures utilisées par C<ioctl()>. L'exemple suivant montre comment
positionner le caractère d'effacement à DEL.

    require 'ioctl.ph';
    $getp = &TIOCGETP;
    die "NO TIOCGETP" if $@ || !$getp;
    $sgttyb_t = "ccccs";                # 4 caractères et un short
    if (ioctl(STDIN,$getp,$sgttyb)) {
        @ary = unpack($sgttyb_t,$sgttyb);
        $ary[2] = 127;
        $sgttyb = pack($sgttyb_t,@ary);
        ioctl(STDIN,&TIOCSETP,$sgttyb)
            || die "Can't ioctl: $!";
    }

La valeur de retour de C<ioctl()> (et de C<fcntl()>) s'interprête comme suit :

        si l'OS retourne:       alors Perl retourne:
            -1                         undef
             0                  la chaîne "0 but true"
        une autre valeur            cette valeur

Donc Perl retourne TRUE (vrai) en cas de succès et FALSE (faux) sinon. Et vous
pouvez encore retrouver facilement la valeur réelle retournée par le système
d'exploitation :

    ($retval = ioctl(...)) || ($retval = -1);
    printf "System returned %d\n", $retval;

La chaîne spéciale "C<0> but true" est traitée par B<-w> comme une exception
qui ne déclenche pas le message d'avertissement concernant les conversions
numériques incorrectes.

=item join EXPR,LIST

Concatène les différentes chaînes de LIST en une seule chaîne où les champs sont
séparés par la valeur de EXPR et retourne cette chaîne. Exemple :

    $_ = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);

Voir L</split>.

=item keys HASH

Retourne une liste constituée de toutes les clés (en anglais : keys) de la
table de hachage fournies. (Dans un contexte scalaire, retourne le nombre de
clés.) Les clés sont produites dans un ordre apparement aléatoire mais c'est
exactement le même que celui produit par les fonctions C<values()> ou
C<each()> (en supposant que la table de hachage n'a pas été modifiée). Un
effet de bord est la réinitialisation de l'itérateur de HASH.

Voici encore une autre manière d'afficher votre environnement :

    @keys = keys %ENV;
    @values = values %ENV;
    while ($#keys >= 0) {
        print pop(@keys), '=', pop(@values), "\n";
    }

et comment trier tout cela par ordre des clés :

    foreach $key (sort(keys %ENV)) {
        print $key, '=', $ENV{$key}, "\n";
    }

Pour trier un tableau par valeur, vous aurez à utiliser la fonction
C<sort()>. Voici le tri d'une table de hachage par ordre décroissant de ses
valeurs :

    foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
        printf "%4d %s\n", $hash{$key}, $key;
    }

En tant que lvalue (valeur modifiable), C<keys()> vous permet de d'augmenter
le nombre de receptacles alloués pour la table de hachage concernée. Cela peut
améliorer les performances lorsque vous savez à l'avance qu'une table va
grossir. (C'est tout à fait similaire à l'augmentation de taille d'un tableau
en affectant une grande valeur à $#tableau.) Si vous dites :

    keys %hash = 200;

alors C<%hash> aura au moins 200 receptacles alloués -- 256 en fait, puisque
la valeur est arrondie à la puissance de deux immédiatement supérieure. Ces
receptacles seront conservés même si vous faites C<%hash = ()>. Utilisez
C<undef %hash> si vous voulez réellement libérer l'espace alloué. En revanche,
vous ne pouvez pas utiliser cette méthode pour réduire le nombre de
receptacles alloués (n'ayez aucune inquiétude si vous le faites tout de même
par inadvertance : cela n'a aucun effet).

=item kill LIST

Envoie un signal à une liste de processus. Le premier élément de la liste doit
être le signal à envoyer. Retourne le nombre de processus qui ont été
correctement « signalés » .

    $cnt = kill 1, $child1, $child2;
    kill 9, @goners;

Au contraire du shell, en Perl, si I<SIGNAL> est négatif, il « kill » le
groupe de processus plutôt que les processus. (Sur System V, un numéro de
I<PROCESSUS> négatif « kill » 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<perlipc/"Signaux"> pour tous les détails.

=item last LABEL

=item last

La command C<last> est comme l'instruction C<break> en C (telle qu'elle est
utilisée dans les boucles) ; cela permet de sortir immédiatement de la boucle
en question. En l'absence de LABEL, la commande se réfère à la boucle
englobante la plus profonde. Le bloc C<continue>, si il existe, n'est pas
exécuté :

    LINE: while (<STDIN>) {
        last LINE if /^$/;      # exit when done with header
        #...
    }

Voir aussi L</continue> pour une illustration du comment marche C<last>,
C<next> et C<redo>.

=item lc EXPR

=item lc

Retourne une version de EXPR entièrement en minuscules. C'est la fonction
interne qui implémente le séquence d'échappement C<\L> dans les chaînes entre
guillemets. Respecte le locale courant C<LC_CTYPE> si C<use locale> est
actif. Voir L<perllocale>.

En l'absence de EXPR, s'applique à C<$_>.

=item lcfirst EXPR

=item lcfirst

Retourne un version de EXPR avec le premier caractère en minuscule. C'est la
fonction interne qui implémente le séquence d'échappement C<\l> dans les
chaînes entre guillemets. Respecte le locale courant C<LC_CTYPE> si C<use
locale> est actif. Voir L<perllocale>.

En l'absence de EXPR, s'applique à C<$_>.

=item length EXPR

=item length

Retourne la longueur en octets de la valeur de EXPR. En l'absence de EXPR,
s'applique à C<$_>.

=item link OLDFILE,NEWFILE

Créer un nouveau fichier NEWFILE lié à l'ancien fichier OLDFILE. Retourne TRUE
(vrai) en cas de succés ou FALSE (faux) sinon.

=item listen SOCKET,QUEUESIZE

Fair exactement la même chose que l'appel système du même nom. Retourne TRUE
(vrai) en cas de succès ou FALSE (faux) sinon. Voir les examples dans
L<perlipc/"Sockets : Communication Client/Serveur">.

=item local EXPR

local modifie les variables listées pour qu'elles soient locales au
bloc/fichier/eval englobant. Si plus d'une valeur est donnée, la liste doit
être placée entre parenthèses. Voir L<perlsub/"Temporary Values via local()">
pour plus de détails, en particulier tout ce qui touchent aux tables de
hachage et aux tableaux liés (par tie()).

Vous devriez certainement utiliser C<my()> à la place car C<local()> n'a pas
la sémantique que la plupart des gens accorde à la notion « local ». Voir
L<perlsub/"Private Variables via my()"> pour plus de détails.

=item localtime EXPR

Convertit une date telle que retournée par le fonction time en un tableau de 9
éléments avec la date liée au fuseau horaire local.  On l'utilise typiquement
de la manière suivante :

    #  0    1    2      3      4      5      6      7      8
    ($sec,$min,$heure,$mjour,$mois,$annee,$sjour,$ajour,$isdst) =
                                                localtime(time);

Tous les éléments du tableau sont numériques et viennent tels qu'ils
apparaissent dans une structure tm. En particulier, cela signifie que C<$mois>
est dans l'intervalle C<0..11> et que C<$sjour> est dans l'intervalle C<0..6>
avec le dimanche comme jour C<0>. D'autre part, C<$annee> est le nombre
d'années depuis 1900 et donc C<$annee> vaut C<123> en l'an 2023 et I<non pas>
simplement les deux derniers chiffres de l'année.

En l'absence de EXPR, localtime utilise la date courante (C<localtime(time)>).

Dans un contexte scalaire, retourne la valeur de ctime(3) :

    $now_string = localtime;  # e.g., "Thu Oct 13 04:54:34 1994"

La valeur scalaire n'est B<pas> dépendante du locale, voir L<perllocale>, mais
est construite de manière interne à Perl. Voir aussi le module C<Time::Local>
et les fonctions strftime(3) et mktime(3) du module POSIX. Pour obtenir
quelque chose de similaire mais dont les chaînes de caractères des dates
dépendent du locale, paramètrez vos variables d'environnement liées au locale
(voir L<perllocale>) et essayez par exemple :

    use POSIX qw(strftime);
        $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;

Notez que C<%a> et C<%b>, les formes courtes du jour de la semaine et du mois
de l'année, n'ont pas obligatoirement 3 caractères de long.

=item log EXPR

=item log

Retourne le logarithme néperien (base I<e>) de EXPR. En l'absence de EXPR,
retourne le log de C<$_>.

=item lstat FILEHANDLE

=item lstat EXPR

=item lstat

Fait la même chose que la fonction C<stat()> (y compris de modifier le
filehandle spécial C<_>) mais fournit les données du lien symbolique au lieu
de celles du fichier pointé par le lien. Si les liens symboliques ne sont
implémentés dans votre système, un appel normal à C<stat()> est effectué.

En l'absence de EXPR, utilise C<$_>.

=item m//

L'opérateur de correspondance (d'expressions rationelles). Voir L<perlop>.

=item map BLOCK LIST

=item map EXPR,LIST

Évalue le bloc BLOCK ou l'expression EXPR pour chaque élément de LIST (en
affectant localement chaque élément à C<$_>) et retourne la liste de valeurs
constituée de tous les résultats de ces évaluations. L'évaluation du bloc
BLOCK ou de l'expression EXPR a lieu dans un contexte de liste si bien que
chaque élément de LIST peut produire zéro, un ou plusieurs éléments comme
valeur retournée.

    @chars = map(chr, @nums);

transcrit une liste de nombres vers les caractères correspondants. Et :

    %hash = map { getkey($_) => $_ } @array;

est juste une jolie manière de dire :

    %hash = ();
    foreach $_ (@array) {
        $hash{getkey($_)} = $_;
    }

Remarquez que du fait que C<$_> est une référence vers la liste de valeurs, il
peut être utiliser pour modifier les éléments du tableau. Bien que cela soit
pratique et supporté, cela peut produire des résultats bizarres si LIST n'est
pas un tableau nommé. Voir aussi L</grep> pour produire un tableau composé de
tous les éléments de la liste originale pour lesquels BLOCK ou EXPR est évalué
à vrai (true).

=item mkdir FILENAME,MODE

Crée le répertoire dont le nom est spécifié par FILENAME avec les droits
d'accès spécifiés par MODE (et modifiés par umask). En cas de succès, retourne
TRUE (vrai). Sinon, retourne FALSE (faux) et positionne la variable C<$!>
(errno).

=item msgctl ID,CMD,ARG

Appelle la fonction msgctl(2) des IPC System V. Vous devrez probablement dire
:

    use IPC::SysV;

au préalable pour avoir les définitions correctes des constantes. Si CMD est
C<IPC_STAT> alors ARG doit être une variable qui pourra contenir la structure
C<msqid_ds> retournée. Renvoie la même chose que C<ioctl()> : la valeur undef
en cas d'erreur, "C<0> but true" pour la valeur zéro ou la vrai valeur dans
les autres cas. Voir aussi C<IPC::SysV> et C<IPC::Semaphore::Msg>.

=item msgget KEY,FLAGS

Appelle la fonction msgget(2) des IPC System V. Retourne l'id de la queue de
messages ou la valeur undef en cas d'erreur. Voir aussi C<IPC::SysV> et
C<IPC::SysV::Msg>.

=item msgsnd ID,MSG,FLAGS

Appelle la fonction msgsnd des IPC System V pour envoyer le message MSG dans
la queue de messages d'identificateur ID. MSG doit commencer par l'entier
long donnant le type de message. Cet entier peut être créé en utilisant
C<pack("l", $type)>. Retourne TRUE (vrai) en cas de succès ou FALSE (faux) en
cas d'erreur. Voir aussi C<IPC::SysV> et C<IPC::SysV::Msg>.

=item msgrcv ID,VAR,SIZE,TYPE,FLAGS

Appelle la fonction msgrcv des IPC System V pour recevoir un message à partir
de la queue de message d'identificateur ID et le stocker dans la variable VAR
avec une taille maximale de SIZE. Remarquez que, si un message est reçu, le
type de message sera la première chose dans VAR et que la taille maximale de
VAR est SIZE plus la taille du type de message. Retourne TRUE (vrai) en cas de
succès ou FALSE (faux) sinon. Voir aussi C<IPC::SysV> et C<IPC::SysV::Msg>.

=item my EXPR

C<my()> déclare les variables listées comme étant locales (lexicallement) au
bloc, fichier ou C<eval()> englobant. Si plus d'une variable est listée, la
liste doit être placée entre parenthèses. Voir L<perlsub/"Private Variables
via my()"> pour plus de détails.

=item next LABEL

=item next

La commande C<next> fonctionne comme l'instruction C<continue> du C ; elle
commence la prochaine itération d'une boucle :

    LINE: while (<STDIN>) {
        next LINE if /^#/;      # ne pas traiter les commentaires
        #...
    }

Si il y avait un bloc C<continue>, dans cet exemple, il serait exécuté même
pour les lignes ignorées. Si LABEL est omis, la commande se réfère au bloc
englobant le plus intérieur.

Voir aussi L</continue> pour voir comment C<last>, C<next> et
C<redo> fonctionne.

=item no Module LIST

Voir la fonction L</use> pour laquelle C<no> est le contraire.

=item oct EXPR

=item oct

Interprête EXPR comme une chaîne octale et retourne la valeur
correspondante. (Si il s'avère que EXPR commence par C<0x>, elle sera
interpétée comme un chaîne héxadécimale.) La ligne suivante manipule les
chaîne décimales, octales et héxadécimales comme le fait la notation Perl ou C
:

    $val = oct($val) if $val =~ /^0/;

Si EXPR est absent, la commande s'applique à C<$_>. Cette fonction est
couramment utilisée pour convertir une chaîne telle que C<644> en un mode
d'accès pour fichier par exemple. (perl convertit automatiquement les chaînes
en nombres si besoin mais en supposant qu'ils sont en base 10.)

=item open FILEHANDLE,EXPR

=item open FILEHANDLE

Ouvre le fichier dont le nom est donné par EXPR et l'associe a FILEHANDLE. Si
FILEHANDLE est une expression, sa valeur est utilisée comme nom de filehandle
à associer. Si EXPR est omis, la variable scalaire du même nom que le
FILEHANDLE contient le nom du fichier. (Remarquez que les variables lexicales
-- celles déclarées par C<my()> -- ne fonctionnent pas dans ce cas ; donc si
vous utilisez C<my()>, spécifiez EXPR dans votre appel à open.)

Si le nom de fichier commence par C<'E<lt>'> ou rien, le fichier est ouvert en
lecture. Si le nom de fichier commence par C<'E<gt>'>, le fichier est tronqué
et ouvert en écriture. Il sera même créé si nécessaire. Si le nom de fichier
commence par C<'E<gt>E<gt>'>, le fichier est ouvert en ajout. Là encore, il
sera créé si nécessaire. Vous pouvez ajouter un C<'+'> devant C<'E<gt>'> ou
C<'E<lt>'> pour indiquer que vous voulez à la fois les droits d'écriture et de
lecture sur le fichier; ceci étant C<'+E<lt>'> est toujours mieux pour les
mises à jour en lecture/écriture -- le mode C<'+E<gt>'> écraserait le fichier
au préalable. Habituellement, il n'est pas possible d'utiliser le mode
lecture/écriture pour des fichiers textes puisqu'ils ont des tailles
d'enregistrements variables.  Voir l'option B<-i> dans L<perlrun> pour une
meilleure approche.

Le préfixe et le nom du fichier peuvent être séparés par des espaces. Ces
différents préfixes correspondent aux différents modes d'ouverture de fopen(3)
: C<'r'>, C<'r+'>, C<'w'>, C<'w+'>, C<'a'> et C<'a+'>.

Si le nom de fichier commence par C<'|'>, le nom de fichier est interpété
comme une commande vers laquelle nous dirigerons nos sorties (via un tube --
en anglais pipe) et si le nom de fichier se termine par C<'|'>, le nom de
fichier est interpété comme une commande dont nous récupérons la sortie (via
un tube -- en anglais pipe). Voir L<perlipc/"Utilisation de open() pour la
CIP"> pour des exemples à ce sujet. (Vous ne pouvez pas utilisez C<open()>
pour une commande qui utiliserait un même tube à la fois pour ses entrées
I<et> pour ses sorties mais L<IPC::Open2>, L<IPC::Open3> et
L<perlipc/"Communication Bidirectionnelle avec un autre Processus"> proposent
des solutions de remplacement.)

Ouvrir C<'-'> revient à ouvrir STDIN tandis qu'ouvrir C<'E<gt>-'> revient à
ouvrir STDOUT. Open renvoie une valeur non-nulle en cas de succès et undef
sinon. Si C<open()> utilise un tube, la valeur de retour sera le PID du
sous-processus.

Si, par malheur, vous utilisez Perl sur un système qui fait une distinction
entre les fichiers textes et les fichiers binaires (les systèmes
d'exploitation modernes ne font pas de différence) alors vous devriez
regarder du côté de L</binmode> pour connaître les astuces à ce sujet. La
différence entre les systèmes nécessitant C<binmode()> et les autres réside
dans le format de leurs fichiers textes. Des systèmes tels que Unix, MacOS et
Plan9 qui délimitent leurs lignes par un seul caractère et qui encode ce
caractère en C par C<"\n"> ne nécessitent pas C<binmode()>. Les autres en ont
besoin.

À l'ouverture d'un fichier, c'est généralement une mauvaise idée de continuer
l'exécution normale si la requête échoue, ce qui explique pourquoi C<open()>
est si fréquemment utilisé en association avec C<die()>. Même si C<die()>
n'est pas ce que voulez faire (par exemple dans un script CGI oú vous voulez
récupérer un message d'erreur joliment présenté (il y a des modules qui
peuvent vous aider pour cela)), vous devriez toujours vérifier la valeur
retournée par l'ouverture du fichier. L'une des seules exceptions est lorsque
vous voulez travailler sur un filehandle non-ouvert.

Exemples:

    $ARTICLE = 100;
    open ARTICLE or die "Can't find article $ARTICLE: $!\n";
    while (<ARTICLE>) {...

    open(LOG, '>>/usr/spool/news/twitlog'); # (log is reserved)
    # si le open échoue, les sorties sont perdues

    open(DBASE, '+<dbase.mine')             # ouverture pour mise a jour
        or die "Can't open 'dbase.mine' for update: $!";

    open(ARTICLE, "caesar <$article |")     # decryptage de l'article
        or die "Can't start caesar: $!";

    open(EXTRACT, "|sort >/tmp/Tmp$$")      # $$ est l'id de notre processus
        or die "Can't start sort: $!";

    # traitement de la liste des fichiers fournis en argument

    foreach $file (@ARGV) {
        process($file, 'fh00');
    }

    sub process {
        my($filename, $input) = @_;
        $input++;               # c'est une incrémentation de chaîne
        unless (open($input, $filename)) {
            print STDERR "Can't open $filename: $!\n";
            return;
        }

        local $_;
        while (<$input>) {              # remarquez l'utilisation de l'indirection
            if (/^#include "(.*)"/) {
                process($1, $input);
                next;
            }
            #...                # ce qu'il faut faire...
        }
    }

Vous pouvez aussi, dans la tradition du Bourne shell, spécifier une expression
EXPR commençant par C<'E<gt>&'> auquel cas le reste de la chaîne sera
interpété comme le nom d'un filehandle (ou d'un descripteur de fichier si
c'est une valeur numérique) à dupliquer puis à ouvrir. Vous pouvez utiliser
C<&> après C<E<gt>>, C<E<gt>E<gt>>, C<E<lt>>, C<+E<gt>>, C<+E<gt>E<gt>> et
C<+E<lt>>. Le mode que vous spécifiez devrait correspondre à celui du
filehandle original. (La duplication d'un filehandle ne prend pas en compte
l'éventuel contenu des buffers (tampons) de stdio (les entrées/sorties standard).)
Voici un script qui sauvegarde, redirige et restaure STDOUT et STDERR :

    #!/usr/bin/perl
    open(OLDOUT, ">&STDOUT");
    open(OLDERR, ">&STDERR");

    open(STDOUT, ">foo.out") || die "Can't redirect stdout";
    open(STDERR, ">&STDOUT") || die "Can't dup stdout";

    select(STDERR); $| = 1;     # fonctionnement sans tampon
    select(STDOUT); $| = 1;     # fonctionnement sans tampon

    print STDOUT "stdout 1\n";  # cela fonctionne aussi
    print STDERR "stderr 1\n";  # pour les processus fils

    close(STDOUT);
    close(STDERR);

    open(STDOUT, ">&OLDOUT");
    open(STDERR, ">&OLDERR");

    print STDOUT "stdout 2\n";
    print STDERR "stderr 2\n";

Si vous spécifiez C<'E<lt>&=N'>, où C<N> est un nombre, alors Perl fera
l'equivalent d'un C<fdopen()> en C sur ce descripteur de fichier ; c'est plus
avare en descripteur de fichier. Par exemple :

    open(FILEHANDLE, "<&=$fd")

Si vous ouvrez un tube (pipe) sur la command C<'-'>, i.e. soit C<'|-'> soit
C<'-|'>, alors vous faites un fork implicite et la valeur de retour de open
est le PID du processus fils pour le processus père et C<0> pour le processus
fils. (Utilisez C<defined($pid)> pour savoir si le open s'est bien déroulé.)
Le filehandle se comporte normalement pour le père mais pour le processus
fils, les entrées/sorties sur ce filehandle se font via STDIN/STDOUT. Dans le
processus fils, le filehandle n'est pas ouvert -- les échanges se font via les
nouveaux STDIN ou STDOUT. Cela s'avère utile lorsque vous voulez avoir un
contrôle plus fin sur la commande exécutée par exemple lorsque vous avez un
script setuid et que vous ne voulez pas que le shell traite les métacaractères
dans les commandes. Les lignes suivantes sont quasimment équivalentes (deux à
deux) :

    open(FOO, "|tr '[a-z]' '[A-Z]'");
    open(FOO, "|-") || exec 'tr', '[a-z]', '[A-Z]';

    open(FOO, "cat -n '$file'|");
    open(FOO, "-|") || exec 'cat', '-n', $file;

Voir L<perlipc/"Ouvertures Sûres d'un Tube"> pour plus d'exemples à ce sujet.

Remarque : pour toutes les opérations impliquant un fork, tous les tampons
(buffers) non-vidés le restent pour les deux processus ce qui signifie que vous
devriez positionner C<$|> pour éviter les sorties en double.

La fermeture d'un filehandle utilisant un tube (pipe) amène le processus père
à attendre que son fils se termine puis à retourner la valeur de statut dans
C<$?>.

Le nom de fichier passé à open aura ses éventuels espaces avant et après
supprimés et les caractères de redirection normaux seront respectés. Cette
fonctionnalité, connue sous le nom "ouverture magique", autorise plein de
bonnes choses. Un utilisateur peut spécifier un nom de fichier tel que F<"rsh
cat file |"> ou alors vous pouvez modifier certains noms de fichiers selon vos
besoins :

    $filename =~ s/(.*\.gz)\s*$/gzip -dc < $1|/;
    open(FH, $filename) or die "Can't open $filename: $!";

Par contre pour ouvrir un fichier dont le nom contient des caractères
bizarroïdes, il est nécessaire de protéger tous les espaces avant et/ou après :

    $file =~ s#^(\s)#./$1#;
    open(FOO, "< $file\0");

Si vous voulez un "vrai" C<open()> à la C (Voir L<open(2)> sur votre système)
alors vous devriez utiliser la fonction C<sysopen()> qui ne fait rien de
magique. C'est un autre moyen de protéger vos noms de fichiers de toute
interpétation. Par exemple :

    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 $$\n");
    seek(HANDLE, 0, 0);
    print "File contains: ", <HANDLE>;

En utilisant le constructeur du paquetage C<IO::Handle> (ou de l'une de ses
sous-classes telles que C<IO::File> ou C<IO::Socket>), vous pouvez générer des
filehandle anonymes qui ont la portée des variables qui gardent une référence
sur eux et qui se ferment automatiquement dès qu'ils sont hors de portée :

    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 automatqieu ici
        mung $first or die "mung failed";       # Ou ici.
        return $first, <$handle> if $ALL;       # Ou ici.
        $first;                                 # Ou ici.
    }

Voir L</sekk()> pour de plus amples informations sur le mélange entre lecture
et écriture.

=item opendir DIRHANDLE,EXPR

Ouvre le répertoire nommé par EXPR pour un traitmement par C<readdir()>,
C<telldir()>, C<seekdir()>, C<rewinddir()> et C<closedir()>. Retourne TRUE
(vrai) en cas de succès. les DIRHANDLEs ont leur propre espace de noms séparé
de celui des FILEHANDLEs.

=item ord EXPR

=item ord

Retourne la valeur numérique ASCII du premier caractère de EXPR. Si EXPR est
omis, utilise C<$_>. Voir L</chr> pour l'opération inverse.

=item pack TEMPLATE,LIST

Prend un tableau ou une liste de valeurs, et la compacte en une structure
binaire puis retourne la chaîne contenant cette structure. Le TEMPLATE est une
séquence de caractères qui donne l'ordre et le type des valeurs de la manière
suivante :

    A   Une chaîne ASCII, complétée par des blancs.
    a   Une chaîne ASCII, complétée par des caractères NUL.
    b   Une chaîne de bits (en ordre croissant, comme pour vec()).
    B   Une chaîne de bits (en ordre décroissant).
    h   Une chaîne héxadécimale (chiffres héxadécimaux faibles en premier).
    H   Une chaîne héxadécimale (chiffres héxadécimaux forts en premier).

    c   La valeur d'un caractère signé
    C   La valeur d'un caractère non-signé

    s   La valeur d'un entier court (short) signé
    S   La valeur d'un entier court (short) non-signé
           (Ce 'short' est exactement sur 16 bits ce qui peut
            être différent de ce qu'un compilateur C local
            appelle 'short'.)

    i   La valeur d'un entier (integer) signé.
    I   La valeur d'un entier (integer) non-signé.
           (Cet 'integer' est d'au moins sur 32 bits. Sa taille
            exact dépend de ce que le compilateur C local appelle 'int'
            et peut même être plus long que le 'long' décrit
            à l'item suivant.)

    l   La valeur d'un entier long (long) signé.
    L   La valeur d'un entier long (long) non-signé.
           (Ce 'long' est exactement sur 32 bits ce qui peut
            être différent de ce qu'un compilateur C local
            appelle 'long'.)

    n   Un entier court (short) dans l'ordre "réseau" (big-endian).
    N   Un entier long (long) dans l'ordre "réseau" (big-endian).
    v   Un entier court (short) dans l'ordre "VAX" (little-endian).
    V   Un entier long (long) dans l'ordre "VAX" (little-endian).
           (Ces 'shorts' et ces 'longs' font exactement
            16 et 32 bits respectivement.)

    f   Un flottant simple précision au format natif.
    d   Un flottant double précision au format natif.

    p   Un pointeur vers une chaîne terminée par un caractère NUL.
    P   Un pointeur vers une structure (une chaîne de longueur fixe).

    u   Une chaîne uuencodée.

    w   Un entier BER compressé. Ses octets représentent chacun un entier
        non-signé en base 128. Les chiffres les plus significatifs viennent
        en premier et il y a le moins de chiffres possibles. Le huitième bit
        (le bit de poids fort) est toujours à 1 pour chaque octets sauf le dernier.

    x   Un octet nul.
    X   Retour en arrière d'un octet.
    @   Remplissage par des octets nuls jusqu'à une position absolue.

Chaque lettre peut éventuellement être suivie d'un nombre spécifiant le nombre
de répétition. Pour tous les types (sauf C<"a">, C<"A">, C<"b">, C<"B">,
C<"h">, C<"H"> et C<"P">), la fonction pack utilisera autant de valeurs de la
liste LIST que nécessaire. Une C<*> comme valeur de répétition demande à
utiliser toutes les valeurs restantes. Les types C<"a"> et C<"A"> n'utilisent
qu'une seule valeur mais la compacte sur la longueur spécifiée en la
complétant éventuellement par des espaces ou des caractères NUL. (Lors du
décompactage, C<"A"> supprime les espaces et les caractères NUL alors que
C<"a"> ne le fait pas.) De la même manière, les types C<"b"> et C<"B">
remplissent la chaîne compactée avec autant de bits que demandés. Le type
C<"p"> compactera une chaîne terminée par un caractère NUL dont on donne le
pointeur. Un pointeur NULL est créé si la valeur correspondant à C<"p"> ou
C<"P"> est C<undef>. Les nombres réels (simple et double précision) sont
uniquement au format natif de la machine. À cause de la multiplicité des
formats existants pour les flottants et du manque d'une représentation
"réseau" standard, aucune possibilité d'échange n'est proposée. Cela signifie
que les données réelles compressées sur une machine peuvent ne pas être
lisibles par une autre machine -- même si elles utilisent toutes deux
l'arithmétique flottante IEEE. Sachez que Perl utilise des doubles en interne
pour tous les calculs numériques et qu'une conversion de double vers float
puis retour vers double amène à une perte de précision (i.e., C<unpack("f",
pack("f", $foo)>) est généralement différent de C<$foo>).

Exemples :

    $foo = pack("cccc",65,66,67,68);
    # foo eq "ABCD"
    $foo = pack("c4",65,66,67,68);
    # idem

    $foo = pack("ccxxcc",65,66,67,68);
    # foo eq "AB\0\0CD"

    $foo = pack("s2",1,2);
    # "\1\0\2\0" sur little-endian
    # "\0\1\0\2" sur big-endian

    $foo = pack("a4","abcd","x","y","z");
    # "abcd"

    $foo = pack("aaaa","abcd","x","y","z");
    # "axyz"

    $foo = pack("a14","abcdefg");
    # "abcdefg\0\0\0\0\0\0\0"

    $foo = pack("i9pl", gmtime);
    # une vrai structure tm (sur mon système en tous cas)

    sub bintodec {
        unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
    }

La même valeur de TEMPLATE peut généralement être utilisée avec la fonction unpack.

=item package

=item package NAMESPACE

Déclare l'unité de compilation comme faisant partie de l'espace de nommage
NAMESPACE. La portée de la déclaration package (NdT: paquetage en français)
commence à la déclaration elle-même et se termine à la fin du block englobant
(c'est la même portée que l'opérateur C<local()>). Tous identificateurs
dynamique non qualifié à venir sera dans cet espace de nommage. Une
instruction package n'affecte que que les variables dynamiques -- même celles
sur lesquelles vous utilisez C<local()> -- et I<pas> les variables lexicales
créées par C<my()>. C'est souvent la première déclaration dans un fichier
inclus par les commandes C<require> ou C<use>. Vous pouvez basculer vers un
même paquetage en plusieurs endroits ; cela ne fait que changer la table de
symboles utilisée par le compilateur pour la suite du bloc. Vous pouvez
référencer des variables ou des filehandles d'autres packages en préfixant
l'identificateur par le nom du package suivi de deux fois deux points :
C<$Package::Variable>. Si le nom de paquetage est vide, c'est la paquetage
C<main> qui est utilisé. Donc C<$::sail> est équivalent à C<$main::sail>.

Si NAMESPACE est omis alors il n'y a pas de paquetage courant et tous les
identificateurs doivent être soit complétement qualifiés soit lexicaux. C'est
plus strict que C<use stric> puisque cela inclut aussi les noms de fonctions.

Voir L<perlmod/"Paquetages"> pour des plus amples informations à propos des
paquetages (packages), des modules et des classes. Voir L<perlsub> pour tous
les problèmes de portée.

=item pipe READHANDLE,WRITEHANDLE

Ouvre une paire de tubes (pipe) exactement comme l'appel système
correspondant. Remarquez qu'en faisant une boucle de tubes entre plusieurs
processus vous risquez un interblocage (deadlock) à moins d'y faire très
attention. De plus, sachez que les tubes de Perl utilise les tampons (buffers)
de stdio. Donc, selon les applications, vous aurez peut-être à positionner
correctement C<$|> pour vider vos WRITEHANDLE après chaque commande.

Voir L<IPC::Open2>, L<IPC::Open3> et L<perlipc/"Communication Bidirectionnelle
avec un autre Processus"> pour des exemples sur tout ça.

=item pop ARRAY

=item pop

Dépile et retourne la dernière valeur du tableau ARRAY. La taille du tableau
est diminué d'une unité. Cette commande a le même effet que :

    $tmp = $ARRAY[$#ARRAY--];

Si le tableau est vide, c'est la valeur undef qui est retournée. Si ARRAY est
omis, pop dépilera soit le tableau C<@ARGV> dans le programme principale soit
C<@_> dans les subroutines, exactement comme C<shift()>.

=item pos SCALAR

=item pos

Retourne l'offset (l'index du caractère dans la chaîne) où s'est arrêté la
dernière recherche C<m//g> sur la variable SCALAR spécifiée (s'appliquera à
C<$_> si la variable SCALAR n'est pas spécifiée). Peut être utilisé pour
modifier cette offset. Une telle modification influe aussi sur l'assertion de
longueur nulle C<\G> dans les expressions rationelles. Voir L<perlre> et
L<perlop>.

=item print FILEHANDLE LIST

=item print LIST

=item print

Affiche une chaîne ou une liste de chaînes séparées par des virgules. Retourne
TRUE (vrai) en cas de succès. FILEHANDLE peut être une variable scalaire
auquel cas cette variable contiendra le nom ou la référence du FILEHANDLE et
donc introduira un niveau d'indirection supplémentaire. (REMARQUE: si
FILEHANDLE est une variable et que l'élément syntaxique qui suit est un terme,
il peut être interpété accidentellement comme un opérateur à moins d'ajouter
un C<+> ou de mettre des parenthèses autour des arguments.) Si FILEHANDLE
n'est spécifié, affichera par défaut sur la sortie standard (ou le dernier
canal de sortie sélectionné -- voir L</select>). Si la liste LIST est
elle-aussi omise, affichera C<$_> sur le canal de sortie courant. Pour
utiliser un autre canal que STDOUT comme canal de sortie par défaut, utilisez
l'opération select. Remarquez qu'étant donné que print utilise une liste
(LIST), tout ce qui est dans LIST est évalué dans un contexte de liste et, en
particulier, toutes les expressions evaluées dans les subroutines appelées le
seront dans un contexte de liste. Faites aussi attention de ne pas faire
suivre le mot-clé print par une parenthèse ouvrante à moins de vouloir clore
la liste de ses arguments à la parenthèse fermante correspondante -- sinon
préfixez votre parenthèse par un C<+> ou entourez tous les arguments par des
parenthèses.

Notez que si vous stockez vos FILEHANDLE dans un tableau (ou quelquechose qui
nécessite une expression), vous aurez à utiliser un bloc qui retourne une
valeur :

    print { $files[$i] } "stuff\n";
    print { $OK ? STDOUT : STDERR } "stuff\n";

=item printf FILEHANDLE FORMAT, LIST

=item printf FORMAT, LIST

Équivalent à C<print FILEHANDLE sprintf(FORMAT, LIST)> sauf que C<$\> (le
séparateur d'enregistrements en sortie) n'est pas ajouté. Le premier argument
de la liste sera interpété comme le format de C<printf()>. Si C<use local> est
actif, le caractère utilisé comme séparateur décimal pour les nombres réels
sera dépendant de la valeur de locale spécifiée dans LC_NUMERIC. Voir
L<perlocale>.

Ne tomber pas de le piège d'utiliser C<printf()> alors qu'un simple C<print()>
suffirait. C<print()> est plus efficace et moins sujet à erreur.

=item prototype FUNCTION

Retourne, sous forme de chaîne, le prototype d'une fonction (ou C<undef> si la
fonction n'a pas de prototype). FUNCTION est une référence ou le nom de la
fonction dont on veut retrouver le prototype.

Si FUNCTION est une chaîne commençant par C<CORE::>, la suite de la chaîne se
réfère au nom d'une fonction interne de Perl. Si la fonction interne n'est pas
I<redéfinissable> (par exemple C<qw//>) ou si ses arguments ne peuvent
s'exprimer sous forme de prototype (par exemple C<system()>) - en d'autres
termes, si la fonction interne ne se comporte pas comme une fonction Perl - la
fonction prototype retournera C<undef>. Sinon, c'est la chaîne qui décrit le
prototype qui est retournée.

=item push ARRAY,LIST

Traite ARRAY comme une pile et empile les valeurs de la liste LIST à la fin du
tableau ARRAY. La longueur de ARRAY est augmenté de la longueur de la liste
LIST. Cela a le même effet que :

    for $value (LIST) {
        $ARRAY[++$#ARRAY] = $value;
    }

mais en plus efficace. Retourne le nouveau nombre d'éléments dans le tableau.

=item q/STRING/

=item qq/STRING/

=item qr/STRING/

=item qx/STRING/

=item qw/STRING/

Guillemets/Apostrophes généralisées. Voir L<perlop>.

=item quotemeta EXPR

=item quotemeta

Retourne la valeur de EXPR avec tous les caractères non alphanumériques
précédés par un backslash (une barre oblique inverse). (Tous les caractères
non reconnus par C</[A-Za-z_0-9]/> seront précédés d'un backslash quelques
soient les réglages des locale). C'est la fonction interne qui implémente la
séquence d'échapement C<\Q> dans les chaînes entre guillemets.

Si EXPR ewst omis, s'appliquera à C<$_>.

=item rand EXPR

=item rand

Retourne un nombre fractionnaire aléatoire plus grand ou égal à C<0> et plus
petit que la valeur de EXPR (la valeur de EXPR devrait être positive). À
défaut de EXPR, c'est C<1> qui est utilisé comme borne. Appelle
automatiquement C<srand()> sauf cela a déjà été fait. Voir aussi C<srand()>.

(Remarque: si votre fonction rand retourne régulièrement des nombres trop
grands ou trop petits alors votre version de Perl a probablement été compilée
avec une valeur erronée pour RANDBITS.)

=item read FILEHANDLE,SCALAR,LENGTH,OFFSET

=item read FILEHANDLE,SCALAR,LENGTH

Essaye de lire LENGTH octets depuis le FILEHANDLE spécifié et les stocke dans
la variable SCALAR. Retourne le nombre d'octets réellement lus, C<0> à la fin
du fichier ou undef si une erreur a lieu. La taille de la variable SCALAR
augmentera ou diminuera pour atteindre la taille exacte de ce qui est lu. Un
OFFSET (décalage) peut être spécifié pour placer les données lues ailleurs
qu'au début de la chaîne. Cette fonction est implémenté par des appels à la
fonction fread(3) de stdio. Pour obtenir un véritable appel système read(2),
voir C<sysread()>.

=item readdir DIRHANDLE

Retourne l'entrée de répertoire suivante d'un répertoire ouvert par
C<opendir()>. Dans un contexte de liste, retournera toutes les entrées restant
dans le répertoire. Si il n'y a plus d'entrée, retournera la valeur undef dans
un contexte scalaire ou une liste vide dans un contexte de liste.

Si vous prévoyez de faire des tests de fichiers sur les valeurs retournées par
C<readdir()>, n'oubliez pas de les préfixer par le répertoire en
question. Sinon, puisqu'aucun appel à C<chdir()> n'est effectué, vous risquez de
tester un mauvais fichier.

    opendir(DIR, $some_dir) || die "can't opendir $some_dir: $!";
    @dots = grep { /^\./ && -f "$some_dir/$_" } readdir(DIR);
    closedir DIR;

=item readline EXPR

Lit à partir du filehandle dont le typeglob est contenu dans EXPR. Dans un
contexte scalaire, une seule ligne est lue et retournée. Dans un contexte de
liste, la lecture se fera jusqu'à la fin du fichier et le résultat sera une
liste de lignes (telles que définies par la variable C<$/> ou
C<$INPUT_RECORD_SEPARATOR>). C'est la fonction interne qui implémente
l'opérateur C<E<lt>EXPRE<gt>> mais vous pouvez l'utiliser
directement. L'opérateur C<E<lt>EXPRE<gt>> est décrit en détail dans
L<perlop/"Les opérateurs d'E/S">.

    $line = <STDIN>;
    $line = readline(*STDIN);           # même chose

=item readlink EXPR

=item readlink

Retourne la valeur d'un lien symbolique si les liens symboliques sont
implémentés. Sinon, produit une erreur fatale. Si il y a une erreur système,
cette fonction retournera la valeur undef et positionnera la variable C<$!>
(errno). Si EXPR est omis, s'applique à C<$_>.

=item readpipe EXPR

EXPR est exécuté comme une commande système. La sortie standard de la commande
est collectée puis retournée. Dans un contexte scalaire, cette sortie est une
seule chaîne (contenant éventuellement plusieurs lignes). Dans un contexte de
liste, retourne une liste de lignes (telles que définies par la variable C<$/>
ou C<$INPUT_RECORD_SEPARATOR>). C'est la fonction interne qui implémente
l'opérateur C<qx/EXPR/> mais vous pouvez l'utiliser directement. L'opérateur
C<qx/EXPR/> est d'ecrit plus en détail dans L<perlop/"Les opérateurs d'E/S">.

=item recv SOCKET,SCALAR,LEN,FLAGS

Reçoit un message depuis un socket. Tente de recevoir LENGTH octets de données
dans la variable SCALAR depuis le filehandle spécifié par SOCKET. Effectue en
fait un appel à la fonction C C<recvfrom()> et donc peut retourné l'adresse de
l'envoyeur. Retourne la valeur undef en cas d'erreur. SCALAR grossira ou
réduira jusqu'à la taille des données réellement lues. Utilise les mêmes FLAGS
que l'appel système du même nom. Voir L<perlipc/"UDP : Transfert de Message">
pour des exemples.

=item redo LABEL

=item redo

La commande C<redo> redémarre une boucle sans évaluer à nouveau la
condition. Le bloc C<continue>, s'il existe, n'est pas évalué. Si l'étiquette
LABEL est omise, la commande se réfère à la boucle englobante la plus
profonde. Cette commande est habituellement utilisée par des programmes qui
veulent utiliser eux-mêmes ce qui vient juste d'être lu :

    # un programme simple pour supprimer les commentaires en Pascal
    # (Attention: on suppose qu'il n'y pas de { ni de } dans les chaînes.)
    LINE: while (<STDIN>) {
        while (s|({.*}.*){.*}|$1 |) {}
        s|{.*}| |;
        if (s|{.*| |) {
            $front = $_;
            while (<STDIN>) {
                if (/}/) {      # end of comment?
                    s|^|$front\{|;
                    redo LINE;
                }
            }
        }
        print;
    }

Voir aussi L</continue> pour illustrer la manière dont C<last>, C<next> et
C<redo> fonctionnent.

=item ref EXPR

=item ref

Retourne une valeur TRUE (vraie) si EXPR est une référence, FALSE (faux)
sinon. Si EXPR n'est pas spécifié, s'applique à C<$_>. La valeur retournée
dépend du type de ce qui est référencé par la référence. Les types internes
incluent :

    REF
    SCALAR
    ARRAY
    HASH
    CODE
    GLOB

Si l'objet référencé a été béni (par bless()) par un paquetage alors le nom du
paquetage est retourné. Vous pouvez voir C<ref()> comme une sorte d'opérateur
C<typeof()> (type de).

    if (ref($r) eq "HASH") {
        print "r is a reference to a hash.\n";
    }
    if (!ref($r)) {
        print "r is not a reference at all.\n";
    }

Voir aussi L<perlref>.

=item rename OLDNAME,NEWNAME

Change le nom d'un fichier. Retoure C<1> en cas de succès ou C<0> sinon. Ne
fonctionne pas entre des systèmes de fichier différents.

=item require EXPR

=item require

Exige une « sémantique » spécifiée par EXPR ou par C<$_> si EXPR n'est pas
fourni. Si EXPR est numérique, exige que la version courante de Perl (C$]> ou
$PERL_VERSION) soit égale ou supérieure à EXPR.

Sinon, exige que le fichier d'une bibliothèque soit inclu si ce n'est pas déjà
fait. Le fichier est inclu via le mécanisme do-FICHIER qu est pratiquement une
simple variante de C<eval()>. Sa sémantique est similaire à la procédure
suivante :

    sub require {
        my($filename) = @_;
        return 1 if $INC{$filename};
        my($realfilename,$result);
        ITER: {
            foreach $prefix (@INC) {
                $realfilename = "$prefix/$filename";
                if (-f $realfilename) {
                    $result = do $realfilename;
                    last ITER;
                }
            }
            die "Can't find $filename in \@INC";
        }
        die $@ if $@;
        die "$filename did not return true value" unless $result;
        $INC{$filename} = $realfilename;
        return $result;
    }

Remarquez que le fichier ne sera pas inclu deux fois sous le même nom. Le
fichier doit retourner TRUE (vrai) par sa dernière instruction pour indiquer
un exécution correcte du code d'initialisation. Il est donc courant de
terminer un tel fichier par un "C<1;>" à moins d'être sûr qu'il retournera
TRUE (vrai) par un autre moyen. Mais il est plus sûr de mettre "C<1;>" au cas
où vous ajouteriez quelques instructions.

Si EXPR est un nom simple (bareword), require suppose l'extension "F<.pm>" et
remplace pour vous les "F<::>" par des "F</>" 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'altérer votre espace de noms.

En d'autres termes, si vous dites :

        require Foo::Bar;    # un splendide mot simple

La fonction require cherchera le fichier "F<Foo/Bar.pm>" dans les répertoires
spécifiés par le tableau C<@INC>.

Mais si vous essayez :

        $class = 'Foo::Bar';
        require $class;      # $class n'est pas un mot simple
    #ou
        require "Foo::Bar";  # n'est pas un mot simple à cause des guillemets

La fonction require cherchera le fichier "F<Foo::Bar>" dans les répertoires du
tableau C<@INC> et se plaindra qu'elle ne peut trouver le fichier
"F<Foo::Bar>". Dans ce cas, vous pouvez faire :

        eval "require $class";

Pour une fonctionnalité d'importation encore plus puissante, voir L</use> et
L<perlmod>.

=item reset EXPR

=item reset

Généralement utilisée dans un bloc C<continue> à la fin d'une boucle pour
effacer les variables et réinitialiser les recherches C<??> pour qu'elle
marche à nouveau. L'expression EXPR est interprétée comme une liste de
caractères (le moins est autorisé pour des intervalles). Toutes les variables
commençant par l'un de ces caractères sont réinitialisées à leur état
primitif. Si EXPR est omis, les motifs de recherche qui ne marchent qu'une
fois (C<?motif?>) sont réinitialisés pour fonctionner à nouveau. Ne
réinitialise que les variables et les motifs du paquetage couran
t. Retourne
toujours 1. Exemples :

    reset 'X';          # réinitialise toutes les variables X...
    reset 'a-z';        # réinitialise toutes les variables
                        # commençant par une minuscule
    reset;              # réinitialise juste les motifs ??

Réinitialiser C<"A-Z"> n'est pas recommandé parce que cela efface les tableaux
C<@ARGV> et C<@INC> ainsi que la table de hachage C<%ENV>. Ne réinitialise que
les variables de paquetage -- les variables lexicales ne sont pas modifiées
mais elles s'effacent toutes seules dès que l'on sort de leur portée
lexicale ce qui devrait vous inciter à les utiliser. Voir L</my>.

=item return EXPR

=item return

Retourne depuis une subroutine, un bloc C<eval()> ou un C<do FICHIER> avec la
valeur donnée par EXPR. L'évaluation de EXPR peut se faire dans un contexte
scalaire, de liste ou vide selon la manière dont la valeur sera utilisée et le
contexte peut varier d'une exécution à l'autre (voir C<wantarray()>). Si
aucune EXPR n'est donné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.

(Remarque: en l'absence de return, une subroutine, un bloc eval ou un do
FICHIER retournera automatiquement la valeur de la dernière expression évaluée.)

=item reverse LIST

Dans un contexte de listem retourne une liste de valeurs constituée des
éléments de LIST en ordre inverse. Dans un contexte scalaire, concatène les
éléments de LIST et retourne la chaîne ainsi constituée mais dans l'ordre inverse.

    print reverse <>;           # tac (cat à l'envers) les lignes,
                                # la dernière ligne en premier

    undef $/;                   # pour un <> efficace
    print scalar reverse <>;    # tac (cat à l'envers) les octets,
                                # la dernière ligne en reimerp

Cet opérateur est aussi utilisé pour inverser des tables de hachage bien que
cela pose quelques problèmes. Si une valeur est dupliquée dans la table
originale, seule l'une des ces valeurs sera représentée comme une clé dans la
table résultante. Cela nécessite aussi de mettre toute la table à plat avant
d'en reconstruire une nouvelle ce qui peut prendre beaucoup de temps sur une
grosse table.

    %by_name = reverse %by_address;     # Inverse la table

=item rewinddir DIRHANDLE

Ramène la position courante au début du répertoire pour le prochain
C<readdir()> sur DIRHANDLE.

=item rindex STR,SUBSTR,POSITION

=item rindex STR,SUBSTR

Fonctionne exactement comme index sauf qu'il retourne la position de la
DERNIRÈRE occurence de SUBSTR dans STR. Si POSITION est spécifiée, retourne la
dernière occurence avant ou exactement à cette position.

=item rmdir FILENAME

=item rmdir

Efface le répertoire spécifié par FILENAME si ce répertoire est vide. En cas
de succès, retourne TRUE (vrai) ou sinon, retourne FALSE (faux) et positionne
la variable C<$!> (errno). Si FILENAME est omis, utilise C<$_>.

=item s///

L'opérateur de substitution. Voir L<perlop>.

=item scalar EXPR

Contraint l'interpération de EXPR dans un contexte scalaire et retourne la
valeur de EXPR.

    @counts = ( scalar @a, scalar @b, scalar @c );

Il n'y pas d'opérateur équivalent pour contraindre l'interpération d'une
expression dans un contexte de liste pacre qu'en pratique ce n'est jamais
utile. Si vous en avez réellement besoins vous pouvez utiliser une
construction comme C<@{[ (une expression) ]}> mais un simple C<(une
expression)> suffit en général.

=item seek FILEHANDLE,POSITION,WHENCE

Modifie la position d'un FILEHANDLE exactement comme le fait l'appel
C<fseek()> de C<stdio()>. FILEHANDLE peut être une expression dont la valeur
donne le nom du filehandle. Les valeurs possibles de WHENCE sont C<0> pour
régler la nouvelle position à POSITION, C<1> pour la régler à la position
courante plus POSITION ou C<2> pour la régler à EOF plus POSITION (en général
négative). Pour WHENCE, vous pouvez utiliser les constantes C<SEEK_SET>,
C<SEEK_CUR> et C<SEEK_END> provenant du module C<IO::Seekable> ou du module
POSIX. Renvoie C<1> en cas de succès et C<0> sinon.

Si vous voulez régler la position pour un fichier dans le but d'utiliser
C<sysread()> ou C<syswrite()>, n'utilisez pas C<seek()> -- la bufferisation
rend ses effets imprévisibles et non portables. Utilisez C<sysseek()> à la
place.

Sur certains systèmes, vous devez faire un seek à chaque fois que vous
basculer entre lecture et écriture. Entre autres choses, cela a pour effet
d'appeler la fonction clearerr(3) de stdio. Un WHENCE de C<1> (C<SEEK_CUR>)
est pratique pour ne pas modifier la position dans le fichier :

    seek(TEST,0,1);

C'est très pratique pour les applications qui veulent simuler C<tail -f>. Une
fois rencontré un EOF en lecture et après avoir attendu un petit peu, vous
devez utiliser seek() pour réactiver les choses. L'appel à C<seek()> ne
modifie pas la position courante mais par contre, il efface la condition
fin-de-fichier (EOF) sur le filehandle et donc, au prochain C<E<lt>FILEE<gt>>,
Perl essayera à nouveau de lire quelque chose.

Si cela ne marche pas (certaines bibliothèques stdio sont particulièrement
hargneuses) alors vous devrez faire quelque chose comme :

    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);
    }

=item seekdir DIRHANDLE,POS

Règle la position courante pour la routine C<readdir()> sur un DIRHANDLE. POS
doit être une valeur retournée par C<telldir()>. Possède les même limitations
que l'appel système correspondant.

=item select FILEHANDLE

=item select

Retourne le filehandle courant. Sélectionne le filehandle FILEHANDLE comme
sortie par défaut si FILEHANDLE est fourni. Ceci a deux effets : tout d'abord,
un C<write()> ou un C<print()> sans filehandle spécifié iront par défaut sur
ce FILEHANDLE. Ensuite, toutes références à des variables relatives aux sorties
se référeront à ce canal de sortie. Par exemple, si vous devez spécifier un
en-tête de format pour plusieurs canaux de sortie, vous devez faire la chose
suivante :

    select(REPORT1);
    $^ = 'report1_top';
    select(REPORT2);
    $^ = 'report2_top';

FILEHANDLE peut être une expression dont le résultat donne le nom du
filehandle. Donc :

    $oldfh = select(STDERR); $| = 1; select($oldfh);

Certains programmeurs préfèrent considérer les filehandle comme des objets
avec des méthodes. Ils écriraient donc l'exemple précédent de la manière
suivante :

    use IO::Handle;
    STDERR->autoflush(1);

=item select RBITS,WBITS,EBITS,TIMEOUT

Ceci utilise directement l'appel système select(2) avec les masques de bit
spécifiés qui peuvent être construits en utilisant C<fileno()> et C<vec()>
comme dans les lignes suivantes :

    $rin = $win = $ein = '';
    vec($rin,fileno(STDIN),1) = 1;
    vec($win,fileno(STDOUT),1) = 1;
    $ein = $rin | $win;

Si vous voulez surveiller de nombreux filehandle, vous aurez peut-être à écrire
une subroutine :

    sub fhbits {
        my(@fhlist) = split(' ',$_[0]);
        my($bits);
        for (@fhlist) {
            vec($bits,fileno($_),1) = 1;
        }
        $bits;
    }
    $rin = fhbits('STDIN TTY SOCK');

L'appel classique est :

    ($nfound,$timeleft) =
      select($rout=$rin, $wout=$win, $eout=$ein, $timeout);

ou pour attendre que quelque chose soit prêt :

    $nfound = select($rout=$rin, $wout=$win, $eout=$ein, undef);

De nombreux systèmes ne prennent pas la peine de retourner quelque chose
d'utile dans C<$timeleft> (le temps restant). En conséquence, un appel à
select() dans un contexte scalaire retourne juste C<$nfound>.

undef est une valeur acceptable pour les masques de bits. Le timeout, si il
est spécifiée, est donné en secondes et peut être fractionnaire. Note:
certaines implémentations ne sont pas capables de retourner C<$timeleft>. Dans
ce cas, elles retournent toujours un C<$timeleft> égal au C<$timeout> fourni.

Vous pouvez spécifier une attente de 250 millisecondes de la manière suivante :

    select(undef, undef, undef, 0.25);

B<ATTENTION>: il ne faut pas mélanger des E/S bufferisées (comme C<read()> ou
E<lt>FHE<gt>) avec C<select()> excepté lorsque la norme POSIX le permet et,
dans ce cas, uniquement sur les systèmes POSIX. Vous devez utiliser
C<sysread()> à la place.

=item semctl ID,SEMNUM,CMD,ARG

Appelle la fonction C<semctl()> des IPC System V. Vous aurez sans doute besoin
de :

    use IPC::SysV;

au préalable pour avoir les définitions correctes des constantes. Si CMD est
IPC_STAT ou GETALL alors ARG doit être une variable capable de contenir la
structure semid_ds retournée ou le tableau des valeurs des sémaphores. Les
valeurs retournées