POD2-FR

 view release on metacpan or  search on metacpan

FR/perlfunc.pod  view on Meta::CPAN

=item Fonctions de descripteurs de fichiers, de fichiers ou de répertoires
X<fichier> X<filehandle> X<descripteur de fichier> X<répertoire> X<tube> X<lien> X<lien symbolique>

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<sysopen>, C<umask>, C<unlink>,
C<utime>

=item Mots-clés liés au contrôle d'exécution de votre programme Perl
X<contrôle d'exécution>

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-clés liés à la portée

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

=item Fonctions diverses

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

=item Fonctions de gestion des processus et des groupes de processus
X<processus> X<pid> X<id de processus>

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

=item Mots-clés liés aux modules perl
X<module>

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

=item Mots-clés liés aux classes et à la programmation orientée objet
X<objet> X<classe> X<package> X<paquetage>

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

=item Fonctions de bas niveau liées aux sockets
X<socket>

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
X<IPC> X<System V> X<sémaphore> X<mémoire partagée> X<mémoire> X<message> X<communication inter-processus>

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
X<utilisateur> X<groupe> X<mot de passe> X<uid> X<gid> X<passwd> X</etc/passwd>

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
X<réseau> X<protocole> X<hôte> X<host> X<hostname> X<nom d'hôte> X<IP> X<adresse> X<service>

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
X<temps> X<date> X<heure>

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

=item Nouvelles fonctions de perl5
X<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<our>, 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-clé 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 Portabilité X<portabilité> X<Unix> X<portable>

Perl est né sur Unix et peut, par conséquent, accéder à tous les appels
systèmes Unix courants. Dans des environnements non-Unix, les fonctionnalités
de certains appels systèmes Unix peuvent manquer ou différer sur certains
détails. Les fonctions Perl affectées par cela S<sont :>

C<-X>, C<binmode>, C<chmod>, C<chown>, C<chroot>, C<crypt>,
C<dbmclose>, C<dbmopen>, C<dump>, C<endgrent>, C<endhostent>,
C<endnetent>, C<endprotoent>, C<endpwent>, C<endservent>, C<exec>,
C<fcntl>, C<flock>, C<fork>, C<getgrent>, C<getgrgid>, C<gethostbyname>,
C<gethostent>, C<getlogin>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getppid>, C<getpgrp>, C<getpriority>, C<getprotobynumber>,
C<getprotoent>, C<getpwent>, C<getpwnam>, C<getpwuid>,
C<getservbyport>, C<getservent>, C<getsockopt>, C<glob>, C<ioctl>,
C<kill>, C<link>, C<lstat>, C<msgctl>, C<msgget>, C<msgrcv>,
C<msgsnd>, C<open>, C<pipe>, C<readlink>, C<rename>, C<select>, C<semctl>,
C<semget>, C<semop>, C<setgrent>, C<sethostent>, C<setnetent>,
C<setpgrp>, C<setpriority>, C<setprotoent>, C<setpwent>,
C<setservent>, C<setsockopt>, C<shmctl>, C<shmget>, C<shmread>,
C<shmwrite>, C<socket>, C<socketpair>, C<stat>, C<symlink>, C<syscall>,
C<sysopen>, C<system>, C<times>, C<truncate>, C<umask>, C<unlink>,
C<utime>, C<wait>, C<waitpid>

Pour de plus amples détails sur la portabilité de ces fonctions, voir
L<perlport> et toutes les documentations disponibles spécifiques à la
plate-forme considérée.

=head2 Fonctions Perl par ordre alphabétique

=over 8

=item -X DESCRIPTEUR
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>

=item -X EXPR

=item -X

Un test de fichier où X est une des lettres présentées ci-dessous. Cet
opérateur unaire prend soit un argument, soit un nom de fichier, soit 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
C<-t> qui teste STDIN. Sauf indication contraire, il retourne C<1> pour VRAI
et C<''> pour FAUX, ou la valeur indéfinie (undef) si le fichier n'existe
pas. Malgré leurs noms originaux, leur priorité est la même que celle de tout
autre opérateur unaire nommé et l'argument peut-être mis de même entre
parenthèses. L'opérateur peut S<être :>

    -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 (il est vide).
    -s  Le fichier n'a pas une taille nulle (retourne sa taille en octets).

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

    -u  Le fichier a le bit setuid positionné.
    -g  Le fichier a le bit setgid positionné.

FR/perlfunc.pod  view on Meta::CPAN

Pour la fonction réciproque (arc cosinus), vous pouvez utiliser la
fonction C<Math:;Trig::acos()> ou alors utiliser cette S<relation :>

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

=item crypt TEXTE,SEL
X<crypt> X<empeinte> X<digest> X<hachage> X<sel> X<mot de passe> X<decrypt> X<cryptographie> X<passwd>

Crée une empreinte exactement comme le fait la fonction crypt(3) de la
bibliothèque C (en supposant que vous n'en avez pas une version
dégradée car considéré comme arme potentielle).

C<crypt()> est une fonction non réversible (à sens unique). Le TEXTE
et le SEL sont transformés en une courte chaîne de caractères, appelée
empreinte, qui est alors retournée. Un même couple TEXTE, SEL donne
toujours la même empreinte mais on ne connait aucun moyen de retrouver
le TEXTE à partir de l'empreinte. Un petit changement dans TEXTE ou
SEL donne un résultat complètement différent pour l'empreinte.

Il n'existe pas de fonction decrypt. La fonction crypt() n'est donc
pas utilisable pour chiffrer des documents (pour cela, chercher les
modules F<crypt> sur CPAN) et donc le nom "crypt" n'est pas vraiment
bien choisi. En fait, elle sert plutôt à vérifier que deux textes sont
identiques sans nécessiter l'envoi ou le stockage du texte
lui-même. On peut par exemple vérifier un mot de passe. Seule
l'empreinte du mot de passe est stockée. L'utilisateur tape son mot de
passe et crypt() calcule son empreinte avec le même SEL qui celui
utilisé pour stocker le mot de passe. Si les deux empreintes (celle
stockée et celle calculée) corresponde alors le mot de passe est
correct.

Pour vérifier une empreinte, vous devriez utilisez cette empreinte
comme SEL (par exemple C<crypt($motdepasse, $empreinte) eq
$empreinte>). Le SEL utilisé pour créer l'empreinte apparaît en clair
dans l'empreinte. Cela permet de garantir que crypt() hachera le
nouveau TEXT avec le même SEL que celui de l'empreinte. Cela vous
garantie aussi que votre code fonctionnera avec une version standard
de L<crypt|/crypt> mais aussi avec des implémentations plus
exotiques. En d'autres termes, ne faites aucune supposition sur la
forme de l'empreinte produite ou sur sa taille.

Traditionnellement, le résultat est une chaîne de 13 S<octets :> les
deux premiers octets du SEL, suivis de 11 octets pris dans l'ensemble
C<[./0-9A-Za-z]> et seuls les huit premiers octets de la chaîne à
encrypter sont pris en compte. Mais des méthodes de hachages
alternatives (comme MD5) ou d'un niveau de sécurité plus élevé (comme
C2) ou encore des implémentations sur des plateformes non-UNIX peuvent
produire d'autres types de chaînes.

Lorsque vous choisissez un nouveau SEL constitué de deux caractères
aléatoires, ces caractères doivent provenir de l'ensemble
C<[./0-9A-Za-z]> (Exemple C<join '', ('.', '/', 0..9, 'A'..'Z',
'a'..'z')[rand 64, rand 64]>).  Cet ensemble de caractères n'est
qu'une recommandation car les caractères réellement acceptables dans
SEL dépendent de le fonction crypt de votre bibliothèque système et
Perl ne peut pas connaître les restrictions exactes.

Voici un exemple qui garantit 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é.

La fonction L<crypt|/crypt> n'est pas utilisable pour chiffrer de
grande quantité d'information déjà parce que vous ne pouvez pas
retrouver l'information initiale. Regarder le module L<Digest> pour
des algorithmes plus robustes.

Si vous utilisez crypt() sur une chaîne Unicode (qui contient
I<éventuellement> des caractères dont l'encodage est supérieur à 255), Perl
essaie de se sortir de cette situation en dégradant une copie de la chaîne
vers un encodage sur 8 bits avant d'appeler crypt() sur cette copie. Si cela
fonctionne, tout est bon. Sinon, crypt() meurt (die) avec les message C<Wide
character in crypt>.

=item dbmclose HASH
X<dbmclose>

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

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

=item dbmopen HASH,DBNOM,MODE
X<dbmopen> X<dbm> X<ndbm> X<sdbm> X<gdbm>

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

Cette fonction lie un fichier dbm(3), ndbm(3), sdbm(3), gdbm(3), ou Berkeley
DB à une table de hachage. HASH est le nom de la table de hachage. (À 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éée avec les droits spécifiés par MODE (et
modifiés par C<umask>). Si votre système supporte uniquement les anciennes
fonctions DBM, vous ne pouvez exécuter qu'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
utilise maintenant sdbm(3).

Si vous n'avez pas les droits d'é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 un test sur
le fichier ou essayez d'écrire une entrée bidon dans la table de hachage, à
l'intérieur d'un C<eval()>, qui interceptera l'erreur.

FR/perlfunc.pod  view on Meta::CPAN

que vous puissiez aussi l'appeler. Elle formate (voir L<perlform>) une
liste de valeurs selon le contenu de IMAGE, plaçant la sortie dans
l'accumulateur du format de sortie C<$^A> (ou C<$ACCUMULATOR> en
anglais). Finalement, lorsqu'un C<write()> est effectué, le contenu de
C<$^A> est écrit dans un descripteur de fichier. Vous pouvez aussi
lire C<$^A> et réassigner C<""> à C<$^A>. Notez qu'un format typique
appelle C<formline> une fois par ligne du formulaire mais la fonction
C<formline> elle-même ne se préoccupe pas du nombre de passage à la
ligne inclus dans l'IMAGE. Ceci signifie que C<~> et C<~~> traiteront
l'IMAGE complète comme une seule ligne. Vous pouvez donc utiliser de
multiples formline pour implémenter un seul format d'enregistrement,
tout comme le compilateur de format.

Faites attention si vous utilisez des guillemets 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
X<getc> X<getchar>

=item getc

Retourne le prochain caractère du fichier d'entrée attaché au
DESCRIPTEUR ou la valeur indéfinie (undef) à la fin du fichier ou en
cas d'erreur (en fixant C<$!> dans ce dernier cas). Si le DESCRIPTEUR
est omis, utilise STDIN. Ce n'est pas particulièrement efficace. De
plus, ce n'est pas utilisable tel quel pour obtenir des caractères un
à un sans que l'utilisateur presse ENTER. 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 la valeur de $BSD_STYLE 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 dans
L<perlmodlib/CPAN>.

=item getlogin
X<getlogin> X<login>

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'authentificationE<nbsp>: ce n'est pas aussi
sûr que C<getpwuid()>.

=item getpeername SOCKET
X<getpeername> X<peer> X<pair>

Renvoie l'adresse sockaddr compactée (voir pack()) de l'autre extrémité 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
X<getpgrp> X<groupe>

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
X<getppid> X<parent> X<pid>

Renvoie l'id du processus parent.

Note pour les utilisateurs S<Linux :> sur Linux, les fonctions C
C<getppid()> et C<getpid()> retournent des valeurs différentes selon
les fils d'exécution (les différents threads). Pour être portable, ce
comportement n'est pas celui de la fonction perl C<getppid()> qui
retourne un valeur identique pour tous les fils (threads) d'un même
processus. Pour appeler la vraie fonction C<getppid()>, vous pouvez
utiliser le module CPAN C<Linux::Pid>.

=item getpriority WHICH,WHO
X<getpriority> X<priorité> X<nice>

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
X<getpwnam> X<getgrnam> X<gethostbyname> X<getnetbyname> X<getprotobyname> X<getpwuid> X<getgrgid> X<getservbyname> X<gethostbyaddr> X<getnetbyaddr> X<getprotobynumber> X<getservbyport> X<getpwent> X<getgrent> X<gethostent> X<getnetent> X<getprotoent...

=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 suivantesE<nbsp>:

    ($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.)

La signification exacte du champ $gcos varie mais contient habituellement le
nom réel de l'utilisateur (au contraire du nom de login) et d'autres
informations pertinentes pour cet utilisateur. Par contre, sachez que sur de
nombreux systèmes, les utilisateurs peuvent changer eux-mêmes ces
informations. Ce n'est donc pas une information de confiance. Par conséquent
$gcos est souillée (voir L<perlsec>). Les champs $passwd, $shell ainsi que
l'interpréteur de commandes (login shell) et le mot de passe crypté sont aussi
souillés pour les mêmes raisons.

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

    $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
«E<nbsp>administratifE<nbsp>» 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 vieillissement 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
exact 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>. Les fichiers de mots
de passe cachés (shadow password) ne sont supportés que si
l'implémentation de votre système est faite telle que les appels aux
fonctions normales de la bibliothèque C accèdent à ces fichiers
lorsque vos privilèges vous y autorisent ou lorsque les fonctions
shadow(3) existent comme sous System V (ce qui est le cas de Solaris
et de Linux). Toute autre implémentation de ces fonctionnalités via
des appels à une bibliothèque spécifique n'est pas supportée.

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écompacter en disant quelque
chose comme :

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

Si vous êtes fatigué de devoir vous souvenir que tel élément de la
liste retournée correspond à telle 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 exempleE<nbsp>:

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

Bien que les deux appels se ressemblent (appel à la méthode 'uid'), ce
n'est pas la même chose car l'objet C<File::stat> est différent de
l'objet C<User::pwent>.