[couverture de Linux Dossiers 2]
[couverture de Linux Magazine 42]

Introduction à la programmation en Perl (2/7)

Article publié dans Linux Magazine 42, septembre 2002. Repris dans Linux Dossiers 2 (avril/mai/juin 2004).

Copyright © 2002-2003 - Sylvain Lhullier.

[+ del.icio.us] [+ Developers Zone] [+ Bookmarks.fr] [Digg this] [+ My Yahoo!]

Ce document est généré à partir du source XML fourni par Sylvain à l'adresse http://sylvain.lhullier.org/publications/perl.html.

Chapeau

Nous continuons ici notre série d'articles sur la programmation en Perl. Ce langage puissant et riche permet d'écrire rapidement des programmes utiles et fiables. Sa conformité POSIX en fait un allié indispensable à l'administrateur système ; la grande facilité de mise en oeuvre de ses fonctions et la souplesse de sa syntaxe sont très appréciées des développeurs de logiciels.

Listes et tableaux

Les scalaires et les expressions de base n'ont maintenant plus aucun secret pour vous. Des notions plus complexes et des fonctions plus puissantes sont alors à notre portée. C'est le cas des listes, des tableaux et de l'impressionnant arsenal de fonctions Perl permettant de les manipuler ; vous verrez tout ce qu'il est possible de faire en Perl avec ces deux concepts a priori anodins.

Une liste est une suite (donc ordonnée) de valeurs scalaires. Nous verrons comment créer une liste, la manipuler, la parcourir etc.

Une variable de type tableau peut contenir plusieurs valeurs scalaires. Cette notion est présente dans de nombreux langages de programmation et ne posera sans doute problème à personne.

Les passerelles entre listes et tableaux sont nombreuses et très intuitives en Perl. C'est pour cela que nous n'entrerons pas ici dans les détails de la distinction entre liste et tableau. Dans ce document, j'utiliserai chacun des deux termes à bon escient sans forcement indiquer explicitement pourquoi j'utilise l'un plutôt que l'autre, mais les notions pourront apparaître naturelles au lecteur sans qu'il ne soit nécessaire de préciser les choses formellement.

Valeurs de listes

En Perl, une liste peut être représentée par les valeurs qu'elle doit contenir encadrées par un couple de parenthèses. Par exemple (2,5,-3) est une liste de 3 scalaires : 2, 5 et -3. Autre exemple (2,'age',"Bonjour $prenom") est aussi une liste ; en effet les listes contenant des scalaires, rien ne nous empêche d'en constituer une comportant des nombres et des chaînes de caractères mêlés. La liste vide se représente sous la forme suivante : ()

L'opérateur d'intervalle .. permet de créer une liste comportant des valeurs successives entre deux bornes. La liste (1..10) comporte tous les entiers de 1 à 10 ; on aurait pu aussi écrire (1,2,3,4,5,6,7,8,9,10), mais cette dernière notation est bien plus lourde. Il faut savoir que les valeurs des bornes ne doivent pas obligatoirement être des nombres : par exemple, la liste ('a'..'z') comporte toutes les lettres de l'alphabet, en minuscule et dans l'ordre. Il est aussi possible de spécifier les bornes à l'aide de variables : ($debut..$fin) On comprendra qu'il n'est pas toujours possible de résoudre ce type de liste (par exemple si $debut vaut 1 et $fin vaut 'a'), dans ce cas la liste est vide. Dernier exemple, la liste (1..10, "age", "a".."z") comporte 37 éléments (10+1+26).

La liste (1,2,("nom",12),"aaa",-1) n'est pas une liste à 5 éléments dont le troisième serait une autre liste, c'est en fait une liste à 6 éléments. On aurait pu écrire (1,2,"nom",12,"aaa",-1) et on aurait obtenu la même liste. On appelle cela l'aplatissement (ou la linéarisation) des listes. Pour constituer une liste de listes, il faudra faire usage de références (notion que nous aborderons plus tard).

L'opérateur de répétition (x), que l'on a déjà appliqué aux chaînes de caractères précédemment, s'applique aussi aux listes : (2,10) x 3 est une liste à 6 éléments valant (2,10,2,10,2,10).

Manipulation de tableaux

Pour simplifier les choses, un tableau est une variable qui peut avoir une liste pour valeur. Une telle variable se déclare de la sorte : my @t; On a alors un tableau vide, c'est-à-dire sans élément. De manière plus explicite, voici comment déclarer un tableau vide :

    my @t = ();

Pour lui donner une valeur lors de sa déclaration, il faut faire ainsi :

    my @t = (3,'chaine',"bonjour $prenom");

On a alors déclaré ce tableau en l'initialisant au moyen d'une liste.

On peut accéder directement à un élément d'un tableau grâce à son indice : $t[indice] représente l'élément d'indice indice du tableau @t. Notez bien que la globalité du tableau se représente au moyen d'une arobase @t alors qu'un élément particulier est désigné à l'aide d'un dollar $t[indice], cette dernière expression étant bien une variable de type scalaire (le dollar est réservé aux scalaires en Perl).

Les indices des tableaux en Perl commencent à 0 (comme en C), ce qui signifie que le premier élément du tableau @t est $t[0] et le deuxième $t[1] etc. Voici un petit exemple d'utilisation de tableau :

    my @t = (3,5);   # déclaration et initialisation
    $t[1] = 4;       # affectation d'un élément
    print "$t[0]\n"; # affichage d'un élément

Il est intéressant de savoir qu'il est possible d'accéder au dernier élément d'un tableau en utilisant l'indice -1 : $t[-1] est le dernier élément de @t. De la même façon, $t[-2] est l'avant-dernier, etc.

Il est possible de connaître l'indice du dernier élément d'un tableau @t grâce à la variable $#t On a donc $t[$#t] équivalent à $t[-1] (ce dernier étant bien plus lisible). Il peut être utile de savoir que l'expression scalar(@t) (c'est-à-dire l'utilisation d'un tableau en contexte scalaire) donne le nombre d'éléments du tableau @t (ce qui vaut 1 de plus que $#t) ; $x=@t donnerait la même chose.

Il faut savoir que vous ne générerez pas d'erreur (débordement ou autre) si vous tentez d'accéder à un élément au-delà du dernier. La valeur de cet élément sera simplement undef et le programme continuera. Depuis la version 5.6 de Perl, l'instruction exists (que l'on retrouvera pour les tables de hachage) permet de tester l'existence d'un élément d'un tableau :

    if( exists( $t[100] ) )
    { ... }

Ce test sera vrai si l'élément d'indice 100 du tableau @t existe. Ce qui est différent du test suivant :

    if( defined( $t[100] ) )
    { ... }

Car on teste ici si l'expression $t[100] vaut undef ou non, ce qui peut être vrai dans deux cas : soit l'élément existe et vaut undef, soit l'élément n'existe pas ...

Voici une autre illustration du fait que vous n'avez pas à vous soucier de problèmes d'allocation mémoire :

    my @t = (3,23.4,"as");
    $t[1000] = 8;

Ce programme est correct et fonctionne parfaitement : l'affectation à l'indice 1000 agrandit le tableau d'autant ... Les éléments d'indice compris entre 3 et 999 valent undef et scalar(@t) vaut 1001. C'est si facile finalement !

Un tableau qu'il est utile de connaître est @ARGV. Cette variable spéciale est toujours définie (même dans les fonctions) et ne nécessite pas de déclaration. Elle contient les arguments de la ligne de commande du programme. Les trois façons de lancer un programme en Perl sont susceptibles d'utiliser @ARGV:

    perl -w -e '... code perl ...' arg1 arg2 arg3
    perl -w script.pl arg1 arg2 arg3
    ./script.pl arg1 arg2 arg3

Ces trois programmes sont lancés avec les trois mêmes arguments. Sachez que, contrairement au langage C, le nom du programme n'est pas contenu dans @ARGV qui ne comporte donc que les arguments au sens strict. La variable spéciale $0 (comme en shell) contient le nom du programme (nul besoin de déclarer cette variable pour l'utiliser).

Affectations

Il est possible d'affecter un tableau à un autre tableau en une seule instruction :

    @t = @s;

Cette instruction copie le tableau @s dans le tableau @t. Le tableau @t perd ses anciennes valeurs, prend celle de @s et sa taille devient celle de @s : on obtient bien deux tableaux tout à fait identiques (et distincts, la modification de l'un n'entraînant nullement la modification de l'autre).

Voici d'autres instructions d'affectation mêlant tableaux et listes :

Multi-déclaration

Pour déclarer plusieurs variables avec un seul my, le débutant aurait tendance à écrire la chose suivante (il n'y a pas de honte !) :

    my $a,$b;  # Incorrect !

Ceci est incorrect. Pour pouvoir faire cela, il nous faut utiliser une liste :

    my ($a,$b);

Les variables $a et $b sont créées et valent undef. Pour leur affecter des valeurs, il faut là aussi utiliser une liste (ou un tableau) :

    my ($a,$b) = (1,2);
    my ($c,$d) = @t;

Les mêmes règles que pour l'affectation de listes s'appliquent ici.

Retour sur l'aplatissement des listes

On retrouve la notion d'aplatissement des listes avec les tableaux :

    @t = (1,2,"age");
    @t2 = (10,@t,20);

Le tableau @t2 ne comporte pas trois éléments dont celui du milieu serait lui-même un tableau, mais contient les cinq éléments, résultat de l'aplatissement du tableau @t dans la liste de droite lors de l'affectation de @t2. Cette affectation a eu le même résultat qu'aurait eu la suivante :

    @t2 = (10,1,2,"age",20);

Absorption d'une liste par un tableau

La syntaxe suivante est intéressante à connaître :

    ($a,@t) = @s;

Le membre gauche de l'affectation est constitué d'une liste comportant une variable scalaire et un tableau. Il n'y a pas à proprement parler d'aplatissement de liste car il s'agit ici d'une l-value (membre gauche d'une affectation), mais la variable $a reçoit le premier élément du tableau @s et le tableau @t absorbe tous les autres (@s n'étant bien-sûr pas modifié).

En fait dans cette syntaxe, le premier tableau rencontré dans la liste de gauche reçoit tous les éléments restant de la liste de droite. D'éventuelles autres variables qui le suivraient (cas idiot, mais bon...) serait mises à undef s'il s'agit de scalaires et à vide s'il s'agit de tableaux. Par exemple, l'affectation suivante :

    @s = (10,1,2,"age",20);
    ($a, @t, @u, $b) = @s;

équivaut à :

    @s = (10,1,2,"age",20);
    $a = 10;
    @t = (1,2,"age",20);
    @u = ();
    $b = undef;

Simple et intuitif.

La structure de boucle foreach

Cette instruction permet de parcourir une liste. Son implémentation optimisée dans l'interpréteur Perl rend son usage bien plus efficace qu'un parcours qui utiliserait une variable indicielle incrémentée à chaque tour d'une boucle for. Sa syntaxe est la suivante :

foreach variable ( liste ) { instructions }

À chaque tour de boucle, la variable aura pour valeur un élément de la liste, la liste étant parcourue dans l'ordre. Aucune modification ni suppression dans la liste n'est effectuée par défaut dans ce type de boucle. Il vous est possible de modifier la variable de boucle (ce qui aura pour effet de modifier l'élément en question), mais, par défaut, le parcours n'est pas destructif.

Par exemple :

    foreach $v (1,43,"toto")
    {
       print "$v\n";
    }

Ce petit programme affiche chaque élément de la liste sur une ligne. Ces autres exemples sont valides eux-aussi :

    foreach $v (@t) { ... }
    foreach $v (32,@t,"age",@t2) { ... }

Dans le premier cas, les éléments du tableau @t sont parcourus. Le second exemple illustre les phénomènes d'aplatissement des listes qui se retrouvent ici aussi.

Il est possible de déclarer la variable de boucle dans le foreach de la manière suivante :

    foreach my $v (@t)
    {
       print "$v\n";
    }

Il est aussi possible de ne pas utiliser explicitement de variable de boucle ; dans ce cas c'est la variable spéciale $_ qui sera automatiquement utilisée :

    foreach (@t)
    {
       print "$_\n";
    }

Comme pour les autres boucles, l'instruction next passe à la valeur suivante sans exécuter les instructions qui la suivent dans le bloc. L'instruction last met fin à la boucle.

Voici un petit exemple d'utilisation de foreach affichant des tables de multiplication :

    #!/usr/bin/perl -w
    use strict;
    die("Usage: $0 <n> <n>\n")
       if( !defined( $ARGV[1] ) );
    foreach my $i (1..$ARGV[0])
    {
       foreach my $j (1..$ARGV[1])
       {
          printf( "%4d", $i*$j );
       }
       print "\n";
    }

Et le voici à l'œuvre :

    ./mult.pl
    Usage: ./mult.pl <n> <n>
    ./mult.pl 5 3
       1   2   3
       2   4   6
       3   6   9
       4   8  12
       5  10  15

Passons à la suite.

Fonctions de manipulation de tableaux

Il existe de nombreuses fonctions permettant de manipuler les tableaux. Pour chacun des exemples qui vont suivre, je suppose que nous avons un tableau @t déclaré de la sorte :

    my @t = (1,2,3,4);

Avec de telles fonctions, il est alors envisageable de manipuler des objets algorithmiques tels que les piles et les files. Une pile est un lieu de stockage ayant pour particularité que le dernier élément à y être entré sera le premier à en sortir (last in-first out) comme pour une pile d'assiettes sur une étagère de placard. On peut utiliser pour cela un tableau, avec les fonctions push pour ajouter un élément et pop pour en prendre un. De façon analogue, une file est un endroit où le premier entré est le premier à sortir (first in-first out) comme pour une file à une caisse de magasin. On peut par exemple utiliser les fonctions push pour ajouter un élément et shift pour en prendre un.

D'autre manipulations plus complexes du contenu d'un tableau sont possibles avec la fonction splice, mais je vous renvoie à la documentation pour les détails.

L'opérateur qw

L'opérateur qw nous permet de créer facilement une liste de chaînes de caractères. En effet, il peut sembler pénible de constituer une longue liste de tels éléments en raison du fait qu'il faut délimiter chacun d'entre eux au moyen de simples ou de doubles quotes :

    @t = ( 'Ceci', 'est', 'quelque', 'peu', 'pénible',
           'à', 'écrire', ',', 'non', '?' );

Avec qw, ceci devient tout à coup plus lisible :

    @t = qw(Cela est bien plus facile à faire non ?);

La chaîne de caractère sera découpée selon les espaces, les tabulations et les retours à la ligne.

Les délimiteurs les plus souvent utilisés sont les parenthèses (comme dans l'exemple précédent) ainsi que les slashs :

    @t = qw/Ou alors comme cela .../;

Cette fonction est bien pratique mais peut être source d'erreurs, voyez l'exemple suivant :

    @t = qw/ attention 'aux erreurs' bêtes /;

Les simples quotes (') semblent indiquer que le programmeur souhaite constituer un seul élément comportant les mots aux et erreurs ; ce n'est pas ce qui est fait ici. En effet, ni les simples quotes ni les doubles quotes ne constituent un moyen de regrouper des mots pour l'opérateur qw. La liste ainsi créée comporte donc 4 éléments ; on aurait pu écrire :

("attention","'aux","erreurs'","bêtes").

Écrire une fonction

Une fonction est un ensemble d'instructions regroupées de manière à être utilisées plusieurs fois sans avoir à dupliquer du code.

Déclaration

Le mot-clef sub permet de définir des fonctions en Perl. Les arguments d'une fonction sont des valeurs scalaires, à l'exclusion de toutes autres (on verra comment faire en sorte de passer un tableau en argument) ; ces paramètres sont accessibles via la variable spéciale @_ (qui est donc un tableau). Modifier une valeur de @_ modifiera les variables d'appel, il est donc d'usage d'en faire une copie avant manipulation.

    sub maJolieFonction
    {
       my ($x,$y,$t) = @_;
       ... instructions ...
       return $z;
    }

Ces quelques lignes définissent une nouvelle fonction dont le nom est maJolieFonction. Cette fonction copie dans trois variables locales les trois premières valeurs du tableau @_, c'est-à-dire ses trois premiers paramètres (les règles classiques d'affectation entre listes et tableaux s'appliquent ici). Je vous conseille de toujours commencer vos fonctions par une ligne copiant les valeurs de @_ et de ne plus utiliser @_ dans la suite de la fonction (sauf cas spécial). Si votre fonction attend un seul paramètre, la syntaxe peut être la suivante :

       my ($x) = @_;

mais ne peut pas être :

       my $x = @_; #incorrect

Cette ligne est incorrect car, dans ce cas, la variable $x aurait pour valeur le nombre de paramètres (affectation d'un tableau à un scalaire). La syntaxe suivante peut aussi être utile :

       my ($x,@t) = @_;

la variable $x reçoit le premier paramètre et le tableau @t reçoit tous les paramètres restants.

Enfin, une autre écriture que vous verrez souvent dans les programmes Perl est la suivante :

       my $x = shift;

celle-ci s'appuie sur le fait que dans une sous-routine, la fonction shift travaille par défaut sur @_.

L'instruction return met fin à l'exécution de la fonction et on peut lui fournir une expression qui sera alors la valeur de retour de la fonction.

Appel

La fonction ainsi définie peut être appelée au moyen de la syntaxe suivante :

    maJolieFonction(10,20,30);

Dans ce cas, l'éventuelle valeur de retour est ignorée. Pour récupérer cette valeur :

    $v = maJolieFonction(10,20,30);

Il est possible d'omettre les parenthèses lors de l'appel à une fonction :

    maJolieFonction 10,20,30;  # À éviter

mais cela peut créer des ambiguïtés et je vous déconseille donc cette syntaxe.

S'il est possible en Perl d'imposer le nombre d'arguments pour une fonction (nous n'en parlerons pas ici), cela n'est pas fait par défaut. Rien ne nous empêche en effet d'appeler la fonction maJolieFonction précédemment définie avec deux ou quatre arguments, alors qu'elle semble en attendre trois ; si on l'appelle avec deux arguments, la variable $t vaudra undef ; par contre si on l'appelle avec plus de trois arguments, les valeurs suivantes seront ignorées. Mais cette particularité du langage est parfois bien pratique, notamment pour écrire des fonctions à nombre variable d'arguments.

Visibilité des variables

Les variables déclarées au moyen de my dans une fonction ne seront visibles qu'à l'intérieur même de la fonction, dans le code qui suit la déclaration. Dans une fonction, il est possible d'accéder aux variables définies à la 'racine' du programme (c'est-à-dire en dehors de toute fonction) : il s'agit donc de variables globales. Si une variable locale a le même nom qu'une variable globale, cette dernière est masquée par la variable locale :

    my $a = 3;
    my $b = 8;
    my $c = 12;
    sub maJolieFonction
    {
       my $a = 5;
       print "$a\n";     # affiche 5
       print "$b\n";     # affiche 8
       $c = 15;          # modification de la variable globale
       print "$c\n";     # affiche 15
    }
    maJolieFonction();
    print "$a\n";        # affiche 3
    print "$b\n";        # affiche 8
    print "$c\n";        # affiche 15

De manière plus générale, les variables déclarées au moyen de my sont visibles jusqu'à la fin du plus petit bloc qui les englobe. En particulier, dans une fonction...

    sub maJolieFonction2
    {
       my $d = -3;
       if( ... )
       {
          my $d = 4;
          my $e = 8;
          print "$d\n";  # affiche 4
          print "$e\n";  # affiche 8
       }
       print "$d\n";     # affiche -3
       print "$e\n";     # $e n'existe pas ici
    }

Une liste pour valeur de retour

Il est tout à fait possible de faire renvoyer plusieurs scalaires à une fonction, il suffit juste d'utiliser une liste. Voici des exemples de syntaxe de liste renvoyée par des fonctions :

       return ($x,$z);
       return @t;

Dans le second cas, le tableau est converti en liste. Et voici comment il est possible de récupérer ces valeurs :

    @s = fonction(...);
    ($j,$k) = fonction(...);

Ces deux manières de procéder peuvent parfaitement être utilisées chacune dans les deux cas de return pré-cités (ce sont toujours les mêmes règles d'affectation qui s'appliquent).

Premier exemple de fonction

Voici un exemple complet de programme en Perl avec une fonction :

        1  #!/usr/bin/perl -w
        2  use strict;
        3  my $t = "Bonjour Larry";  # variable globale
        4  print "$t\n";             # avec ou sans parenthèses
        5  sub f
        6  {
        7     my ($x,$z) = @_;       # deux arguments attendus
        8     my $m = $x*$z;
        9     printf("%d\n", $m);
       10    return ($x+$z,$m);     # retourne une liste
       11 }
       12 my @t = f(3,5);
       13 print "$t $t[0] $t[1]\n";

Un bon programme Perl commence toujours par les première et deuxième lignes. Si la variable scalaire $t, elle, est globale, en revanche les variables $x, $z et $m sont locales à la fonction. En ligne 12, le tableau @t reçoit pour valeur la liste renvoyée par la fonction. Notez bien qu'il n'y a aucun conflit entre les variables $t et @t ; en effet, l'instruction de la dernière ligne procède d'abord à l'affichage de la variable scalaire $t puis du premier et deuxième éléments du tableau @t (les crochets permettent de savoir qu'il s'agit d'éléments d'un tableau).

Autre exemple : une fonction récursive

Voici un exemple de fonction. Elle est récursive (c'est-à-dire qu'elle fait appel à elle-même) : nous allons calculer la factorielle d'un nombre. Par définition, F(0)=F(1)=1 et F(n)=n×F(n-1) pour tout n supérieur à 1 :

    sub Fact
    {
       my ($n) = @_;
       return 1
          if( $n == 1 || $n == 0 );
       return $n * Fact($n-1);
    }
    print Fact(5)."\n";  # affiche 120

Aussi lisible que dans tout autre langage.

Autres fonctions sur les listes

Vous savez maintenant manipuler des tableaux et des listes, vous savez aussi écrire des fonctions : vous voila armés pour aborder les très puissantes et bien pratiques fonctions de gestion qui suivent.

Joindre les éléments dans une chaîne avec join

La fonction join prend en paramètre un scalaire et une liste ; elle renvoie une chaîne de caractères comportant les éléments de la liste, concaténés et séparés par ce premier paramètre scalaire. Les arguments passés ne sont pas modifiés.

scalaire = join( séparateurliste );

Voici quelques exemples :

Découper une chaîne de caractères en liste avec split

La fonction split prend en paramètre un séparateur et une chaîne de caractères ; elle renvoie la liste des éléments de la chaîne de caractères délimités par le séparateur. Le séparateur est une expression régulière, notion que nous aborderons dans la suite, mais dont le minimum de connaissances suffit à cette fonction ; admettez ici qu'une telle expression est à placer entre slashs (/). Les arguments passés ne sont pas modifiés.

liste = split( /séparateur/, chaîne );

Voici quelques exemples :

Trier une liste avec sort

La fonction sort prend en paramètre un bloc d'instructions optionnel et une liste ; elle renvoie une liste triée conformément au critère de tri constitué par le bloc d'instructions. La liste passée en argument n'est pas modifiée.

liste2 = sort( liste1 );

liste2 = sort( { comparaison } liste1 ); (attention à ne pas mettre de virgule entre le bloc d'instructions et la liste)

Tout au long du tri, le bloc d'instruction sera évalué pour comparer deux valeurs de la liste ; ces deux valeurs sont localement affectées aux variables spéciales $a et $b qui ne sont définies que dans le bloc et sur lesquelles il faut donc effectuer la comparaison. Il faut faire particulièrement attention au fait que s'il existe des variables $a et $b dans le programme elles seront localement masquées par ces variables spéciales (source courante d'erreurs). Le bloc doit être composé d'une expression dont la valeur est :

C'est là qu'entrent en jeu les opérateurs de comparaison cmp et <=> : ils permettent de comparer respectivement les chaînes de caractères selon l'ordre lexical et les nombres selon l'ordre numérique. Si la fonction sort est appelée sans bloc d'instruction, la liste est triée selon l'ordre lexical.

Voici quelques exemples :

Sélectionner des éléments avec grep

La fonction grep prend en paramètre un critère de sélection et une liste ; elle renvoie la liste des éléments correspondant au critère. La liste passée en argument n'est pas modifiée.

Le critère de sélection peut être soit une expression régulière (cas sur lequel nous reviendrons plus tard), soit un bloc d'instructions (cas sur lequel nous allons nous étendre) :

liste2 = grep { sélection } liste1; (attention : pas de parenthèses ni de virgule)

Les éléments renvoyés sont ceux pour lesquels l'évaluation du bloc d'instructions a pour valeur vrai. Durant cette évaluation, chacune des valeurs sera localement affectée à la variable spéciale $_ sur laquelle les tests devront donc être effectués.

Voici quelques exemples :

En contexte scalaire, la fonction grep renvoie le nombre d'éléments qui correspondent au critère : $n = grep { ... } @t;

La syntaxe de grep comportant une expression régulière est la suivante :

liste2 = grep( /regexp/, liste1 );

En quelques mots, les éléments renvoyés seront ceux qui correspondront à l'expression régulière. Par exemple @s = grep( /^aa/, @t ); affecte à @s les éléments de @t qui commencent par deux lettres a. Plus d'explications sur les expressions régulières seront données dans la suite.

J'ai affirmé que la liste d'origine n'était pas modifiée, mais il vous est possible de le faire. Si, durant la sélection, vous affectez une valeur à $_, la liste sera modifiée. Mais cela est sans doute une mauvaise idée de modifier la liste passée en paramètre d'un grep car la fonction map est faite pour cela.

Appliquer un traitement à tous les éléments avec map

La fonction map prend en paramètre un bloc d'instructions et une liste ; elle applique le bloc à chacun des éléments de la liste (modification possible de la liste) et renvoie la liste constituée des valeurs successives de l'expression évaluée.

liste2 = map( { expression } liste1 ); (attention à ne pas mettre de virgule entre le bloc d'instructions et la liste)

La variable spéciale $_ vaut localement (dans le bloc d'instructions) chaque élément de la liste. La valeur de la dernière expression du bloc sera placée dans la liste résultat.

Voici quelques exemples :

Dans les exemples qui précèdent, la liste d'origine n'est pas modifiée (sauf dans le dernier exemple où elle peut l'être dans la fonction). Voici un exemple de modification de liste :

map( { $_*=4 } @t ); Tous les éléments de @t sont multipliés par quatre.

Un exemple : le crible d'Ératosthène

Nous allons ici illustrer l'usage des listes et des tableaux par un exemple mathématique : le crible d'Ératosthène. Cet algorithme permet de calculer tous les nombres premiers inférieurs à un nombre donné n.

Son principe est le suivant : nous construisons tout d'abord la liste de tous les entiers de 2 à n. Ensuite, à chaque itération, nous supprimons de la liste tous les multiples du premier nombre de la liste et signalons ce premier nombre comme étant premier. Au premier tour de boucle, je supprime tous les nombres pairs et dis que 2 est premier. Au suivant, je supprime tous les multiples de 3 et affirme que 3 est premier. Au tour suivant, c'est le 5 qui est au début de la liste (4 étant multiple de 2, il a déjà été supprimé), j'enlève de la liste les multiples de 5 et annonce la primalité de 5 etc ... L'algorithme se termine lorsque la liste est vide, j'ai alors déterminé tous les nombres premiers inférieurs à n.

Voici la fonction réalisant cet algorithme en Perl :

    sub Crible
    {
       my ($n) = @_;

       # Liste initiale :
       my @nombres = (2..$n);
       # Liste des nombres premiers trouvés :
       my @premiers = ();

       # Tant qu'il y a des éléments (un tableau
       # en contexte booléen vaut faux s'il est vide) :
       while( @nombres )
       {
          # On extrait le premier nombre
          my $prem = shift @nombres;

          # On indique qu'il est premier
          push @premiers, $prem;

          # On supprime ses multiples
          @nombres = grep { ( $_ % $prem )!=0 } @nombres;
       }

       # On renvoie la liste des nombres premiers
       return @premiers;
    }

Quiconque a déjà réalisé cet algorithme en C ou C++ comprendra la joie que cette concision procure ...

L'auteur

Sylvain Lhullier sylvain@lhullier.org http://sylvain.lhullier.org/

À l'Université de Marne-la-Vallée (http://www.univ-mlv.fr/), il est chargé chaque année d'un module complet d'enseignement en maîtrise informatique ; ce module porte sur des sujets tels que Perl, Perl/Tk, Perl/DBI, Apache, CGI/Perl et consiste en dix semaines d'un cours en amphithéatre et de trois travaux dirigés, ainsi qu'en un examen final et un projet.

Il a travaillé pour Linagora (http://www.linagora.com/) comme consultant formateur et développeur ; il intervenait principalement pour des projets et prestations concernant le développement (Perl, Java, C++, programmation système, PHP, Apache, MySQL, XML etc.).

Il a développé chez feue-Atrid des projets bâtis en Perl (LogTrend, Mioga) et publiés sous GPL.

Il a donné une conférence "Perl : pour quoi faire ?" lors du salon LinuxSolutions de janvier 2004.

Entre autres associations, il est membre et administrateur de l'association "Les Mongueurs de Perl" dont l'objet est de promouvoir le langage Perl en France par des réunions, des conférences etc (http://www.mongueurs.net/). Il y coordonne le groupe de travail "Articles" dont le but est de publier un article dans la presse francophone technique, notamment dans GNU/Linux & Hurd Magazine France (http://www.linuxmag-france.org/) chaque mois. L'auteur tient à remercier très chaleuseusement les autres membres de l'association pour leur aide, leur soutien et les relectures effectuées.

[IE7, par Dean Edwards] [Validation du HTML] [Validation du CSS]