view release on metacpan or  search on metacpan

FR/perlfunc.pod  view on Meta::CPAN

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 parfois
surprenante) règle est la S<suivante :> ça I<RESSEMBLE> à une
fonction, donc c'I<EST> une fonction, et la priorité importe
peu. Sinon, c'est un opérateur de liste ou un opérateur unaire et la
priorité a son importance. Les espaces entre la fonction et les
parenthèses ne comptent pas, vous devez donc faire parfois très
S<attention :>

    print 1+2+4;        # affiche 7.
    print(1+2) + 4;     # affiche 3.
    print (1+2)+4;      # affiche aussi 3 !
    print +(1+2)+4;     # affiche 7.
    print ((1+2)+4);    # affiche 7.

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.

Quelques rares fonctions ne prennent aucun argument et ne sont donc ni
des opérateurs unaires ni des opérateurs de liste. Cela inclut des
fonctions telles que C<time> et C<endpwent>. Par exemple,
C<time+86_400> signifie toujours C<time() + 86_400>.

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 choisit le type de
valeur qui semble le 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
retournent la première valeur. D'autres encore retournent la dernière
valeur. D'autres enfin retournent le nombre d'opérations réussies. En
général, ils font ce que vous souhaitez, à moins que vous ne vouliez
de la cohérence.
X<contexte>

Un tableau nommé en contexte scalaire est assez différent de ce qui
apparaîtrait 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
construction de liste de la virgule. Ce qui signifie que ça n'a jamais été
considéré comme une liste avec laquelle travailler.

En général, les fonctions en Perl qui encapsulent 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<wait>, C<waitpid()> et
C<syscall()>. Les appels système positionnent 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 X<fonction>

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

=over 4

=item Fonctions liées aux scalaires ou aux chaînes de caractères
X<scalaire> X<chaîne> X<caractère>

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/CHAINE/>, C<qq/CHAINE/>, C<reverse>,
C<rindex>, C<sprintf>, C<substr>, C<tr///>, C<uc>, C<ucfirst>, C<y///>

=item Expressions rationnelles et reconnaissances de motifs
X<expression rationnelle> X<expression régulière> X<ratexp> X<regexp>

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

=item Fonctions numériques
X<numérique> X<nombre> X<trigonométrie>

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 liées aux véritables @tableaux
X<tableau>

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

=item Fonctions aux listes de données
X<liste>

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

=item Fonctions liées aux véritables %tables de hachage
X<table de hachage> X<tableau associatif>

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

=item Fonctions d'entrée/sortie
X<E/S> X<entrée> X<sortie> X<dbm>

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
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.

FR/perlfunc.pod  view on Meta::CPAN

C<$_>. S<Exemple :>

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

Vous pouvez en fait tronquer tout ce qui est une lvalue, y compris 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é.

Si la directive C<encoding> est active alors les longueurs retournées
sont calculées en fonction de la longueur de C<$/> exprimée en nombre
de caractères Unicode, qui n'est pas toujours la même si elle est
exprimée en fonction de l'encodage natif.

Notez que les parenthèses sont nécessaires lorsque vous voulez "chomp"-er
quelque chose qui n'est pas une simple variable. C'est parce que C<chomp $cwd
= `pwd`;> est interprété comme C<(chomp $cwd) = `pwd`;> plutôt que comme
C<chomp( $cwd = `pwd` );>. De même dans le cas de C<chomp $a, $b> qui est
interprété comme C<chomp($a), $b> plutôt que comme C<chomp($a, $b)>.

=item chop VARIABLE
X<chop>

=item chop( LISTE )

=item chop

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

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

Vous pouvez en fait tronquer tout ce qui est une lvalue, y compris 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)>.

Voir aussi L</chomp>.

=item chown LISTE
X<chown> X<propriétaire> X<utilisateur> X<groupe>

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<numériques>. Une valeur -1 à l'une de ces positions est
interprétée par la plupart des systèmes comme une valeur à ne pas
modifier. Retourne le nombre de fichiers modifiés avec succès.

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

Sur les systèmes qui connaissent fchown, vous pouvez utiliser des
descripteurs de fichier à la place des noms de fichier. Sur les
systèmes ne connaissant pas fchown, cela produira une erreur fatal
lors de l'exécution.

Voici un exemple qui cherche les uid non numériques dans le 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);      # expansion des noms de fichiers
    chown $uid, $gid, @ary;

Sur la plupart des systèmes, vous n'êtes pas autorisé à changer le
propriétaire d'un fichier à moins d'être le super-utilisateur, même si avez la
possibilité de changer un groupe en l'un de vos groupes secondaires. Sur les
systèmes non sécurisés, ces restrictions peuvent être moindres, mais ceci
n'est pas une hypothèse portable. Sur les systèmes POSIX, vous pouvez détecter
cette condition de la manière S<suivante :>

    use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
    $can_chown_giveaway = not sysconf(_PC_CHOWN_RESTRICTED);

=item chr NOMBRE
X<chr> X<caractère> X<ASCII> X<Unicode>

=item chr

Retourne le caractère représenté par ce NOMBRE dans le jeu de
caractères. Par exemple, C<chr(65)> est C<"A"> en ASCII ou Unicode et
chr(0x263a) est un visage réjoui en Unicode. Notez que les caractères
de 128 à 255 (inclu) ne sont pas par défaut encodés en UTF-8 Unicode
pour des raisons de compatibilités (mais voir L<encoding>).

Si NOMBRE est omis, s'applique à C<$_>.

Pour la fonction réciproque, utilisez L</ord>.

Notez que si la directive C<bytes> est active, NOMBRE est masqué pour ne
conserver que les 8 bits de poids faible.

Voir L<perlunicode> et L<encoding> pour en savoir plus sur Unicode.

=item chroot FICHIER
X<chroot> X<root>

=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
X<close>

=item close

Ferme le fichier ou le tube associé au descripteur de fichier, en retournant
VRAI si et seulement si les tampons d'entrée/sortie ont été correctement vidés
et si le descripteur a été correctement fermé. 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. (voir C<open()>.)
Toutefois, un C<close()> explicite sur un fichier d'entrée réinitialise le
compteur de lignes (C<$.>) alors que la fermeture implicite par un C<open()> ne
le fait pas.

Si le descripteur vient d'un tube ouvert, C<close()> va de plus retourner FAUX
si un des autres appels système impliqués échoue ou si le programme se
termine avec un statut non nul. (Si le seul problème rencontré est une
terminaison 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, et positionne
implicitement la valeur du statut de sortie de la commande dans C<$?>.

La fermeture prématurée d'une extrémité de lecture d'un tube (c'est-à-dire
avant que le processus qui écrit à l'autre extrémité l'ait fermé) aura pour
conséquence l'envoi d'un signal SIGPIPE au processus écrivain. Si l'autre