An Introduction to Perl by HC12092920322

VIEWS: 0 PAGES: 60

									                    Perl

Sources:
http://www.cs.utk.edu/~plank/plank/classes/cs494/
   notes/Perl/lecture.html
Randal L. Schwartz and Tom Christiansen,
  “Learning Perl” 2nd ed., O’Reilly
Randal L. Schwartz and Tom Phoenix,
  “Learning Perl” 3rd ed., O’Reilly
Dr. Nathalie Japkowicz, Dr. Alan Williams



                                       CSI 3525, Perl, page 1
                             Perl
- Perl est inspiré du langage C et d’interpréteurs de
  commande Unix comme sed, awk, et sh.

- La facilitée de manipulation de texte, fichiers et processus
  par Perl font qu’il est populaire pour le prototypage rapide,
  les outils de système d’exploitation, l’accès aux bases de
  données, la gestion de réseaux, et la programmation pour
  le web.

- Populaire pour l’administration de systèmes et les scriptes
  CGI.




                                           CSI 3525, Perl, page 2
                          Survol (1)

• Perl = Practical Extraction and Report Language
  Aussi (Pathologically Eclectic Rubbish Lister )

• Un langage puissant et générale.

• Utile pour des programmes “quick and dirty”.

• Développé by Larry Wall, sans excuse pour le
  manque d’élégance.

• Facile à apprendre pour quelqu’un qui connaît C et
  Unix.


                                                    CSI 3525, Perl, page 3
                         Survol (2)
• Perl n’est pas tout à fait un langage de haut niveau, il se
  trouve entre C ou C++ et les shell scripts (des langages
  qui ajoutent des structures de contrôle à l’interpréteur de
  commande Unix) tel que sh, sed et awk.
   – awk : langage qui permet de lire des patrons et exécuter
     des commandes selon ce qui est lu.
   – sed : permet de modifier des fichiers texte
   – sh : peut exécuter plusieurs instructions de l’interpréteur
     de commandes, contenu dans un fichier (comme les
     fichiers batch de DOS).



                                            CSI 3525, Perl, page 4
                 Avantages de Perl (1)
• Selon certains, Perl combine les meilleurs aspects de:
      Unix/Linux shell programming,
      Les commandes sed, grep, awk et tr,
      C,
      Cobol.
- tr : permet d’éliminer ou de substituer des caractères dans un
    texte.
• Les shell scripts sont normalement écrit dans plusieurs petits
  fichiers referant les uns aux autres. Perl permet les même
  résultats avec un seul programme dans un fichier.

                                           CSI 3525, Perl, page 5
              Avantages de Perl (2)

• Perl incorpore des capacité puissante de traitement
  des expressions régulières. Ceci permet un
  traitement de chaînes de caractères très rapide,
  fiable et flexible, surtout pour le filtrage de texte
  (pattern matching).
• Conséquemment, Perl est particulièrement utile pour
  le traitement de chaînes de caractères.
• En fait, Perl à permis de rapidement traduire
  plusieurs documents texte en HTML au début des
  années 1990,permettant au web de prendre
  beaucoup d’expansion.

                                       CSI 3525, Perl, page 6
               Désavantages de Perl

• Ce n’est pas un langage élégant. Plutôt une combinaison
  de plusieurs éléments provenant de différent langages et
  outils.
• Contient plusieurs façons différentes d’accomplir la même
  chose (plusieurs instructions de boucle ou expressions
  conditionnelles).
  un langage peu lisible
• Les programmes ne sont pas compilé en fichier binaires,
  mais sont plutôt exécuté directement à partir du texte.
  Ainsi, il est difficile de commercialiser des programmes
  développé en Perl.

                                        CSI 3525, Perl, page 7
        Perl: ressources et versions
• http://www.perl.org vous dira tout ce que vous
  avez toujours voulu savoir sur le Perl.

• Ce que nous allons voir dans ce cours est le
  Perl 5.

• Perl 5.8.0 a été déployé en Juillet 2002.

• Perl 6 (http://dev.perl.org/perl6/) est la
  prochaine version, qui n’est pas encore prête,
  mais qui sera bientôt déployée. Le premier livre
  sur le Perl 6 se vend déjà
  (http://www.oreilly.com/catalog/perl6es).

                                      CSI 3525, Perl, page 8
Scalaires: chaînes de caractères et nombres
Les scalaires de sont pas n’ont pas à être déclaré.

Perl comprend à partir du contexte.

Fichier hellos.pl:
#! /usr/bin/perl
print "Hello" . " " . "world\n";
print "hi there " . 2 . " worlds!" ."\n";
print (("5" + 6) ." eggs\n" . " in " . " 3 + 2 = " . ("3" + "2") . "
baskets\n" );

            % hellos.pl                                    invoque Perl
            Hello world
            hi there 2 worlds!
            11 eggs
             in 3 + 2 = 5 baskets

                                                      CSI 3525, Perl, page 9
                      Variables scalaire

      Les variables scalaires commencent par un ‘$’. Elles
      n’ont pas à être déclarée.


% cat scalar.pl
#! /usr/bin/perl
$i = 1;
$j = "2";                                        % scalar.pl
print "$i and $j \n";
                                                 1 and 2
$k = $i + $j;
                                                 3
print "$k\n";
                                                 12
print $i . $j . "\n";
                                                 $k\n
print '$k\n' . "\n";

                                                CSI 3525, Perl, page 10
               Guillemets et substitution
Supposons $x = 3
Les apostrophes ' ' ne permettent aucune substitutions sauf pour
les séquences d’échappement \\ et \'.
    print('$x\n'); donne $x\n et pas de nouvelle ligne.
Les guillemets " " permettent la substitution de variables comme
$x et des séquences d’échappement comme \n (newline).
    print("$x\n"); donne 3 (avec la nouvelle ligne).
Les accents graves ` ` permettent les substitution, et tentent
d’exécuter les commandes de système résultant. Ils retournent la
sortie du système.
        $y = `date`; print($y); donne
        Mon Aug 12 14:48:24 EDT 2002

                                          CSI 3525, Perl, page 11
           Instructions de contrôle: if, else, elsif
% cat names.pl
#! /usr/bin/perl
$name = <STDIN>;                        Input standard
chomp($name);                           élimine le newline
if ($name gt 'fred')
    {print "$name follows 'fred'\n";}
elsif ($name eq 'fred') {
   print "both names are 'fred'\n";}
else {
   print "$name precedes 'fred'\n";}
  % names.pl
  Stan                                   input de l’utilisateur
  'Stan' precedes 'fred'                 Output de Perl
  % names.pl
  stan
  'stan' follows 'fred'

                                        CSI 3525, Perl, page 12
    Instructions de contrôle : boucles (1)
% cat oddsum_while.pl
#! /usr/bin/perl
# Add up some odd numbers
$max = <STDIN>;
$n = 1;
while ($n < $max) {
 $sum += $n;
 $n += 2; } # On to the next odd number
print "The total is $sum.\n";

% oddsum_while.pl
10                                            Input de l’utilisateur
Use of uninitialized value at oddnums.pl line
6, <STDIN> chunk 1. (the $sum)                    warning
The total is 25.                                  Output de Perl

                                          CSI 3525, Perl, page 13
      Instructions de contrôle : boucles (2)

• Les commentaires débutent par #

• On peut utiliser une variable sans l’initialiser (comme
  $sum). Elle sera initialiser à 0 si elle est d’abord utilisée
  comme un nombre, ou à la chaîne vide "" si elle est
  d’abord utilisée comme chaîne de caractères. En fait,
  c’est toujours undef, qui est converti selon le contexte.

• Le flag ‘-w’ demande à Perl d’indiquer les warnings.

• Il y a plusieurs autres instructions de boucles…



                                           CSI 3525, Perl, page 14
   Instructions de contrôle : boucles (3)

% cat oddsum_until.pl
#! /usr/bin/perl
# Add up some odd numbers
$max = <STDIN>;
$n = 1;
$sum = 0;
until ($n >= $max) {
 $sum += $n;
 $n += 2; } # On to the next odd number
print "The total is $sum.\n";
% oddsum_until.pl
10
The total is 25.

                                 CSI 3525, Perl, page 15
 Instructions de contrôle : boucles (4)
% cat oddsum_for.pl
#! /usr/bin/perl
# Add up some odd numbers
$max = <STDIN>;
$sum = 0;
for ($n = 1 ; $n < $max ; $n += 2) {
 $sum += $n; }
print "The total is $sum.\n";
% oddsum_for.pl
10
The total is 25.

Il y a aussi do-while et do-until.


                                     CSI 3525, Perl, page 16
Instructions de contrôle : boucles (5)

% cat oddsum_foreach.pl
#! /usr/bin/perl
# Add up some odd numbers
$max = <STDIN>;
$sum = 0;
foreach $n ( (1 .. $max) ) {
 if ( $n % 2 != 0 ) { $sum += $n; } }
print "The total is $sum.\n";
% oddsum_foreach.pl
10
The total is 25.



                                  CSI 3525, Perl, page 17
                      Comparaison avec C


             C                      Perl
même chose   if () { ... }          if () { ... }
différent    } else if () { ... }   } elsif () { ... }
même chose   while () { ... }       while () { ... }
même chose   for (aa;bb;cc) {...}   for (aa;bb;cc) {...}
                                    foreach $v (@array){... }
différent    break                  last
différent    continue               next
similaire    0 est FALSE            0, "0", and "" sont FALSE
similaire    != 0 est TRUE          Tout ce qui n’est pas FALSE est
                                    TRUE

                                                CSI 3525, Perl, page 18
                Listes et tableaux

• Une liste est une collection ordonnée de scalaires.
  Un tableau est une variable contenant une liste.
• Chaque élément est un scalaire indépendant. Une
  liste peut contenir des nombres, chaînes de
  caractères, undef, ou tout mélange de différent
  scalaires.
• Pour utiliser un tableau, places un ‘$’ devant et
  utilises les ‘[ ]’ (ex: $a[2]).
• Pour accéder au tableau en entier: @.
• On peut copier un tableau, et utiliser les opérateurs
  sort, reverse, push, pop, split.

                                      CSI 3525, Perl, page 19
             Examples de tableaux (0)

% cat somme_de_carre.pl
#! /usr/bin/perl
$s = <STDIN>;
for ($i=0; $i<$s; $i+=1){
  $a[$i] = $i*$i;
}
print @a;
print "\n";
% somme_de_carre.pl
4
0



                                CSI 3525, Perl, page 20
    Paramètre de l’appel au programme
         (comand-line argument)
Si un programme Perl écrit dans un fichier myProg.pl
est invoqué par la commande:

myProg.pl -o big.basket.htm candle.htm

La liste @ARGV , prédéfinie dans Perl, contient alors:

   ('-o', 'big.basket.htm', 'candle.htm')

Ces éléments peuvent être accédés par:
      $ARGV[0]
      $ARGV[1]
      $ARGV[2]


                                      CSI 3525, Perl, page 21
              Exemples de tableau (1)
% cat arraysort.pl
#! /usr/bin/perl
 $i = 0;
 while ($k = <STDIN>) {
   $a[$i++] = $k; }
 print "===== sorted =====\n";
 print sort(@a);
 % arraysort.pl
 Nathalie
 Frank                           ===== sorted =====
 hello                           Frank
 John                            John
 Zebra                           Nathalie
 notary                          Zebra
 nil                             hello
                                 nil
                                 notary
control-D (pour arrêter la boucle)
                                    CSI 3525, Perl, page 22
                   Exemples de tableau (2A)
Inverser un texte (lignes entières).
% cat whole_rev.pl
#! /usr/bin/perl
while ($k = <STDIN>) {
 push(@a, $k); }
print "== reversed ==\n";
while ($oldval = pop(@a)) {
 print $oldval; }                      % whole_rev.pl
                                       abcd
                                       ef
                                       ghi
                      control-D        == reversed ==
                                       ghi
                                       ef
                                       abcd


                                       CSI 3525, Perl, page 23
                    Exemples de tableau (2B)
                     Inverser les lignes d’un texte
 % cat each_rev.pl                                       % each_rev.pl
 #! /usr/bin/perl
 while($k = <STDIN>) {                                   a bc d efg
  @a = split(/\s+/, $k);                                 efg d bc a
  $s = "";                                               hi j
  for ($i = @a;                                          j hi
     $i > 0;                                             klm nopq st
     $i--) {
                                                         st nopq klm
   $s = "$s$a[$i-1] "; }
  chop($s);
  print "$s\n"
 }                                                    control-D
split sépare les lignes aux espaces       output
chop élimine le dernier caractère (un espace)
                                                   CSI 3525, Perl, page 24
          Exemples de tableau (3)
Inverser les lignes
print reverse(<STDIN>);
Inverser chaque ligne
while($k = <STDIN>) {
  $s = "";
  foreach $i
   (reverse(split(/\s+/, $k))) {
     $s = "$s$i "; }
  chop($s);
  print "$s\n";
}

                                   CSI 3525, Perl, page 25
                  Une digression:
         La variable défaut favorite du Perl
                                      par défaut,
while(<STDIN>) {                    Perl lit dans $_
  $s = "";
  foreach $i
   (reverse(split(/\s+/, $_))) {
     $s = "$s$i "; }
  chop($s); print "$s\n";
}
                                 par défaut,
while(<STDIN>) {                Perl sépare $_
  $s = "";                       également!
  foreach $i
   (reverse(split(/\s+/ ))) {
     $s = "$s$i "; }
  chop($s); print "$s\n";
}
                                     CSI 3525, Perl, page 26
                        Haches

• Un hache est semblable à un tableau, mais au lieu des
  entiers comme index, un hache peut utiliser n’importe quoi
  comme clef. Les accolades { } sont utilisées au lieu des
  parenthèses carrées [ ].
• Le nom officiel est tableau associatif (implémenté par
  hachage).
• Les clefs et valeurs peuvent être n’importe quel scalaire. Les
  clefs sont toujours convertie en chaînes de caractères.
• Pour référer au hache en entier, on place un % devant.
• Si un hache est assigné à un tableau, il devient une liste.


                                           CSI 3525, Perl, page 27
                 exemple I (1)
% cat hash_array.pl
#! /usr/bin/perl
%some_hash =
  ("foo", 35, "bar", 12.4, 2.5, "hello",
   "wilma", 1.72e30, "betty", "bye\n");
@an_array = %some_hash;
print "@an_array\n========\n";
foreach $key (keys %some_hash) {
  print "$key: ";
  print delete $some_hash{$key};
  print "\n";
}

                                     CSI 3525, Perl, page 28
                       exemple I (2)
% hash_array.pl
betty bye
wilma 1.72e+30 foo 35 2.5 hello bar 12.4
========
betty: bye
                           %some_hash =
                             ("foo", 35, "bar", 12.4, 2.5, "hello",
                              "wilma", 1.72e30, "betty", "bye\n");
wilma: 1.72e+30
                           @an_array = %some_hash;
foo: 35                    print "@an_array\n========\n";
2.5: hello                 foreach $key (keys %some_hash) {
                             print "$key: ";
bar: 12.4                    print delete $some_hash{$key};
                             print "\n";
                           }


                                                  CSI 3525, Perl, page 29
              exemple II
% cat hash_arrows.pl
#! /usr/bin/perl
my %hash =
 ( "a" => 1, "b" => 2, "c" => 3);
foreach $key (sort keys %hash) {
  $value = $hash{$key};
  print "$key => $value\n";
}
% hash_arrows.pl
a => 1
b => 2
c => 3


                             CSI 3525, Perl, page 30
               Un petit interlude:
             l’opérateur diamand

% cat concat
#!/usr/bin/perl -w
while ( <> ) { print $_; }
% cat a
one-a              <> Fait une boucle sur tous les
two-a
% cat b            fichiers listés dans les arguments
three-b            de la ligne de commande
four-b
five-b                    % concat a b >c
% concat a b              % cat c
one-a                     one-a
two-a                     two-a
three-b                   three-b
four-b                    four-b
five-b                    five-b
                                 CSI 3525, Perl, page 31
     exemple III: Fréquence de caractères

% cat frequency.pl
#! /usr/bin/perl
while (<>) {
  # loop over characters in input line
  foreach $c (split //) {
   # Increment $count of $c
   ++$count{$c};
}}
# end of input, print %count
for $c (sort keys %count) {
  print "$c\t$count{$c}\n";
}



                                         CSI 3525, Perl, page 32
          Fréquence de caractères (2)

% frequency.pl               \n            8
Nathalie                  space            2
Fran                                 1      2
                                     F      2
hello                                J      2
John                                 N      2
rather                               a      5
                                     e      3
Notary                               h      4
F1                                   i     1
                                     l     3
J1                                   n      2
                                     o      3
     ^D                              r     4
                                     t     3
                                     y      1

                                  CSI 3525, Perl, page 33
                       Sous-
                    programmes
• Un sous-programme est une fonction définie par l’utilisateur.
  La syntaxe est très simple. La sémantique aussi.

       #! /usr/bin/perl
       sub max {
         if ( $x > $y ) { $x } else { $y }
       }
       $x = 10; $y = 11;
       print &max . "\n";

 • Il n’y a pas d’arguments; le script accède a deux
   variables globales. L’appel de sous-programme s’indique
   avec un &. La valeur retournée est celle de la dernière
   expression évaluée.

                                         CSI 3525, Perl, page 34
                      Sous-
                 programmes (2)
Quelques règles utiles.
• Vous pouvez placer vos définitions n’importe où dans
  vos fichiers. Néanmoins, il est recommandé de les
  mettre au début.
• Perl utilise toujours la dernière définition dans le fichier—
  les précédentes sont ignorées.
• Certains éléments de syntaxe sont optionnels.
    • Le & peut parfois être omit (mais cela n’est pas une
      bonne idée)
    • L’opérateur return peut précéder une valeur a
      retourner (cela peut être utile):
      if ( $x > $y ) { return $x }
      else { return $y }
                                         CSI 3525, Perl, page 35
                    Sous-
               programmes (3)
• Il est clair que l’utilisation seule de variables globales
  est trop limitée. Les sous-programmes peuvent prendre
  des arguments et les utiliser grâce a une variable de
  liste @_ prédéfinie ou ses éléments $_[0], $_[1], etc…

     #! /usr/bin/perl
     sub max {
       if ( $_[0] > $_[1] ) { $_[0] }
       else { $_[1] }
     }
     print &max ( 12, 13 ) . "\n";


                                      CSI 3525, Perl, page 36
                    Sous-
               programmes (4)
• $_[0], $_[1] ne sont pas faciles à utiliser. Vous
  pouvez les re-nommer localement en utilisant
  l’opérateur my—Il crée les variables privées d’un sous-
  programme. Ici, on déclare deux variables de ce type
  et on les initialise immédiatement.

    #! /usr/bin/perl
    sub max {
      my ( $a, $b ) = @_;
      if ( $a > $b ) { $a } else { $b }
    }
    print &max ( 15, 14 ) . "\n";

                                      CSI 3525, Perl, page 37
                     Sous-
                programmes (5)
• Mais: ceci n’est pas un calcul du maximum bien conçu:

     #! /usr/bin/perl
     sub max {
       my ( $a, $b ) = @_;
       if ( $a > $b ) { $a } else { $b }
     }
     print &max ( 16, 19, 23 ) . "\n";
     print &max ( 26 ) . "\n";


• Il produit 19 (23 est ignoré) et 26 (la deuxième valeur
  est undef, ce qui veut dire 0)


                                        CSI 3525, Perl, page 38
                     Sous-
                programmes (6)
• On pourrait stopper le sous-programme si le nombre
  d’arguments était le mauvais. L’opérateur (très utile) die
  le fait pour nous.
 #! /usr/bin/perl
 sub max {
  if ( @_ != 2 ) {
    die "max needs two arguments: @_\n";
  }
     my ( $a, $b ) = @_;
     if ( $a > $b ) { $a } else { $b }
 }
 print &max ( 16, 19, 23 ) . "\n";
Le script est stoppé après avoir imprimé:
max needs two arguments: 16 19 23

                                       CSI 3525, Perl, page 39
                   Sous-
              programmes (7)
      • On peut choisir de n’avoir qu’un warning
        avec l’opérateur warn.
#! /usr/bin/perl
sub max {
 if ( @_ != 2 ) {
   warn "max needs two arguments: @_\n";
 }
    my ( $a, $b ) = @_;
    if ( $a > $b ) { $a } else { $b }
}
print &max ( 16, 19, 23 ) . "\n";
    Le script imprime:
    max needs two arguments: 16 19 23
    19

                                     CSI 3525, Perl, page 40
                         Sous-
                    programmes (8)
• De toutes façons, ce n’est pas une mauvaise idée de
  généraliser max en lui permettant de prendre n’importe quel
  nombre d’arguments.
   #! /usr/bin/perl
   sub max {
     my ( $curr_max ) = shift @_;
     foreach ( @_ ) {
       if ( $_ > $curr_max ) { $curr_max = $_; }
     }
     $curr_max
   }
   print &max ( 15, 14 ) . "\n";
   print &max ( 16, 19, 23 ) . "\n";
   print &max ( 26 ) . "\n";

                                          CSI 3525, Perl, page 41
                       Sous-
                  programmes (9)
       • Cela marche même pour les listes vides.

#! /usr/bin/perl
sub max {
  my ( $curr_max ) = shift @_;
  foreach ( @_ ) {
    if ( $_ > $curr_max ) { $curr_max = $_; }
  }
  $curr_max
}
$z = &max ( );
if ( defined $z ) { print $z . "\n"; }
else { print "undefined\n"; }

                                          CSI 3525, Perl, page 42
            Expressions régulières (1)
• Une expression régulière (patron) décrit une classe de
  chaînes de caractères.
• Une chaîne de caractères peut matcher ou non le patron.
• Le patron le plus simple est un seul caractère.
• Une classe de caractères est écrite entre parenthèses
  carrées:
       [01234567]           un chiffre octal
       [0-7]                un chiffre octal
       [0-9A-F]             un chiffre hexadécimale
       [^A-Za-z]            pas une lettre
       [0-9-]        un chiffre décimale ou un moins (-)


                                       CSI 3525, Perl, page 43
          Expressions régulières (2)

• Metacaractères:
   .          (point) n’importe quel caractère sauf \n
• Ancres:
   ^          le debout d’une chaîne de caractères
   $          la fin
• Multiplicateurs:
   *          répète ce qui précède 0 fois ou plus
   +          répète ce qui précède 1 fois ou plus
   ?          ce qui précède devient optionnel
   {n} répète n fois
   {n, m}     répète de n à m fois (n <= m)
   {n,}       répète n fois ou plus

                                       CSI 3525, Perl, page 44
           Expressions régulières (3)

• L’opérateur Booléen =~ essaye de matcher une
  chaine avec une expression régulière écrite
  entre deux barres inclinées (slashes).

     $x = "01239876AGH";
     if ( $x =~ /^0[1-9]{4,}/ )
     { print "yes1\n"; }
     if ( $x =~ /[A-Z]{3}$/ )
     { print "yes2\n"; }
     if ( $x =~ /^.*[A-Z]{4}$/ )
     { print "yes3\n"; }


                                 CSI 3525, Perl, page 45
           Expressions régulières (4)
• L’opérateur booléen =~ matche une chaîne à un patron,
  écrit entre barres obliques /.
• Les patrons peuvent être regroupes entre parenthèses
  (le patron en entier devient un item).
• Les alternatives sont séparées par la barre |.

   $x = "01239876AGH";
   if ( $x =~ /([0-9]{4}|[A-Z]{3}){2,}/ )
   { print "yes4\n"; }
   if ( $x =~ /(0?|4)(5|[1abc]{1,})/ )
   { print "yes5\n"; }

                                            to be explained shortly

                                            CSI 3525, Perl, page 46
              Expressions régulières (5)
• La précédence des éléments d’un patron:
       parenthèses           ()
       multiplicateurs       * + ? {n}
       séquence, ancres ^ $
       alternatives          |
• Certaines classes de caractères sont prédéfinies:
                                     classe C non C
       chiffres                      \d       \D
       caractères [a-zA-Z0-9_]+ \w            \W
       espaces blanc                 \s       \S
Autre ancres:
       frontières entre les mots \b           \B

                                        CSI 3525, Perl, page 47
                              Exemple (1)
$i = "Jim";
                                 match
$i =~ /Jim/;                     oui
$i =~ /J/;                       non
$i =~ /j/;                       non
$i =~ /j/i;                      oui
$i =~ /\w/;                      oui
$i =~ /\W/;                      non
La différence majuscule-minuscule est ignorée si postfix i est utilisé.


                                                    CSI 3525, Perl, page 48
                   Exemple (2)

$j = "JjJjJjJj";


$j =~ /j*/;        oui: pour n’importe quoi
$j =~ /j+/;        oui: matche le premier j
$j =~ /j?/;        oui: matche le premier j
$j =~ /j{2}/;      non
$j =~ /j{2}/i;     oui: ignore majuscule-minuscule
$j =~ /(Jj){3}/;   oui

                                   CSI 3525, Perl, page 49
                      Exemple (3)
$k = "Boom Boom, out go the lights!";

$k =~ /Jim|Boom/;           oui: matche Boom
$k =~ /(Boom){2}/;          non: un espace entre Booms
$k =~ /(Boom ){2}/;         non: la virgule
$k =~ /(Boom\W){2}/;        oui
$k =~ /\bBoom\b/;           oui: les mots sont séparés
$k =~ /\bBoom.*the\b/;      oui
$k =~ /\Bgo\B/;             non: "go" est un mot
$k =~ /\Bgh\B/;             oui: le "gh" dans "lights"

                                      CSI 3525, Perl, page 50
                Substitution d’expressions
                      régulières (1)
On peut modifier une variable de type string en appliquant
   une substitution.
L’opérateur est =~ et la substitution est écrite comme il suit:

  s/pattern1/pattern2/
$v = "a string to play with";
$v =~ s/^\w+/just a single/;
print "$v\n";
just a single string to play with

                                         CSI 3525, Perl, page 51
         Substitution d’expressions
               régulières (2)
Les patrons matchés sont sauvegardés dans les
variables préconstruites $1, $2, $3 etc. Ces variables
gardent leurs valeurs jusqu’à l’opération de match
suivante. Chaque paire de parenthèses d’un patron
correspond à une variable “de mémoire”
# $v == "just a single string to play with"
$v =~ s/(\b\w*\b)(.*)/'$1'$2/;
print "$v\n";
print "$2, $1 $1\n";
'just' a single string to play with
 a single string to play with, just just
                                    CSI 3525, Perl, page 52
         Substitution d’expressions
               régulières (3)
Une substitution peut être appliquée à toutes les
incidences du patron, c’est à dire, globalement:
s/pattern1/pattern2/g
# $v == "'just' a single string to play with"
$v =~ s/\b\w*\b/word/g;
print "$v\n";
'word' word word word word word word
$v =~ s/\b\w*\b$/last/;
print "$v\n";
'word' word word word word word last

                                       CSI 3525, Perl, page 53
           Substitution d’expressions
                 régulières (4)
Les parenthèses utilisées comme de la mémoire peut aider à
construire des patrons puissants avec “répétition instantanée”.
On peut utiliser \1, \2 etc. pour les sous-chaines matchées.

  $v = "This is a double double word.";
  $v =~ s/(\b\w+\b) \1/\1/;
  print "$v\n";
  This is a double word.
  $v = "This is a triple triple triple word.";
  $v =~ s/(\b\w+\b) \1 \1/\1/;
  print "$v\n";
  This is a triple word.
                                           CSI 3525, Perl, page 54
                    Substitution d’expressions
                          régulières (5)
Voici un exemple plus réaliste (le devoir de l’année dernière). Vous
    aurez sûrement besoin d’explications:discussion en classe.
   $Day = '0[1-9]|[12][0-9]|3[01]|[1-9]';
   $Month = '0[1-9]|1[012]|[1-9]';
   # Year number up to 31 must have a leading zero or two.
   $Year = '[0-9]{4}|[0-9]{3}|3[2-9]|[4-9][0-9]';
   while(<>){
     # Find all dates, selecting and reinserting the context.
     # $1 and $6 match the context. Superfluous digits,
     # as 43 and 55 in 432001-01-2255, belong in the context.
     # "Dates" such as April 31 or February 30 are allowed.
     # There are no provisions for leap years.
     s/(\D*)(($Year)-($Month)-($Day))(\D|.*$)/$1<date>$2<\/date>$6/g;
     s/(\D*)(($Day)-($Month)-($Year))(\D|.*$)/$1<date>$2<\/date>$6/g;
     print $_;
   }



                                                             CSI 3525, Perl, page 55
                   Substitution d’expressions
                         régulières (6)
                On l’exécute sur un exemple, juste pour
                      montrer comment il marche.

                                          DATA

Both 12-09-2000 and 25-8-324 are good dates,

but 30-14-1955 and 10-10-10 are not. OTOH, 10-10-010 is.

                                        RESULTS

Both <date>12-09-2000</date> and <date>25-8-324</date> are good dates,

but 30-14-1955 and 10-10-10 are not. OTOH, <date>10-10-010</date> is.




                                                           CSI 3525, Perl, page 56
             Il reste à voir…
• Variables prédéfinies
• Plus sur les listes, et haches
• Plus sur les expressions régulières
• Traitement de fichier
• Traitement de répertoires
• Traitement de processus
• Bases de données
• Programmation CGI

                                   CSI 3525, Perl, page 57
          Erreurs fréquentes (1)

Vient de « Programming Perl », page 361.
1. Tester « d’un coup » plutôt que de façon
   incrémentale.
2. Ne pas afficher les résultat temporaires pour
   vérifier le progrès
3. Ne pas utiliser le switch -w pour trouver des
   erreurs typographiques.
4. Oublier $, @ ou % devant une variable.
5. Oublier le ; à la fin des lignes.
6. Oublier les { } autours d’un bloc.

                                       CSI 3525, Perl, page 58
           Erreurs fréquentes (2)

7. (), {}, [], "", '', ``, <> non équilibrés.
8. Confusion entre '' et "", ou / et \.
9. Utiliser == plutôt que eq, != plutôt que ne, =
   plutôt que ==, …
    •   ('White' == 'Black') et ($x = 5) sont évalué
        comme (0 == 0) et (5), donc true!
10. Utiliser "else if" plutôt que "elsif".
11. Placer une virgule après le fichier dans une
    expression print.


                                         CSI 3525, Perl, page 59
                   Erreurs fréquentes (3)
12.Ne pas « chopper » l’output des accents graves `date` ou
   l’input:
        print "Enter y to proceed: ";
        $ans = <STDIN>;
        chop $ans;
        if ($ans eq 'y') { print "You said y\n";}
        else { print "You did not say 'y'\n";}
13.Oublier que les indexes commencent par 0, et non 1.
14.Utiliser $_, $1, ou d’autres variables prédéfinie, puis
   modifier le code d’une manière qui les affecte indirectement.
15.Oublier que les expressions régulières sont gloutonnes,
   recherchant le plus long match, et non le plus court.


                                          CSI 3525, Perl, page 60

								
To top