Que signifie cette expression rationnelle Perl moyenne: m/(.*?):(.*?)$/g?

Je suis de l'édition d'un dossier de Perl, mais je ne comprends pas cette regexp comparaison. Quelqu'un peut-pourriez-vous m'expliquer?

if ($lines =~ m/(.*?):(.*?)$/g) { } ..

Ce qui se passe ici? $lines est une ligne d'un fichier texte.

  • Ressemble à première (.*?) toujours correspondre à la chaîne vide.
  • Pas toujours. Il va correspondre tous les caractères jusqu'à la première du côlon.
InformationsquelleAutor perlnewb | 2010-09-22
  1. 12

    La diviser en plusieurs parties:

    $lines =~ m/ (.*?)      # Match any character (except newlines)
                        # zero or more times, not greedily, and
                        # stick the results in $1.
             :          # Match a colon.
             (.*?)      # Match any character (except newlines)
                        # zero or more times, not greedily, and
                        # stick the results in $2.
             $          # Match the end of the line.
           /gx;

    Donc, ce sera le match des chaînes de caractères comme ":" (il correspond à zéro des personnages, puis une virgule, puis zéro caractères avant la fin de la ligne, $1 et $2 sont des chaînes vides), ou "abc:" ($1 = "abc", $2 est une chaîne vide), ou "abc:def:ghi" ($1 = "abc" et $2 = "def:ghi").

    Et si vous passez dans une ligne qui ne correspond pas (il semble que ce serait si la chaîne ne contient pas de deux-points), alors il ne sera pas procédé le code à l'intérieur des parenthèses. Mais si c'est le match, puis le code à l'intérieur des parenthèses peut l'utiliser et le processus de la spéciale $1 et $2 variables (au moins jusqu'à la prochaine expression régulière se montre, s'il en est dans les crochets).

    InformationsquelleAutor CanSpice
  2. 9

    Il est un outil pour aider à comprendre les regexes: YAPE::Regex::Expliquer.

    Ignorant la g modificateur, qui n'est pas nécessaire ici:

    use strict;
use warnings;
use YAPE::Regex::Explain;

my $re = qr/(.*?):(.*?)$/;
print YAPE::Regex::Explain->new($re)->explain();

__END__

The regular expression:

(?-imsx:(.*?):(.*?)$)

matches as follows:

NODE                     EXPLANATION
----------------------------------------------------------------------
(?-imsx:                 group, but do not capture (case-sensitive)
                         (with ^ and $ matching normally) (with . not
                         matching \n) (matching whitespace and #
                         normally):
----------------------------------------------------------------------
  (                        group and capture to :
----------------------------------------------------------------------
    .*?                      any character except \n (0 or more times
                             (matching the least amount possible))
----------------------------------------------------------------------
  )                        end of 
----------------------------------------------------------------------
  :                        ':'
----------------------------------------------------------------------
  (                        group and capture to :
----------------------------------------------------------------------
    .*?                      any character except \n (0 or more times
                             (matching the least amount possible))
----------------------------------------------------------------------
  )                        end of 
----------------------------------------------------------------------
  $                        before an optional \n, and the end of the
                           string
----------------------------------------------------------------------
)                        end of grouping
----------------------------------------------------------------------

    Voir aussi perldoc perlre.

    • C'est sacrément chouette!
    InformationsquelleAutor toolic
  3. 3

    Il a été écrit par quelqu'un qui en sait trop sur les expressions régulières, ou pas assez sur le $' et $` variables.

    Cela pourrait avoir été écrit comme

    if ($lines =~ /:/) {
    ... # use $` ($PREMATCH)  instead of $1
    ... # use $' ($POSTMATCH) instead of $2
}

    ou

    if ( ($var1,$var2) = split /:/, $lines, 2 and defined($var2) ) {
    ... # use $var1, $var2 instead of $1,$2
}
    • Si vous souhaitez utiliser /:/, utilisez l' /p drapeau et le ${^PREMATCH} et ${^POSTMATCH} des variables à partir de Perl 5.10. Je préfère split, cependant, puisque c'est ce qui se passe réellement.
    InformationsquelleAutor mob
  4. 2

    (.*?) capture de caractères, mais comme quelques-uns d'entre eux que possible.

    Donc il cherche des modèles comme <something>:<somethingelse><end of line>, et s'il y a plusieurs : dans la chaîne, le premier sera utilisé comme séparateur entre <something> et <somethingelse>.

    InformationsquelleAutor Amber
  5. 2

    Cette ligne indique à effectuer une expression régulière sur $lines avec les regex m/(.*?):(.*?)$/g. Il sera en fait de retour true si un match ne peut être trouvé dans $lines et false si on ne peut pas être trouvé.

    Une explication de la =~ opérateur:

    Binaire "=~" lie une expression scalaire
    pour une mise en correspondance du modèle. Certaines opérations
    de recherche ou de modifier la chaîne $_ par
    par défaut. Cet opérateur permet ce genre
    de l'opération de travail sur certains autres
    chaîne de caractères. La droite argument est une recherche
    motif, la substitution ou la
    la translittération. La gauche argument est
    ce qui est censé être recherché,
    substitué, ou transcrit au lieu
    de la valeur par défaut $_. Lorsque utilisé dans scalaire
    contexte, la valeur de retour généralement
    indique la réussite de l'
    le fonctionnement.

    La regex est lui-même:

    m/    #Perform a "match" operation
(.*?) #Match zero or more repetitions of any characters, but match as few as possible (ungreedy)
:     #Match a literal colon character
(.*?) #Match zero or more repetitions of any characters, but match as few as possible (ungreedy)
$     #Match the end of string
/g    #Perform the regex globally (find all occurrences in $line)

    Donc si $lines correspond à l'encontre de cette regex, il va aller dans la réserve de la partie, sinon, il sera false et le sauter.

    InformationsquelleAutor eldarerathis