Comment puis-je échapper des méta-caractères lorsque j'interpole une variable dans l'opérateur de correspondance de Perl?

Question

Supposons que j'ai un fichier contenant des lignes que je suis en train de correspondre:

foo 
quux 
bar 

Dans mon code, j'ai un autre tableau:

foo 
baz 
quux 

Supposons que nous parcourons le fichier, appelant chaque élément $word, et la liste interne que nous vérifions, @arr.

if(grep {$_ =~ m/^$word$/i} @arr) 

Cela fonctionne correctement, mais dans le cas peu possible où nous avons un cas de test de fo. dans le fichier, le . fonctionne comme un opérateur générique dans le regex et fo. correspond alors foo, ce qui est inacceptable .

Ceci est bien sûr dû au fait que Perl interpole la variable dans une regex.

La question:

Comment forcer Perl à utiliser littéralement la variable?

Answer 1

La bonne réponse est - ne pas utiliser les expressions régulières. Je ne dis pas que les expressions rationnelles sont mauvaises, mais les utiliser pour (ce qui équivaut à) vérifier l'égalité simple est exagéré.

Utilisez: grep { lc($_) eq lc($word) } @arr et soyez heureux.

Answer 2

quotemeta

Renvoie la valeur de EXPR avec tous les caractères non "mot" antislash.

http://perldoc.perl.org/functions/quotemeta.html

Answer 3

Utilisez \Q...\E pour échapper à des symboles spéciaux directement dans la chaîne perl après interpolation de valeur variable:

if(grep {$_ =~ m/^\Q$word\E$/i} @arr) 

Answer 4

De la réponse de perlfaq6 à How do I match a regular expression that's in a variable?:

---

Nous n'avons pas à des modèles difficiles codes dans l'opérateur de correspondance (ou toute autre chose qui fonctionne avec des expressions régulières). Nous pouvons mettre le motif dans une variable pour une utilisation ultérieure. L'opérateur match est un contexte de double guillemets, de sorte que vous pouvez interpoler votre variable comme une chaîne entre guillemets. Dans ce cas, vous lisez l'expression régulière en tant qu'entrée utilisateur et la stockez dans $ regex. Une fois que vous avez le motif dans $ regex, vous utilisez cette variable dans l'opérateur match.

chomp(my $regex = <STDIN>); 

if($string =~ m/$regex/) { ... } 

Toute expression régulière des caractères spéciaux $ regex sont toujours spéciales, et le modèle doit encore être valide ou Perl se plaindra. Par exemple, dans ce modèle, il y a une parenthèse non appariée.

my $regex = "Unmatched (paren"; 

"Two parens to bind them all" =~ m/$regex/; 

Lorsque Perl compile l'expression régulière, il traite la parenthèse comme le début d'un match de mémoire.Quand il ne trouve pas la parenthèse fermante, il se plaint:

Unmatched (in regex; marked by <-- HERE in m/Unmatched (<-- HERE paren/ at script line 3. 

Vous pouvez contourner ce de plusieurs façons en fonction de notre situation. Tout d'abord, si vous ne voulez pas que les caractères de la chaîne soient spéciaux, vous pouvez leur échapper avec quotemeta avant d'utiliser la chaîne. Vous pouvez également le faire directement dans l'opérateur match en utilisant les séquences \ Q et \ E. Le \ Q indique à Perl où commencer à échapper des caractères spéciaux, et le \ E lui indique où s'arrêter (voir perlop pour plus de détails).

chomp(my $regex = <STDIN>); 

if($string =~ m/\Q$regex\E/) { ... } 

Alternativement, vous pouvez utiliser // qr, l'opérateur de citation d'expression régulière (voir perlop pour plus de détails). Il cite et compile peut-être le motif, et vous pouvez appliquer des drapeaux d'expression régulière au motif.

chomp(my $input = <STDIN>); 

my $regex = qr/$input/is; 

$string =~ m/$regex/ # same as m/$input/is; 

Vous pourriez également vouloir piéger des erreurs en enveloppant un bloc eval autour de l'ensemble.

chomp(my $input = <STDIN>); 

eval { 
    if($string =~ m/\Q$input\E/) { ... } 
    }; 
warn $@ if $@; 

Ou ...

my $regex = eval { qr/$input/is }; 
if(defined $regex) { 
    $string =~ m/$regex/; 
    } 
else { 
    warn $@; 
    } 

Answer 5

Je ne pense pas que vous voulez un regex dans ce cas, puisque vous n'êtes pas correspondant à un motif. Vous recherchez une séquence littérale de caractères que vous connaissez déjà. Construire un hachage avec les valeurs pour correspondre et l'utiliser pour filtrer @arr:

open my $fh, '<', $filename or die "..."; 
my %hash = map { chomp; lc($_), 1 } <$fh>; 

foreach my $item (@arr) 
     { 
     next unless exists $hash{ lc($item) }; 
     print "I matched [$item]\n"; 
     }