view release on metacpan or  search on metacpan

FR/perlop.pod  view on Meta::CPAN

C<$1>, C<$2>, etc. sont aussi mises à jours ce qui diffère du comportement de
Perl 4.) Lorsqu'il n'y a pas de parenthèses dans le motif, la valeur retournée
est la liste C<(1)> en cas de succès. Qu'il y ait ou non de parenthèses, une
liste vide est retournée en cas d'échec.

S<Exemples :>

    open(TTY, '/dev/tty');
    <TTY> =~ /^y/i && foo();    # appel de foo si désiré

    if (/Version: *([0-9.]*)/) { $version = $1; }

    next if m#^/usr/spool/uucp#;

    # le grep du pauvre
    $arg = shift;
    while (<>) {
        print if /$arg/o;       # compile une seule fois
    }

    if (($F1, $F2, $Etc) = ($foo =~ /^(\S+)\s+(\S+)\s*(.*)/))

Ce dernier exemple découpe $foo en trois parties (le deux premiers mots et le
reste de la ligne) et les affecte à $F1, $F2 et $Etc. La condition est vraie
si au moins une des variables est affectée, c.-à-d. si le motif est reconnu.

Le modificateur C</g> spécifie une recherche globale du motif -- c'est à dire
la recherche d'autant de correspondances que possible dans la chaîne. Le
comportement dépend du contexte. Dans un contexte de liste, c'est la liste de
toutes les sous-chaînes reconnues par les sous-motifs (entre parenthèses) du
motif qui est retournée. En l'absence de parenthèses, c'est la liste de toutes
les chaînes correspondant au motif qui est retournée, comme si il y avait des
parenthèses autour du motif lui-même.

Dans un contexte scalaire, chaque exécution de C<m//g> trouve la prochaine
correspondance et retourne vrai si il y a correspondance et faux si il n'y en
a plus. La position après la dernière correspondance peut-être lue et modifiée
par la fonction pos(); voir L<perlfunc/pos>. Normalement, un échec de la
recherche réinitialise la position de recherche au début de la chaîne sauf si
vous ajoutez le modificateur C</c> (par ex. C<m//gc>). La modification de la
chaîne sur laquelle à lieu la recherche réinitialise aussi la position de
recherche.

Vous pouvez mélanger des reconnaissances C<m//g> avec des C<m/\G.../g>
où C<\G> est l'assertion de longueur nulle qui est reconnue à la
position exacte où, si elle existe, s'est arrêtée la précédente
recherche C<m//g>. Sans le modificateur C</g>, l'assertion pourra
encore s'ancrer sur pos(), mais cette reconnaissance n'est évidemment
essayée qu'une seule fois. L'application de C<\G> sans C</g> sur une
chaîne de caractères sur laquelle aucune reconnaissance utilisant
C</g> n'a encore été faite, revient à utiliser l'assertion C<\A> pour
reconnaître le début de la chaîne. Notez aussi que, actuellement,
C<\G> ne fonctionne bien que si il est utilisé au tout début du motif.

S<Exemples :>

    # contexte de liste
    ($one,$five,$fifteen) = (`uptime` =~ /(\d+\.\d+)/g);

    # contexte scalaire
    $/ = "";
    while (defined($paragraph = <>)) {
        while ($paragraph =~ /[a-z]['")]*[.!?]+['")]*\s/g) {
            $sentences++;
        }
    }
    print "$sentences\n";

    # utilisation de m//gc avec \G
    $_ = "ppooqppqq";
    while ($i++ < 2) {
        print "1: '";
        print $1 while /(o)/gc; print "', pos=", pos, "\n";
        print "2: '";
        print $1 if /\G(q)/gc;  print "', pos=", pos, "\n";
        print "3: '";
        print $1 while /(p)/gc; print "', pos=", pos, "\n";
    }
    print "Final: '$1', pos=",pos,"\n" if /\G(.)/;

Le dernier exemple devrait S<afficher :>

    1: 'oo', pos=4
    2: 'q', pos=5
    3: 'pp', pos=7
    1: '', pos=7
    2: 'q', pos=8
    3: '', pos=8
    Final: 'q', pos=8

Remarquez que la reconnaissance finale reconnaît C<q> au lieu de C<p>,
comme l'aurait fait une reconnaissance sans C<\G>. Notez aussi que
cette reconnaissance finale ne met pas à jour C<pos> (C<pos> n'est mis
à jour qu'avec C</g>). Si vous obtenez un C<p> lors de cette
reconnaissance finale, cela indique que vous utilisez une vieille
version de Perl (avant 5.6.0).

Une construction idiomatique pratique pour des analyseurs à la C<lex> est
C</\G.../gc>. Vous pouvez combiner plusieurs expressions rationnelles de ce
type pour traiter une chaîne partie par partie en faisant différentes actions
selon l'expression qui est reconnue. Chaque expression essaye de correspondre
là où la précédente s'est arrêtée.

 $_ = <<'EOL';
      $url = new URI::URL "http://www/";   die if $url eq "xXx";
 EOL
 LOOP:
    {
      print(" chiffres"),       redo LOOP if /\G\d+\b[,.;]?\s*/gc;
      print(" minuscule"),      redo LOOP if /\G[a-z]+\b[,.;]?\s*/gc;
      print(" MAJUSCULE"),      redo LOOP if /\G[A-Z]+\b[,.;]?\s*/gc;
      print(" Capitalisé"),     redo LOOP if /\G[A-Z][a-z]+\b[,.;]?\s*/gc;
      print(" MiXtE"),          redo LOOP if /\G[A-Za-z]+\b[,.;]?\s*/gc;
      print(" alphanumérique"), redo LOOP if /\G[A-Za-z0-9]+\b[,.;]?\s*/gc;
      print(" autres"),         redo LOOP if /\G[^A-Za-z0-9]+/gc;
      print ". C'est tout !\n";
    }

Voici la sortie (découpée en plusieurs lignes) :

    autres minuscule autres minuscule MAJUSCULE autres