Comment effectuer plusieurs remplacements avec Perl?

Question

J'ai code Perl:

my $s = "The+quick+brown+fox+jumps+over+the+lazy+dog+that+is+my+dog"; 

Je veux remplacer tous les + avec l'espace et dog avec cat.

J'ai cette expression régulière:

$s =~ s/\+(.*)dog/ ${1}cat/g; 

Mais, il correspond uniquement à la première occurrence de + et dernier dog.

Answer 1

Vous pouvez utiliser le modificateur « e » pour exécuter du code dans la deuxième partie d'une expression s///.

$s =~ s/(\+)|(dog)/$1 ? ' ' : 'cat'/eg; 

Si $1 est vrai, cela signifie que le \+ adapté, il substitue un espace; sinon, il remplace "chat".

Answer 2

réponse simple - utiliser 2 lignes !:

$s =~ s/+/ /g; 
$s =~ s/dog/cat/g; 

Il pourrait probablement se faire en une ligne avec correspondance « non gourmand », mais cela devrait faire l'affaire

Answer 3

Deux expressions régulières pourraient faire votre vie beaucoup plus facile:

$s =~ s/\+/ /g; 
$s =~ s/dog/cat/g; 

Les matches suivants « + », suivi d'un tas de choses, suivi de « chien ». En outre, "+" est techniquement un métacaractère.

/+(.*)dog/ 

Answer 4

Un hachage peut faire ce que vous voulez:

#!/usr/bin/perl 

use strict; 
use warnings; 

my $s = "The+quick+brown+fox+jumps+over+the+lazy+dog+that+is+my+dog"; 

my %replace = (
    "+" => " ", 
    dog => "cat", 
); 

$s =~ s/([+]|dog)/$replace{$1}/g; 

print "$s\n"; 

Dans les commentaires, je vois que vous êtes préoccupé par la performance, la solution à deux regex est plus performante. C'est parce que toute solution qui fonctionne pour une regex devra utiliser des captures (qui ralentissent l'expression rationnelle).

Voici les résultats d'une référence:

eval: The quick brown fox jumps over the lazy cat that is my cat 
hash: The quick brown fox jumps over the lazy cat that is my cat 
two: The quick brown fox jumps over the lazy cat that is my cat 
     Rate hash eval two 
hash 33184/s -- -29% -80% 
eval 46419/s 40% -- -72% 
two 165414/s 398% 256% -- 

J'ai utilisé la référence suivante:

#!/usr/bin/perl 

use strict; 
use warnings; 

use Benchmark; 

my $s = "The+quick+brown+fox+jumps+over+the+lazy+dog+that+is+my+dog"; 

my %replace = (
    "+" => " ", 
    dog => "cat", 
); 

my %subs = (
    hash => sub { 
     (my $t = $s) =~ s/([+]|dog)/$replace{$1}/g; 
     return $t; 
    }, 
    two => sub { 
     (my $t = $s) =~ s/[+]/ /g; 
     $t =~ s/dog/cat/g; 
     return $t; 
    }, 
    eval => sub { 
     (my $t = $s) =~ s/(\+)|(dog)/$1 ? ' ' : 'cat'/eg; 
     return $t; 
    }, 
); 

for my $k (sort keys %subs) { 
    print "$k: ", $subs{$k}(), "\n"; 
} 

Benchmark::cmpthese -1, \%subs; 

Answer 5

Si la vitesse est importante, vous devriez probablement en tenir à deux lignes. Mais quand j'ai besoin de faire plusieurs sous-groupes à la fois, je m'intéresse généralement plus à la commodité, alors j'utilise un hash comme suggéré par Chas. Owens. Deux avantages par rapport au doubleur étant qu'il est facile de le modifier, et il se comporte comme prévu (par exemple en substituant "chat" pour "chien" et "chien" pour "chat" en même temps).

Cependant, je suis beaucoup trop paresseux pour écrire l'expression rationnelle à la main et préfère assembler par join et utiliser la carte pour échapper à des choses:

#!/usr/bin/perl 

use strict; 
use warnings; 

my $s = "The+quick+brown+fox+jumps+over+the+lazy+dog+that+is+my+dog"; 

my %replace = (
    "+" => " ", 
    dog => "cat", 
); 

my $regex = join "|", 
    #use quotemeta to escape special characters 
    map { quotemeta } 
    #reverse sort the keys because "ab" =~ /(a|ab)/ returns "a" 
    sort { $b cmp $a } keys %replace; 

#compiling the regex before using it prevents 
#you from having to recompile it each time 
$regex = qr/$regex/; 

$s =~ s/($regex)/$replace{$1}/g; 

print "$s\n"; 

Answer 6

Perl 5.14 et plus récent a la capacité de substitutions de chaîne avec une affectation non-destructrice de sorte que vous pouvez tuer 3 oiseaux d'une pierre: faites vos deux substitutions globales et assignez le résultat à une nouvelle variable sans modifier votre variable d'origine.

my $s = "The+quick+brown+fox+jumps+over+the+lazy+dog+that+is+my+dog"; 
my $result = $s =~ s/+/ /gr 
       =~ s/dog/cat/gr; 

remplacera tous vos + avec l'espace et remplacer tous les dog avec cat, attribuer le résultat dans une nouvelle variable. Dans un one-liner.