=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 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.) 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 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 ça I à une fonction, donc c'I 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 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 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 il n'y a B 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 sinon, comme c'est souvent mentionné ci-dessous. C'est différent des S qui retournent C<-1> en cas d'erreur. Les exceptions à cette règle sont C et C. 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, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C =item Expression régulières et reconnaissance de motifs C, C, C, C, C, C, C =item Fonctions numériques C, C, C, C, C, C, C, C, C, C, C, C =item Fonctions de véritables @TABLEAUx C, C, C, C, C =item Fonctions de listes de données C, C, C, C, C, C, C =item Fonctions de véritables %TABLEs DE HACHAGE C, C, C, C, C =item Fonctions d'entrée/sortie C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C). 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 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. Si C 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. Ne tomber pas de le piège d'utiliser C alors qu'un simple C suffirait. C est plus efficace et moins sujet à erreur. =item prototype FUNCTION Retourne, sous forme de chaîne, le prototype d'une fonction (ou C 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, 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 (par exemple C) ou si ses arguments ne peuvent s'exprimer sous forme de prototype (par exemple C) - en d'autres termes, si la fonction interne ne se comporte pas comme une fonction Perl - la fonction prototype retournera C. 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. =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 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 sauf cela a déjà été fait. Voir aussi C. (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. =item readdir DIRHANDLE Retourne l'entrée de répertoire suivante d'un répertoire ouvert par C. 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, n'oubliez pas de les préfixer par le répertoire en question. Sinon, puisqu'aucun appel à C 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 CEXPRE> mais vous pouvez l'utiliser directement. L'opérateur CEXPRE> est décrit en détail dans L. $line = ; $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 mais vous pouvez l'utiliser directement. L'opérateur C est d'ecrit plus en détail dans L. =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 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 pour des exemples. =item redo LABEL =item redo La commande C redémarre une boucle sans évaluer à nouveau la condition. Le bloc C, 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 () { while (s|({.*}.*){.*}|$1 |) {} s|{.*}| |; if (s|{.*| |) { $front = $_; while () { if (/}/) { # end of comment? s|^|$front\{|; redo LINE; } } } print; } Voir aussi L pour illustrer la manière dont C, C et C 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 comme une sorte d'opérateur C (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. =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. 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" 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" dans les répertoires du tableau C<@INC> et se plaindra qu'elle ne peut trouver le fichier "F". Dans ce cas, vous pouvez faire : eval "require $class"; Pour une fonctionnalité d'importation encore plus puissante, voir L et L. =item reset EXPR =item reset Généralement utilisée dans un bloc C à 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) 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. =item return EXPR =item return Retourne depuis une subroutine, un bloc C ou un C 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). 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 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. =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 de C. 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, C et C provenant du module C 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 ou C, n'utilisez pas C -- la bufferisation rend ses effets imprévisibles et non portables. Utilisez C à 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) 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. 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 ne modifie pas la position courante mais par contre, il efface la condition fin-de-fichier (EOF) sur le filehandle et donc, au prochain CFILEE>, 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); $_ = ; $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 sur un DIRHANDLE. POS doit être une valeur retournée par C. 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 ou un C 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 et C 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: il ne faut pas mélanger des E/S bufferisées (comme C ou EFHE) avec C excepté lorsque la norme POSIX le permet et, dans ce cas, uniquement sur les systèmes POSIX. Vous devez utiliser C à la place. =item semctl ID,SEMNUM,CMD,ARG Appelle la fonction C 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 sont comme celles de C : la valeur undef en cas d'erreur, la chaîne "C<0> but true" pour rien ou la vraie valeur retournée dans les autres cas. Voir aussi la documentation de C et de C. =item semget KEY,NSEMS,FLAGS Appelle la fonction C des IPC System V. Renvoie l'id du sémaphore ou la valeur undef en cas d'erreur. Voir aussi la documentation de C et de C. =item semop KEY,OPSTRING Appelle la fonction C des IPC System V pour réaliser certaines opérations sur les sémaphores comme l'attente ou la signalisation. OPSTRING doit être un tableau empaqueté (par pack()) de structures semop. Chaque structure semop peut être générée par C. Le nombre total d'opérations sur les sémaphores est déduit de la taille de OPSTRING. Renvoie TRUE en cas de succès ou FALSE en cas d'erreur. Par exemple, le code suivant attend sur le sémaphore C<$semnum> de l'ensemble de sémaphores d'id C<$semid> : $semop = pack("sss", $semnum, -1, 0); die "Semaphore trouble: $!\n" unless semop($semid, $semop); Pour envoyer un signal au sémaphore, remplacez le C<-1> par C<1>. Voir aussi la documentation de C et de C. =item send SOCKET,MSG,FLAGS,TO =item send SOCKET,MSG,FLAGS Envoie un message sur un socket. Utilise les mêmes flags que l'appel système du même nom. Pour des sockets non-connectés vous devez spécifier dans le paramètre TO une destination pour l'envoi. Dans ce cas c'est la fonction C C qui est utilisée. Retourne le nombre de caractères envoyés ou la valeur undef si il y a une erreur. Voir les exemples dans L. =item setpgrp PID,PGRP Modifie le groupe de process courant pour le PID spécifié (C<0> pour le process courant). Cela produira une erreur fatale si vous l'utilisez sur un système qui n'implémente pas setpgrp(2). Si les arguments sont omis, ils prennent comme valeur par défaut C<0,0>. Remarquez aussi que la version POSIX de C n'accepte aucun argument. Donc seul setpgrp C<0,0> est portable. =item setpriority WHICH,WHO,PRIORITY Modifie la priorité courante d'un process, d'un groupe de process ou d'un utilisateur. (Voir setpriority(2).) Cela produira une erreur fatale si vous l'utilisez sur un système qui n'implémente pas setpriority(2). =item setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL Modifie l'option spécifiée d'un socket. Retourne undef en cas d'erreur. OPTVAL peut être C si vous ne voulez pas passer d'argument. =item shift ARRAY =item shift Retourne la première valeur d'un tableau après l'avoir supprimer du tableau en rétrécissant sa taille de 1 et en déplaçant tout vers le bas. Renvoie undef si il n'y a pas d'éléments dans le tableau. Si ARRAY est omis, shift agira soit sur le tableau C<@_> si il est dans la portée lexicale d'une subroutine ou d'un format, soit sur le tableau C<@ARGV> si il est dans la portée lexicale d'un fichier ou si il est dans une portée lexicale établie par l'une des constructions C, C, C ou C. C et C agissent sur le côté gauche d'un tableau exactement comme C et C le font sur le côté droit. =item shmctl ID,CMD,ARG Appelle la fonction shmctl de 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 C alors ARG doit être une variable capable de contenir la structure C retournée. Les valeurs retournées sont comme celles de C : la valeur undef en cas d'erreur, la chaîne "C<0> but true" pour rien ou la vraie valeur retournée dans les autres cas. Voir aussi la documentation de C. =item shmget KEY,SIZE,FLAGS Appelle la fonction shmget de IPC System V. Renvoie l'id du segment de mémoire partagée ou undef en cas d'erreur. Voir aussi la documentation de C. =item shmread ID,VAR,POS,SIZE =item shmwrite ID,STRING,POS,SIZE Lit ou écrit le segment de mémoire partagée System V d'id ID en commençant à la position POS et sur une taille de SIZE en s'attachant à lui puis en le lisant ou en l'écrivant puis enfin en s'en détachant. Lors d'une lecture, VAR doit être une variable qui contiendra les données lues. Lors d'une écriture, si STRING est trop long seuls SIZE octets seront utilisés, si STRING est trop court des caractères NUL seront ajoutés pour compléter jusqu'à SIZE octets. Retourne TRUE en cas de succès et FALSE en cas d'erreur. Voir aussi la documentation de C. =item shutdown SOCKET,HOW Ferme une connexion socket de la manière indiquée par HOW qui est interprété comme le fait l'appel système du même nom. shutdown(SOCKET, 0); # J'ai arrêté d'écrire des données shutdown(SOCKET, 1); # J'ai arrêté de lire des données shutdown(SOCKET, 2); # J'ai arrêté d'utiliser ce socket C'est pratique pour des sockets pour lesquels vous voulez indiquer à l'autre extrémité que vous avez fini d'écrire mais pas de lire ou vice versa. C'est aussi une forme plus insistante de close puisque qu'elle désactive aussi le filedescriptor pour tous les process dupliqués par fork. =item sin EXPR =item sin Retourne le sinus de EXPR (exprimé en radians). Si EXPR est omis, retourne le sinus de C<$_>. Pour calculer la fonction inverse du sinus, vous pouvez utiliser la fonction C ou utiliser cette relation : sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) } =item sleep EXPR =item sleep Demande au script de s'endormir pendant EXPR secondes ou pour toujours si EXPR est omis. Peut être interrompu si le process reçoit un signal comme C. Renvoie le durée réelle du sommeil en secondes. Vous ne pourrez probablement pas mélanger des appels C et C car C est souvent implémenté en utilisant C. Sur quelques vieux systèmes, il se peut que la durée du sommeil soit d'une seconde de moins que celle que vous avez demandée en fonction de la manière dont il compte les secondes. Les systèmes plus modernes s'endorment toujours pendant la bonne durée. En revanche, il peut arriver que votre sommeil dure plus longtemps que prévu sur un système multi-tâches très chargé. Pour des délais d'une granularité inférieure à la seconde, vous pouvez utiliser l'interface Perl C pour accéder à setitimer(2) si votre système le supporte ou sinon regarder L plus haut. Regarder aussi la fonction C du module POSIX. =item socket SOCKET,DOMAIN,TYPE,PROTOCOL Ouvre un socket du type spécifié et l'attache au filehandle SOCKET. DOMAIN, TYPE et PROTOCOL sont spécifiés comme pour l'appel système du même nom. Vous devriez mettre "C" au préalable pour importer les définitions correctes. Voir les exemple dans L. =item socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL Crée une paire de sockets sans nom dans le domaine spécifié et du type spécifié. DOMAIN, TYPE et PROTOCOL sont spécifiés comme pour l'appel système du même nom. Si l'appel système n'est pas implémenté, cela produit une erreur fatale. Retourne TRUE en cas de succès. Certains systèmes définissent C en terme de C, auquel cas un appel à C est quasiment équivalent à : use Socket; socketpair(Rdr, Wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC); shutdown(Rdr, 1); # no more writing for reader shutdown(Wtr, 0); # no more reading for writer Voir L pour des exemples d'utilisation de socketpair. =item sort SUBNAME LIST =item sort BLOCK LIST =item sort LIST Trie LIST et retourne la liste de valeurs triée. Si SUBNAME et BLOCK sont omis, le tri est effectué dans l'ordre standard de comparaison de chaînes. Si SUBNAME est spécifié, il donne le nom d'une subroutine qui retourne un entier plus petit, égale ou plus grand que C<0> selon l'ordre dans lequel les éléments du tableau doivent être triés. (Les opérateurs C=E> et C sont extrêmement utiles dans de telles subroutines.) SUBNAME peut être une variable scalaire auquel cas sa valeur donne le nom (ou la référence) de la subroutine à utiliser. À la place de SUBNAME, vous pouvez fournir un BLOCK comme subroutine de tri anonyme et en-ligne. Dans un souci d'efficacité le code normal d'appel de subroutines n'est pas utilisé ce qui a les effets suivants : la subroutine ne peut pas être récursive et les deux éléments à comparer ne sont pas passés via C<@_> mais par les variables globales du package C<$a> et C<$b> (voir exemples ci-dessous). Les valeurs sont passées par référence donc ne modifiez ni C<$a> ni C<$b>. Et n'essayez pas non plus de les déclarer comme lexicales. Vous ne pouvez pas non plus sortir du bloc sort ou de la subroutine en utilisant les opérateurs de contrôle de boucles décrits dans L ou avec un C. Lorsque C est actif, C trie LIST selon l'ordre (collation) du locale courant. Voir L. Exemples : # tri alphabétique @articles = sort @files; # idem mais avec une routine de tri explicite @articles = sort {$a cmp $b} @files; # idem mais indépendant de la casse @articles = sort {uc($a) cmp uc($b)} @files; # idem mais dans l'ordre inverse @articles = sort {$b cmp $a} @files; # tri numérique ascendant @articles = sort {$a <=> $b} @files; # tri numérique descendant @articles = sort {$b <=> $a} @files; # tri utilisant le nom explicite d'une subroutine sub byage { $age{$a} <=> $age{$b}; # supposé numérique } @sortedclass = sort byage @class; # tri des clés de la table de hachage %age # par valeur de la table en utilisant # une subroutine en-ligne @eldest = sort { $age{$b} <=> $age{$a} } keys %age; sub backwards { $b cmp $a; } @harry = ('dog','cat','x','Cain','Abel'); @george = ('gone','chased','yz','Punished','Axed'); print sort @harry; # affiche AbelCaincatdogx print sort backwards @harry; # affiche xdogcatCainAbel print sort @george, 'to', @harry; # affiche AbelAxedCainPunishedcatchaseddoggonetoxyz # tri inefficace par ordre numérique descendant utilisant # le premier entier après le signe = ou l'ensemble de # l'enregistrement si cet entier n'existe pas @new = sort { ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0] || uc($a) cmp uc($b) } @old; # la même chose mais plus efficace; # nous construisons un tableau auxilliaire d'indices # pour aller plus vite @nums = @caps = (); for (@old) { push @nums, /=(\d+)/; push @caps, uc($_); } @new = @old[ sort { $nums[$b] <=> $nums[$a] || $caps[$a] cmp $caps[$b] } 0..$#old ]; # même chose en utilisant une transformation Schwartzian (pas de temporaire) @new = map { $_->[0] } sort { $b->[1] <=> $a->[1] || $a->[2] cmp $b->[2] } map { [$_, /=(\d+)/, uc($_)] } @old; Si vous utilisez strict, vous I déclarer C<$a> et C<$b> comme variables lexicales. Ce sont des variables globales au package. Cela signifie que si vous êtes dans le package C
, c'est : @articles = sort {$main::b <=> $main::a} @files; ou juste : @articles = sort {$::b <=> $::a} @files; mais si vous êtes dans le package C, c'est : @articles = sort {$FooPack::b <=> $FooPack::a} @files; La fonction de comparaison doit se comporter correctement. Si elle retourne des résultats incohérents (parfois elle dit que C<$x[1]> est plus petit que C<$x[2]> et d'autres fois le contraire par exemple), le résultat du tri n'est pas bien défini. =item splice ARRAY,OFFSET,LENGTH,LIST =item splice ARRAY,OFFSET,LENGTH =item splice ARRAY,OFFSET Supprime d'un tableau les éléments consécutifs désignés par OFFSET (indice du premier élément) et LENGTH (nombre d'éléments concernés) et les remplace par les éléments de LIST si il y en a. Dans un contexte de liste, renvoie les éléments supprimés du tableau. Dans un contexte scalaire, renvoie le dernier élément supprimé ou C si aucun élément n'est supprimé. Le tableau grossit ou diminue si nécessaire. Si OFFSET est négatif, il est compté à partir de la fin du tableau. Si LENGTH est omis, supprime tout à partir de OFFSET. Si LENGTH est négatif, laisse ce nombre d'éléments à la fin du tableau. Les équivalences suivantes sont vraies en supposant que C<$[ == 0> : push(@a,$x,$y) splice(@a,@a,0,$x,$y) pop(@a) splice(@a,-1) shift(@a) splice(@a,0,1) unshift(@a,$x,$y) splice(@a,0,0,$x,$y) $a[$x] = $y splice(@a,$x,1,$y) Exemple, en supposant que la longueurs des tableaux est passée avant chaque tableau : sub aeq { # compare deux listes de valeurs my(@a) = splice(@_,0,shift); my(@b) = splice(@_,0,shift); return 0 unless @a == @b; # même longueur ? while (@a) { return 0 if pop(@a) ne pop(@b); } return 1; } if (&aeq($len,@foo[1..$len],0+@bar,@bar)) { ... } =item split /MOTIF/,EXPR,LIMIT =item split /MOTIF/,EXPR =item split /MOTIF/ =item split Découpe une chaîne en un tableau de chaînes et le retourne. Par défaut, les champs vides du début sont gardés et ceux de la fin sont éliminés. Si l'appel n'est pas dans un contexte de liste, split retourne le nombre de champs trouvés et les place dans le tableau C<@_>. (Dans un contexte de liste, vous pouvez forcer l'utilisation du tableau C<@_> en utilisant C comme motif délimiteur mais il renvoie encore la liste des valeurs.) En revanche, l'utilisation implicite de C<@_> par split est désapprouvée parce que cela écrase les arguments de votre subroutine. SI EXPR est omis, split découpe la chaîne C<$_>. Si MOTIF est aussi omis, il découpe selon les blancs (après avoir sauté d'éventuels blancs au départ). Tout ce qui correspond à MOTIF est considéré comme étant un délimiteur de champs. (Remarquez que le délimiteur peut être plus long qu'un seul caractère.) SI LIMIT est spécifié et positif, fixe le nombre maximum de champs du découpage (il est possible que le nombre de champs soit inférieur). Si LIMIT n'est pas spécifié ou vaut zéro, les champs vides de la fin sont supprimés (chose dont les utilisateurs potentiels de C devraient se souvenir). Si LIMIT est négatif, il est traité exactement comme si LIMIT avait une valeur arbitrairement très grande. Un motif qui peut correspondre à la chaîne vide (ne pas confondre avec le motif vide C qui n'est qu'un motif parmi tous ceux qui peuvent correspondre à la chaîne vide) découpera la valeur de EXPR en caractère séparé à chaque point où il sera reconnu. Par exemple : print join(':', split(/ */, 'hi there')); produira la sortie 'h:i:t:h:e:r:e'. La paramètre LIMIT peut être utilisé pour découper partiellement une ligne : ($login, $passwd, $remainder) = split(/:/, $_, 3); Lors de l'affectation à une liste, si LIMIT est omis, Perl agit comme si LIMIT était égal au nombre de variables de la liste plus un pour éviter tout travail inutile. Pour la liste ci-dessous, la valeur par défaut de LIMIT serait 4. Dans les applications où le temps est critique, il vous incombe de ne pas découper en plus de champs que ceux réellement nécessaires. Si MOTIF contient des parenthèses (et donc des sous-motifs), un élément supplémentaire est créé dans le tableau résultat pour chaque chaîne reconnue par le sous-motif. split(/([,-])/, "1-10,20", 3); produit la liste de valeurs (1, '-', 10, ',', 20) Si vous avez dans la variable C<$header> tout l'en-tête d'un email normal d'Unix, vous devriez pouvoir le découper en champs et valeurs en procédant comme suit : $header =~ s/\n\s+/ /g; # fix continuation lines %hdrs = (UNIX_FROM => split /^(\S*?):\s*/m, $header); Le motif C peut être remplacé par une expression pour spécifier un motif qui varie à chaque passage. (Pour faire une compilation une seule fois lors de l'exécution, utilisez C.) Un cas spécial : spécifié un blanc (C<' '>) comme MOTIF découpe selon les espaces exactement comme le fait C sans argument. Donc, C peut être utilisé pour émuler le comportement par défaut de B alors que C vous donnera autant de champs vides que d'espaces au début. Un C avec C est comme C sauf dans le cas de blancs au début qui produiront un premier champ vide. Un C sans argument effectue réellement un C en interne. Exemple : open(PASSWD, '/etc/passwd'); while () { ($login, $passwd, $uid, $gid, $gcos, $home, $shell) = split(/:/); #... } Remarquez que C<$shell> contiendra encore un caractère nouvelle ligne (newline). (Voir L, L et L.) =item sprintf FORMAT, LIST Retourne une chaîne formatée par les conventions usuelles de la fonction C de la bibliothèque C. Voir L ou L sur votre système pour une explication sur les principes généraux. Perl a sa propre implémentation de C -- elle émule la fonction C C mais elle ne l'utilise pas (sauf pour les nombres en virgule flottante et encore en n'autorisant que les modificateurs standards). Conséquence : une extension non-standard de votre version locale de C ne sera pas disponible en Perl. Le C de Perl autorise les conversions universellement connues : %% un signe pourcent %c un caractère dont on fournit le code %s une chaîne %d un entier signé, en décimal %u un entier non-signé, en décimal %o un entier non-signé, en octal %x un entier non-signé, en hexadécimal %e un nombre en virgule flottante, en notation scientifique %f un nombre en virgule flottante, avec un nombre de décimales fixe %g un nombre en virgule flottante, %e ou %f (au mieux) De plus, Perl autorise les conversions largement supportées : %X comme %x mais avec des lettres majuscules %E comme %e, mais en utilisant un "E" majuscule %G comme %g, mais en utilisant un "E" majuscule (si nécessaire) %p un pointeur (affiche la valeur Perl de l'adresse en hexadécimal) %n spécial: stocke le nombre de caractères produits dans la prochaine variable de la liste des paramètres Et finalement, pour des raisons de compatibilité (et "uniquement" pour cela), Perl autorise les conversions inutiles mais largement supportées : %i un synonyme de %d %D un synonyme de %ld %U un synonyme de %lu %O un synonyme de %lo %F un synonyme de %f Perl accepte les flags universellement connus suivants entre le C<%> et la lettre de conversion : espace précède les nombres positifs par un espace + précède les nombres positifs par un signe plus - justifie le champ à gauche 0 utilise des zéros à la place des espaces pour justifier à droite # précède le nombre non nul en octal par "0", précède le nombre non nul en hexadécimal par "0x" nombre taille minimum du champ .nombre "précision": nombre de décimales pour un nombre en virgule flottante, longueur maximum pour une chaîne, longueur minimum pour un entier l interprète un entier comme le type C "long" ou "unsigned long" h interprète un entier comme le type C "short" ou "unsigned short" Il y a aussi un flag spécifique à Perl : V interprète un entier comme le type entier standard de Perl À chaque fois qu'un nombre peut être spécifié comme flag, on peut le remplacer par un astérisque ("C<*>") auquel cas Perl utilise le prochain item de la liste des paramètres comme valeur pour ce nombre (c'est à dire comme longueur ou précision du champ). Si un champ de longueur obtenu par "C<*>" est négatif alors cela a le même effet que le flag "C<->" : justification à gauche. Si C est actif, le caractère utilisé comme séparateur décimal pour les nombres réels dépend de la valeur de LC_NUMERIC. Voir L. =item sqrt EXPR =item sqrt Renvoie la racine carrée de EXPR. Si EXPR est omis, retourne la racine carrée de C<$_>. =item srand EXPR =item srand Fixe la graine aléatoire pour l'opérateur C. Si EXPR est omis, on utilise une valeur pseudo-aléatoire basée entre autres sur l'heure courante et l'ID du process. Dans les versions de Perl antérieures à la version 5.004, la valeur par défaut était juste C. Ce n'est pas une graine particulièrement bonne et donc de nombreux programmes anciens fournissaient leur propre valeur de graine (souvent C