Perl Language
Expressions régulières

Chaînes correspondantes

L'opérateur =~ tente de faire correspondre une expression régulière (définie par / ) à une chaîne:

my $str = "hello world";
print "Hi, yourself!\n" if $str =~ /^hello/;

/^hello/ est l'expression régulière réelle. Le ^ est un caractère spécial qui dit à l'expression régulière de commencer avec le début de la chaîne et de ne pas correspondre au milieu quelque part. Ensuite, les regex essaient de trouver les lettres suivantes dans l'ordre h , e , l , l et o .

Les expressions régulières tentent de faire correspondre la variable par défaut ( $_ ) si elle est vide:

$_ = "hello world";

print "Ahoy!\n" if /^hello/;

Vous pouvez également utiliser différents délimiteurs si vous faites précéder l'expression régulière avec l'opérateur m :

m~^hello~;
m{^hello}; 
m|^hello|;

Ceci est utile pour faire correspondre les chaînes qui incluent le caractère / :

print "user directory" if m|^/usr|;

Utilisation de \ Q et \ E dans la correspondance de modèle

Ce qui est entre \ Q et \ E est traité comme des caractères normaux

#!/usr/bin/perl

my $str = "hello.it's.me";

my @test = (
  "hello.it's.me",
    "hello/it's!me",
    );

sub ismatched($) { $_[0] ? "MATCHED!" : "DID NOT MATCH!" }

my @match = (
      [ general_match=> sub { ismatched /$str/ } ],
      [ qe_match    => sub { ismatched /\Q$str\E/ } ],
      );

for (@test) {
    print "\String = '$_':\n";

foreach my $method (@match) {
    my($name,$match) = @$method;
    print "  - $name: ", $match->(), "\n";
}

}

Sortie

String = 'hello.it's.me':
  - general_match: MATCHED!
  - qe_match: MATCHED!
String = 'hello/it's!me':
  - general_match: MATCHED!
  - qe_match: DID NOT MATCH!

Analyser une chaîne avec une expression régulière

Généralement, ce n'est pas une bonne idée d' utiliser une expression régulière pour analyser une structure complexe . Mais cela peut être fait. Par exemple, vous pouvez charger des données dans la table de ruche et les champs sont séparés par des virgules, mais les types complexes comme les tableaux sont séparés par un "|". Les fichiers contiennent des enregistrements dont tous les champs sont séparés par des virgules et des types complexes. Dans ce cas, ce bit de Perl jetable pourrait suffire:

echo "1,2,[3,4,5],5,6,[7,8],[1,2,34],5" | \
    perl -ne \
        'while( /\[[^,\]]+\,.*\]/ ){
            if( /\[([^\]\|]+)\]/){
                $text = $1;
                $text_to_replace = $text;
                $text =~ s/\,/\|/g;
                s/$text_to_replace/$text/;
            }
        } print'

Vous voudrez vérifier la sortie:

1,2, [3 | 4 | 5], 5,6, [7 | 8], [1 | 2 | 34], 5

Remplacer une chaîne à l'aide d'expressions régulières

s/foo/bar/;         # replace "foo" with "bar" in $_
my $foo = "foo";
$foo =~ s/foo/bar/; # do the above on a different variable using the binding operator =~
s~ foo ~ bar ~;     # using ~ as a delimiter
$foo = s/foo/bar/r; # non-destructive r flag: returns the replacement string without modifying the variable it's bound to
s/foo/bar/g;        # replace all instances