Les Mongueurs de Perl / Groupe de travail Articles / Conférences Perl

Nous rejoindre / SVN / Relecture / Rédaction / Planning / Liens /

Publications : Linux Magazine France, Perles, Brèves, Production, Comptes-Rendus, Interviews, Traductions, Spoofathon

    # n'affiche que certains trucs
    /regex/ && print for @trucs;

    # autre formulation
    print grep { /regex/ } @trucs;

    # n'affiche que certains trucs (les mêmes qu'avant)
    foreach my $truc (@trucs) {
        print $truc if $truc =~ /regex/;
    }

    while (<FH>) {
        # la ligne courante est stockée dans $_
        ...
    }

    while ( defined( my $ligne = <FH> ) ) {
        # la ligne courante est stockée dans $ligne
        ...
    }

    open F, "< $fichier" or die "Impossible d'ouvrir $fichier: $!";
    while ( my $ligne = <F> and $. <= 10 ) {
        print $ligne;
    }

    # imprime la liste des utilisateurs
    open F, "< /etc/passwd" or die "Impossible d'ouvrir /etc/passwd : $!";
    while (<F>) {
        next if /^\s*(?:#|$)/;    # ignore les commentaires et lignes blanches
        s/:.*//;
        print;
    }
    close F;

    # imprime la liste des utilisateurs
    open F, "< /etc/passwd" or die "Impossible d'ouvrir /etc/passwd : $!";
    while (defined my $ligne = <F>) {
        next if $ligne =~ /^\s*(?:#|$)/;
        $ligne =~ s/:.*//;
        print $ligne;
    }
    close F;

    $ perl -lpe 'next if/^\s*(?:#|$)/;s/:.*//' /etc/passwd

    # récupère la liste des sous-répertoires de $dir dans @subdirs
    opendir( DIR, $dir ) or die "Impossible d'ouvrir $dir: $!";
    my @files = readdir(DIR);

    # Note : @files contient des fichiers relatifs à $dir
    my @abs = map { "$dir/$_" } @files;
    my @subdirs = grep { -d } @abs;

    closedir(DIR);

    # récupère la liste des sous-répertoires de $dir dans @subdirs
    opendir( DIR, $dir ) or die "Impossible d'ouvrir $dir: $!";

    my @subdirs = grep { -d } map { "$dir/$_" } readdir(DIR);

    closedir(DIR);

    #!/usr/bin/perl
    while (<>) {
        # traitement complexe sur $_
    }

    @ARGV = glob("*") unless @ARGV;

    @ARGV = grep { -f } @ARGV;

    @ARGV = map { /^\.(gz|Z)$/ ? "gzip -dc $_ |" : $_ } @ARGV;

    @ARGV = map { m!^\w+://! ? "lynx -dump $_ |" : $_ } @ARGV;

    @ARGV = map { m!^\w+://! ? "lynx -source $_ |" : $_ } @ARGV;

    sub rot13 {
        my $string = shift;
        $string =~ y/A-Za-Z/N-ZA-Mn-za-m/;
        return $string;
    }

Et pour les méthodes des modules objets (une référence à l'instance en cours de l'objet étant toujours passée en premier paramètre à la méthode):

    # un accesseur pour l'attribut color d'un objet
    sub color {
        my $self = shift;
        my $old  = $self->{color};
        $self->{color} = shift if @_;
        return $old;
    }

Voire :

    sub print_color { print shift->{color} }

• $/

  $/ est le séparateur d'enregistrements en entrée. Par défaut, $/ est un saut de ligne. Cette variable modifie l'idée que Perl se fait de ce qu'est une ligne, en particulier avec l'opérateur <> (parfois appelé readline() ).

  La notion de ligne dépend du système d'exploitation utilisé. Plus précisément, sous Unix les lignes seront délimitées par le caractère \012, tandis que sous DOS/Windows ce sera par \015\012 et que sous Mac on utilisera \015. Heureusement, Perl initialise $/ directement à la valeur habituelle sur le système utilisé (ceci pourra vous jouer des tours si vous traitez un fichier DOS sous Unix et réciproquement).

  Il est important de noter que $/ peut être une chaîne de plusieurs caractères. Ceci permet des découpages un peu plus élaborés du fichier en entrée :

      my $fortune;
      local $/ = "\n%\n";
      while(<>) {
          $fortune = $_ if rand $.;
      }
      print $fortune;

  Cet algorithme, qui permet de sélectionner une entrée de façon équiprobable (au moins au sens de rand() ), est expliqué à la recette 8.6 (Picking a Random Line from a File) du Perl Cookbook (Perl en action dans la version française), publié chez O'Reilly.

  Notez l'utilisation de local() pour modifier $/. Quand on modifie les variables spéciales de Perl, surtout celles qui concernent les entrées/sorties, local() permet de limiter la portée de ces modifications au bloc (dynamique) qui entoure la modification. On peut ainsi s'assurer que les modifications n'altéreront pas le fonctionnement habituel de Perl à d'autres endroits du code (par exemple dans des routines définies par d'autres modules utilisés).

  Il existe deux valeurs de $/ pour lesquelles <> a un comportement un peu particulier.

  Si $/ vaut undef, readline() lira le fichier jusqu'à la fin en une seule fois. C'est ce qu'on appelle le slurp mode, ou mode aspiration.

  Si $/ vaut "", on passe en mode paragraphe, c'est-à-dire que readline() renverra le fichier paragraphe par paragraphe (deux paragraphes étant séparés par des lignes vides). Si vous affectez "\n\n" à $/, vous n'obtiendrez pas tout à fait le même résultat, puisque Perl considérera que les caractères qui suivent $/ font partie du prochain paragraphe, tandis qu'avec "" plusieurs lignes vides consécutives sont traitées comme une seule séparation de paragraphe (et les paragraphes sont alors de vrais paragraphes).

  Attention, $/ n'est pas utilisé comme une expression régulière. Il serait d'ailleurs particulièrement difficile d'écrire un module qui permette d'utiliser un équivalent de $/ qui soit une expression régulière. À ce sujet, voir le blog de Nat Torkington (l'un des auteurs du Perl Cookbook) qui mentionne le problème dans $RS as Regex, http://use.perl.org/~gnat/journal/11599.

  Notez que chomp() se sert de $/ pour déterminer quelle suite de caractères supprimer à la fin d'une chaîne. Ceci permet d'éliminer un bug subtil (et non portable) que vous pourriez faire si vous utilisiez chop(). En effet, chop() supprime le dernier caractère d'une chaîne, quel qu'il soit, tandis que chomp() supprime la sous-chaîne finale d'une chaîne seulement si celle-ci est égale à $/. chop() est assez rarement utilisé.

• $.

  $. est le numéro de ligne (plus précisément le numéro d'enregistrement) courant du dernier fichier à partir duquel vous venez de lire quelque chose. Il peut effectivement être différent du véritable numéro de ligne si vous avez modifié l'idée que Perl se fait des lignes à l'aide de $/.

  Voici un petit uniligne pour numéroter les lignes d'un fichier (éh oui, il est légèrement différent de celui de l'article précédent ; s'il fallait prouver qu'il y a plus d'une manière de faire, c'est fait).

      $ perl -ne 'printf"%6d $_",$.'

  $. est réinitialisé lors d'un close() explicite sur un handle de fichier.

  Pour savoir comment réinitialiser $. entre deux fichiers passés sur @ARGV (avec un close(ARGV)), reportez-vous à la documentation de eof().

• @F

  Nous avons déjà vu @F dans l'article sur les programmes d'une ligne. C'est le tableau qui reçoit les éléments autosplités quand l'option -a a été utilisée sur la ligne de commande.

  @F ne sert que pour les unilignes.

• $ARGV

  $ARGV contient simplement le nom du fichier en cours de lecture lorsqu'on utilise la construction <>. Lorsque Perl a ouvert l'entrée standard (car @ARGV était vide, voir plus haut), $ARGV contient évidemment -.

  Pour être complet, précisons que le handle de fichier associé à $ARGV et <> est ARGV. Il est en fait rarement utilisé, sauf avec eof() (vous pouvez à nouveau consulter la documentation de cette fonction pour plus de détails).

• $\

  $\ est le séparateur d'enregistrement pour la fonction print() .

  Par défaut, $\ est vide, c'est-à-dire qu'habituellement, print() se contente d'imprimer la liste de ses arguments, sans rien de plus.

      $ perl -e 'print 1..5'
      12345

  Si vous voulez ajouter une chaîne à la fin de chaque appel à print() , vous pouvez utiliser $\ en conséquence. On peut dire que $\ est plus ou moins le contraire de $/.

      $ perl -e '$\ = ","; print 1..5'
      12345,

  Attention, $\ n'a aucun effet sur printf() .

• $,

  $, est le séparateur de champs pour la fonction print() .

  Par défaut, $, est vide, c'est-à-dire qu'habituellement, print() se contente d'imprimer la liste de ses arguments. Même exemple que précédemment :

      $ perl -e 'print 1..5'
      12345

  Si vous voulez afficher quelque chose entre deux champs, vous pouvez modifier $, en conséquence.

      $ perl -e '$, = ","; print 1..5'
      1,2,3,4,5

• $"

  $" fonctionne comme $, sauf qu'elle s'applique aux tableaux et tranches qui sont interpolés dans une chaîne entre guillemets (ou les chaînes qui sont interprétées de la même manière).

  Par défaut, $" est un espace :

      $ perl -e '@a = ( 1 .. 5 ); print "@a"'
      1 2 3 4 5
  
      $ perl -e '@a = ( 1 .. 5 ); $" = ","; print "@a"'
      1,2,3,4,5

  Notez bien que c'est différent de l'affichage du même tableau sans interpolation :

      $ perl -e '@a = ( 1 .. 5 ); print @a'
      12345

• $|

  La principale utilisation de cette variable se résume à la ligne suivante :

      $| = 1;

  Si $| est vraie, le mode d'écriture systématique des tampons (autoflush) est activé sur le handle de fichier courant (en général STDOUT).

  Si vous désirez activer l'autoflush sur un handle de fichier autre que STDOUT, vous pouvez utiliser la construction suivante, assez idiomatique, mais peu lisible :

      select( ( select(FH), $| = 1 )[0] );

  select() permet en effet de sélectionner le handle de fichier courant, qui sera celui sur lequel la modification faite à $| aura un effet. Il retourne l'ancien handle de fichier, qui est ici récupéré par le [0] appliqué à la liste de deux éléments.

  De nos jours, on utilise plutôt IO::File, avec la méthode autoflush() (héritée de IO::Handle). C'est tout de même plus lisible :

      use IO::File;
      $fh = new IO::File;
      $fh->open("> fichier") or die "Erreur: $!";
      $fh->autoflush(1);

  Ou pour faire le strict équivalent de $| = 1 (sur STDOUT par défaut) :

      use IO::File;
      autoflush STDOUT 1;

  $| est généralement utilisé dans les scripts vite écrits, vite jetés, ou alors par les golfeurs Perl (mais il vaut mieux pour votre santé mentale que vous ignoriez ce qu'ils font avec).

• $@

  $@ contient le message d'erreur du dernier eval() qui a été exécuté. Si $@ est vide, cela signifie que le dernier eval() a été évalué et exécuté correctement.

  Seuls les messages des erreurs fatales sont capturés par $@. Les avertissements sont traités normalement (c'est-à-dire envoyés sur STDERR, en général).

  eval { } (le eval d'un bloc, à ne pas confondre avec le eval d'une chaîne) utilisé avec $@ et die() permet de mettre en œuvre un mécanisme d'exception (comme en Java). Voici un exemple :

      eval {
          open F, $file or die "IO: $!";
          while (<F>) {
              # assertion
              die "ASSERT: $file contient une ligne de '#'" if /^#+$/;
  
              # faire quelque chose d'utile ici
          }
          close F or die "IO: $!";
      };
  
      # gestion des exceptions levées
      if ( $@ =~ /^IO:/ ) {
          # erreur d'entrée sortie
      }
      elsif ( $@ =~ /^ASSERT:/ ) {
          # une assertion a échoué
      }

  Si on sort du bloc normalement, $@ est vide, sinon $@ contient le message passé à die() .

• $!

  $! contient l'erreur système courante (le fameux errno).

  Cette variable est très magique : utilisée en contexte numérique, elle renverra la valeur numérique de errno (qui dépend du système), alors qu'utilisée comme une chaîne de caractères, elle contiendra le message d'erreur.

  De plus, si vous affectez une valeur numérique à $!, le message d'erreur dans $! en tant que chaîne sera le bon. Et si le programme meurt (avec die() ), le statut de sortie du programme aura la valeur correspondante.

      $ perl -e '$! = 13; die' ; echo $?
      Died at -e line 1.
      13

  Voici un exemple de script qui affiche tous les messages d'erreur du système, avec la traduction numéro/message (et en plus, vous aurez des messages différents selon la locale qui est définie) :

      $ LC_ALL=C perl -e '$! = $_, print 0 + $!, " $!\n" for 1 .. 128'
      1 Operation not permitted
      2 No such file or directory
      3 No such process
      4 Interrupted system call
      ...

  Ou en français :

      $ LC_ALL=french perl -e '$! = $_, print 0 + $!, " $!\n" for 1 .. 128'
      1 Opération non permise
      2 Aucun fichier ou répertoire de ce type
      3 Aucun processus de ce type
      4 Appel système interrompu
      ...

• $^E

  Cette variable fournit des informations d'erreur spécifiques au système d'exploitation. Si $^E n'est pas supportée par le système d'exploitation, alors elle sera égale à $!.

  En fait, $^E n'est différente de $! que sous VMS, OS/2, MacPerl et Win32. Ce qui la rend de peu d'intérêt pour un lecteur de Linux Magazine.

• $?

  $? contient le statut de sortie renvoyé par la dernière commande qx() (ou ``), le dernier appel réussi à wait() ou waitpid() ou la dernière fermeture d'un tube ; en bref, le résultat du dernier sous-processus exécuté. Ce n'est pas pour rien qu'elle porte le même nom que la variable équivalente du shell.

  En fait, c'est un statut sur 16 bits. La valeur de sortie du sous-processus est donnée par $? << 8. Le reste du mot donne d'autres informations, soit en résumé :

       $exit_value  = $? >> 8;    # valeur de sortie
       $signal_num  = $? & 127;   # numéro du signal qui a tué le processus
       $dumped_core = $? & 128;   # vrai si c'était un core dump

  Pour récupérer la bonne valeur de $? quand vous avez ouvert un tube sur un sous-processus (avec un open() sur "commande|", par exemple), il faut impérativement faire un close() du handle de fichier.

• $0

  $0 contient le nom du programme en train de s'exécuter. Si le programme en cours d'exécution est donné avec l'option -e de Perl, $0 contiendra simplement la chaîne "-e". Sinon, $0 contiendra le nom du script.

  Sur certains systèmes d'exploitation, modifier $0 permet de modifier le nom du programme tel qu'affiché par ps, ce qui permet de faire comme sendmail et d'indiquer par exemple l'état du programme.

• $$

  Le numéro de process id (ou PID) du processus Perl en train de s'exécuter.

• %ENV

  Ce hachage contient l'ensemble des variables d'environnement définies lorsque le script a été lancé.

  Bien évidemment, si vous créez ou modifiez une variable d'environnement en affectant une valeur à l'une des clés de %ENV, cela modifiera l'environnement des processus lancés après ladite modification par system(), qx() ou les formes de open() qui créent un sous-processus.

• @INC

  @INC contient la liste des répertoires où Perl va aller chercher les modules ou fichiers nécessaires pour exécuter une instruction do, require ou use.

  Le tableau se comporte comme la variable d'environnement PATH de votre shell. Perl va successivement chercher le module demandé dans les différents répertoires.

  Les éléments contenus par défaut dans @INC sont définis à la compilation de Perl. Il est heureusement possible d'ajouter (ou de supprimer) des répertoires à cette liste lors de l'exécution d'un script.

  Il existe trois manières de modifier le contenu de @INC : les variables d'environnement, l'option -I de perl et la pragma lib. Vous pouvez également agir directement sur @INC, mais c'est en général réservé à ceux qui savent vraiment ce qu'ils font.

  Deux variables d'environnement permettent d'ajouter des éléments à @INC : PERLLIB et PERL5LIB, qui contiennent une liste de répertoires séparés par des deux-points (:). Si PERL5LIB est utilisé, alors PERLLIB est ignoré. Attention, quand Perl fonctionne en mode taint checking, ces deux variables d'environnement sont ignorées. Dans ce cas, il faut impérativement utiliser l'une des deux autres méthodes.

  L'option -I permet d'ajouter une liste de répertoires (ici aussi séparés par des deux-points) à @INC. Cette option peut être utilisée plusieurs fois.

  Enfin, la pragma use lib, suivie d'une liste de répertoires permet également de les ajouter à @INC. La documentation du module lib explique également les détails de no lib, qui permet de supprimer des répertoires de @INC (ce qui est rarement nécessaire).

  Pour voir l'effet de chacune de ces directives sur le contenu de @INC, et l'ordre dans lequel elles sont prises en compte, utilisons le one-liner suivant (ici sur une distribution Debian) :

      $ PERL5LIB=env1:env2 perl -Iopt1:opt2 -Iopt3 -le 'use lib qw(lib1 lib2); use lib "lib3"; print for @INC'
      lib3
      lib1
      lib2
      opt1
      opt2
      opt3
      env1
      env2
      /usr/local/lib/perl/5.6.1
      /usr/local/share/perl/5.6.1
      /usr/lib/perl5
      /usr/share/perl5
      /usr/lib/perl/5.6.1
      /usr/share/perl/5.6.1
      /usr/local/lib/site_perl
      .

  Personnellement, dans les cas de dépendance envers des modules qui ne sont pas installés dans les répertoires standards (par exemple modules personnels sur une machine où je n'ai pas les droits d'administration nécessaires pour l'installation de modules Perl), je préfère l'utilisation de la variable d'environnement PERL5LIB ou de l'option -I, car cela n'impose pas de modification du script exécuté.

  D'autres conditions d'utilisations justifient d'autres choix.

• $^O

  $^O contient le nom du système d'exploitation sur lequel la version de Perl en train de tourner a été compilée. C'est la même valeur que celle qu'on trouve dans $Config{'osname'} (voir la page de manuel Config(3pm) pour plus de détails).

  Si vous réalisez du code qui a un comportement différent selon le système d'exploitation (cela peut arriver), vous pouvez être amenés à écrire du code comme celui-ci :

      if ( $^O eq 'MSWin32' ) {
          # code spécifique Windows
      }

  Voir perlport(1), section PLATFORMS pour avoir la liste des systèmes supportés, et les valeurs de $^O correspondantes.

• $^X

  $^X contient le nom sous lequel le binaire de perl a lui-même été exécuté, tel qu'obtenu par le argv[0] de C. Il n'y a aucune garantie quant à ce qu'elle contient, ce peut être ou non un chemin complet, par exemple.

• $^W

  $^W contient la valeur courante de l'option d'avertissement de Perl. $^W est initialement vraie si -w a été utilisé.

  Avant Perl 5.6.0, on utilisait généralement $^W pour supprimer les avertissements dans un bloc de code, comme ceci :

      {
          local $^W = 0;    # désactive temporairement les avertissements
          $A = $B + $C;     # ces variables sont potentiellement indéfinies
      }

  À partir de Perl version 5.6.0, plutôt que de modifier $^W, on peut utiliser la pragma warning. Celle-ci a l'avantage d'être à portée lexicale (voir la page de manuel perllexwarn(1) pour plus de détails).

      {
          no warnings;    # désactive temporairement les avertissements
          $A = $B + $C;   # ces variables sont potentiellement indéfinies
      }

  Notez également que vous ne pouvez pas utiliser my() sur $^W, mais seulement local() comme sur toutes les variables spéciales de Perl.

• %SIG

  Le modèle de gestion des signaux de Perl est assez simple : le hachage %SIG, indexé par les noms des signaux, contient des noms ou des références (de code) de handlers pour ces signaux.

  Tous les détails de la gestion des signaux en Perl sont expliqués dans la page de manuel perlipc(1). Nous ne nous étendrons donc pas dessus, sinon pour donner deux courts exemples de code. Un dernier rappel, vous êtes censés en faire le moins possible dans un handler de signal, car quasiment quoi que vous puissiez faire de plus compliqué que modifier une variable globale risque de provoquer un core dump.

  Nous avons reçu un signal mortel :

      $SIG{KILL} = $SIG{INT} = sub { $killed++ };
      while ( not $killed ) { 
          # un traitement très répétitif
          ...
      }
      # un peu de nettoyage post-traitement
      ...

  Une manière de gérer des délais de garde (timeout) quand on dispose du signal ALRM :

      eval {
          local $SIG{ALRM} = sub { die "TIMEOUT" };
          alarm 10;          # on se donne 10 secondes pour
          flock( FH, 2 );    # l'opération qui est bloquante
          alarm 0;           # annulation du compteur
      };
      if ( $@ and $@ !~ /TIMEOUT/ ) {
          # traitement d'erreur
          ...
      }

  La page de manuel perlipc(1) est très complète sur le sujet des signaux, consultez-la si vous ne maîtrisez pas le sujet.

• Stages of a Perl Programmer (Novice, Initiate, User, Adpet, Hacker, Guru, Wizard), par Nathan Torkington.

  http://prometheus.frii.com/~gnat/yapc/2000-stages/

Mon prochain article sera d'ailleurs consacré à la documentation de Perl, afin de vous aider à vous retrouver dans la jungle de l'information disponible.

Philippe Bruhat est vice-président de l'association les Mongueurs de Perl, membre du groupe Paris.pm et de l'équipe organisatrice de la conférence YAPC::Europe à Paris en juillet 2003 (http://yapc.mongueurs.net/). Il est consultant en sécurité et l'auteur des modules Log::Procmail, HTTP::Proxy et Regexp::Log, disponibles sur CPAN.

BooK tient à remercier Jean Forget, qui lui a fourni un exemple tout à fait éclairant sur l'étendue de la magie à l'œuvre dans while().

Copyright © Les Mongueurs de Perl, 2001-2011 pour le site.
Les auteurs conservent le copyright de leurs articles.