Was hat das Perl-regex bedeutet: m/(.*?):(.*?)$/g?

Bin ich die Bearbeitung einer Perl-Datei, aber ich versteh das nicht-regexp-Vergleich. Kann jemand bitte erklären Sie es mir?

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

Was passiert hier? $lines ist eine Zeile aus einer text-Datei.

Sieht aus wie erste (.*?) entspricht immer auf eine leere Zeichenfolge.
Nicht immer. Es werde mit allen Zeichen bis zum ersten Doppelpunkt.

InformationsquelleAutor perlnewb | 2010-09-22

  1. 12

    Brechen Sie in Teile:

    $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;

    So, in diesem match zu Zeichenfolgen wie ":" (es entspricht null-Zeichen, dann ein Doppelpunkt, dann null-Zeichen vor dem Ende der Zeile, $1 und $2 sind leere strings), oder "abc:" ($1 = "abc", $2 ist ein leerer string), oder "abc:def:ghi" ($1 = "abc" und $2 = "def:ghi").

    Und wenn Sie eine Zeile, die nicht mit (es sieht aus wie dies wäre, wenn der string nicht enthalten einen Doppelpunkt), dann wird es nicht Prozess den code, der innerhalb der eckigen Klammern. Aber wenn es passt, dann wird der code innerhalb der Klammern können die Nutzung und Verarbeitung der speziellen $1 und $2 Variablen (zumindest bis zum nächsten regulären Ausdrucks zeigt sich, wenn man innerhalb der eckigen Klammern).

    InformationsquelleAutor CanSpice

  2. 9

    Es ist ein Werkzeug, um zu helfen, zu verstehen, regexes: YAPE::Regex::Explain.

    Ignorieren die g modifier, die hier nicht notwendig ist:

    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 \1:
----------------------------------------------------------------------
    .*?                      any character except \n (0 or more times
                             (matching the least amount possible))
----------------------------------------------------------------------
  )                        end of \1
----------------------------------------------------------------------
  :                        ':'
----------------------------------------------------------------------
  (                        group and capture to \2:
----------------------------------------------------------------------
    .*?                      any character except \n (0 or more times
                             (matching the least amount possible))
----------------------------------------------------------------------
  )                        end of \2
----------------------------------------------------------------------
  $                        before an optional \n, and the end of the
                           string
----------------------------------------------------------------------
)                        end of grouping
----------------------------------------------------------------------

    Siehe auch perldoc perlre.

    Das ist verdammt ordentlich!

    InformationsquelleAutor toolic

  3. 3

    Es wurde von jemandem geschrieben, der entweder weiß zu viel über reguläre Ausdrücke oder nicht genug über die $' und $` Variablen.

    Diese geschrieben worden sein könnte, als

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

    oder

    if ( ($var1,$var2) = split /:/, $lines, 2 and defined($var2) ) {
    ... # use $var1, $var2 instead of $1,$2
}
    Wenn Sie möchten, verwenden Sie/,:/, die /p-flag und ${^PREMATCH} und ${^POSTMATCH} - Variablen von Perl 5.10. Ich würde es vorziehen, split, obwohl, da, dass ist das, was tatsächlich geschieht.

    InformationsquelleAutor mob

  4. 2

    Diese Zeile sagt, führen Sie einen regulären Ausdruck übereinstimmen, der auf $lines mit der regex m/(.*?):(.*?)$/g. Es wird wirksam zurück true wenn eine übereinstimmung gefunden werden kann, in $lines und false wenn man nicht gefunden werden kann.

    Einer Erklärung, die =~ Betreiber:

    Binary "=~" bindet einen skalaren Ausdruck
    zu einem Muster übereinstimmen. Bestimmte Operationen
    Suche Sie oder ändern Sie die Zeichenfolge $_ von
    Standard. Dieser operator macht, die Art
    der Betrieb funktioniert auf einigen anderen
    string. Das Rechte argument ist eine Suche
    Muster, Ersatz, oder
    transliteration. Das linke argument ist
    was soll gesucht werden soll,
    ersetzt oder transkribiert statt
    der Standardwert ist $_. Wenn verwendet, Skalare
    Kontext, ist der Rückgabewert in der Regel
    zeigt der Erfolg der
    Betrieb.

    Die regex selbst ist:

    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)

    Also, wenn $lines matches gegen regex, es wird in den bedingten Teil, sonst wird es false und wird es zu überspringen.

    InformationsquelleAutor eldarerathis

  5. 1

    (.*?) erfasst alle Zeichen, aber so wenige von Ihnen wie möglich.

    So sieht es für Muster, wie <something>:<somethingelse><end of line>, und wenn es mehrere : im string wird das erste verwendet werden, als Teiler zwischen <something> und <somethingelse>.

    InformationsquelleAutor Amber

Schreibe einen Kommentar