Comment puis-je faire correspondre plusieurs expressions régulières en Perl?

Je voudrais vérifier si une chaîne de caractères correspondant à un ensemble donné de regexes. Comment puis-je le faire?

source d'informationauteur David B

perl regex

10

Mon go-to pour le test d'une valeur à l'encontre de plusieurs regexes à la fois est Regexp::Assemblerqui va Assembler plusieurs Expressions Régulières en une seule RE" d'une manière un peu plus intelligente et optimisée que de simplement faire un join '|', @regexps. Vous êtes également en mesure, par défaut, pour récupérer la partie du texte correspondant et, si vous avez besoin de savoir quel modèle de correspondance, la track commutateur de fournir ces informations. Sa performance est assez bonne dans une application, je l'utilise pour tester l'encontre de 1700 modèles à la fois - et je n'ai pas encore besoin de quelque chose qu'il ne fait pas.
20

Utiliser smart matching si vous avez la version en perl 5.10 ou plus récent!
```
#! /usr/bin/env perl

use warnings;
use strict;

use feature 'switch';

my @patterns = (
  qr/foo/,
  qr/bar/,
  qr/baz/,
);

for (qw/ blurfl bar quux foo baz /) {
  no warnings 'experimental::smartmatch';
  print "$_: ";
  given ($_) {
    when (@patterns) {
      print "hit!\n";
    }
    default {
      print "miss.\n";
    }
  }
}
```
Bien que vous ne voyez pas explicite ~~ opérateur, Perl donné/quand t-il derrière les coulisses:

La plupart de la puissance vient de l'implicite smartmatching qui peut parfois s'appliquer. La plupart du temps, when(EXPR) est traité comme un implicite smartmatch de $_qui est, $_ ~~ EXPR. (Voir Smartmatch Opérateur dans perlop pour plus d'informations sur smartmatching.)

“Smartmatch Opérateur” in perlop donne un tableau de beaucoup de combinaisons que vous pouvez utiliser, et le code ci-dessus correspond au cas où $a est Tout et $b est Tableauqui correspond à peu près à
```
grep $a ~~ $_, @$b
```
à l'exception de la recherche de courts-circuits, c'est à direse retourne rapidement sur un match plutôt que de traiter de tous les éléments. Dans la boucle implicite ensuite, nous sommes smart matching Tout contre Regexqui est
```
$a =~ /$b/
```
De sortie:
```
blurfl: miss. 
bar: touché! 
quux: miss. 
toto: touché! 
baz: touché!
```
Additif

Depuis cette réponse a été écrit à l'origine, Perl, les designers ont réalisé qu'il y avait des erreurs dans la façon dont smartmatching œuvres, et il est donc maintenant considéré comme une fonctionnalité expérimentale. Le boîtier ci-dessus n'est pas l'un des controverses utilise, néanmoins, le code de sortie du comprendrait given is experimental et when is experimental sauf que j'ai ajouté no warnings 'experimental::smartmatch';.

Toute utilisation de fonctions expérimentales implique certains risques, mais j'avais l'estimation basse de probabilité pour ce cas. Lors de l'utilisation d'un code similaire à ce qui précède et de la mise à niveau vers une version plus récente de Perl, c'est un potentiel de gotcha d'être conscient de.
12

De perlfaq6's réponse à Comment puis-je adapter efficacement le nombre d'expressions régulières à la fois?dans ce cas, la dernière version de développement que je viens de mettre à jour avec un smart match exemple.

Comment puis-je adapter efficacement le nombre d'expressions régulières à la fois?

(contribution de brian d foy)

Si vous avez Perl 5.10 ou plus tard, c'est presque banal. Vous avez juste à puce
match contre un tableau de l'expression régulière objets:
```
my @patterns = ( qr/Fr.d/, qr/B.rn.y/, qr/W.lm./ );

if( $string ~~ @patterns ) {
    ...
    };
```
La smart match s'arrête lorsqu'il trouve une correspondance, il n'a pas à essayer
chaque expression.

Plus tôt que Perl 5.10, vous avez un peu de travail à faire. Vous voulez
éviter la compilation d'une expression régulière à chaque fois que vous voulez pour le match.
Dans cet exemple, perl devez recompiler l'expression régulière pour chaque
itération de la boucle C, car il n'a aucun moyen de savoir ce que
C:
```
my @patterns = qw( foo bar baz );

LINE: while( <DATA> ) {
    foreach $pattern ( @patterns ) {
        if( /\b$pattern\b/i ) {
            print;
            next LINE;
            }
        }
    }
```
Le C de l'opérateur a montré en perl 5.005. Il compile un régulier
l'expression, mais ne l'applique pas. Lorsque vous utilisez le pré-compilés
la version de la regex perl fait moins de travail. Dans cet exemple, j'ai inséré
un C pour faire de chaque motif dans son pré-forme compilée. Le reste de
le script est le même, mais plus rapide:
```
my @patterns = map { qr/\b$_\b/i } qw( foo bar baz );

LINE: while( <> ) {
    foreach $pattern ( @patterns ) {
        if( /$pattern/ )
            {
            print;
            next LINE;
            }
        }
    }
```
Dans certains cas, vous peut être capable de faire plusieurs modèles en un seul
expression régulière. Méfiez-vous des situations qui nécessitent un retour en arrière
si.
```
my $regex = join '|', qw( foo bar baz );

LINE: while( <> ) {
    print if /\b(?:$regex)\b/i;
    }
```
Pour plus de détails sur l'expression régulière de l'efficacité, de voir que je par Jeffrey Freidl. Il explique comment régulier
moteur d'expression et la raison pour laquelle certains modèles sont étonnamment
inefficaces. Une fois que vous comprenez comment perl utilise les expressions régulières,
vous pouvez régler dans toutes les situations.

Je ne suis pas exactement sûr de ce que vous recherchez, mais quelque chose comme ça?

#!/usr/bin/perl
@regexes = ( qr/foo/ , qr/bar/ );
while ($line=<>){
  chomp $line;
  $match=0;
  for $re (@regexes){
    $match++ if ($line =~ $re);
  }
  print "$line matches $match regexes\n";
}

Vous pouvez également compiler toutes ces données en un seul reges comme ceci:

#!/usr/bin/perl
@regexes = ( qr/foo/ , qr/bar/ );
$allre= "(".join("|",@regexes).")";
$compiled=qr/$allre/;
while(<>){
  chomp;
  print "$_ matches ($1)\n" if /$compiled/;
}

Espère que ça aide.

3

Si vous utilisez un grand nombre d'expressions régulières, vous pourriez être intéressé par Regexp::Optimiseur De

Voir à partir de la synthèse de la section :
```
use Regexp::Optimizer;
my $o  = Regexp::Optimizer->new;
my $re = $o->optimize(qr/foobar|fooxar|foozap/);
# $re is now qr/foo(?:[bx]ar|zap)/
```
Qui pourrait être plus efficace, si vous êtes prêt à installer un module supplémentaire.

Vous devez vous connecter pour publier un commentaire.

Additif