Was ist der Unterschied in Perl, wenn zwischen der Verwendung von $ Variable und $ {variable} eine Variable in einem regulären Ausdruck vorbei

Question

Ich bin die Überprüfung einiger Clearcase in Perl geschrieben Trigger. Ich habe in einigen regulären Ausdrücken bemerkt, dass die Variablen übergeben werden entweder straighforwardly oder mit ihren Namen in geschweiften Klammern.

Zum Beispiel, ich habe die folgende Codezeile in einem Trigger:

if ($baseline !~ /^${component}_(|.*_)$phase\.\d+(|[a-z]|-\d+|${automateddigit})$/ &&
        $baseline !~ /^${project_root}_$phase\.\d+(|[a-z]|-\d+|${automateddigit})$/)

$component, $phase, $automateddigit, $project_root sind alle Variablen.

Warum als $variable im regulären Ausdruck einige geben als ${variable} und andere übergeben werden?

Kommt es aus, wie sie initialisiert werden?

Hier sind die Codezeile initialisiert sie:

($project = $ENV{CLEARCASE_PROJECT}) =~ s/\@.*$//;
($component = $ENV{CLEARCASE_COMPONENT}) =~ s/\@.*$//;

($project_root, $phase) = ($project =~ /^(.*)_(R\d+.*)$/);

exit(0) if (! $phase);

$phase .= ".0" if ($phase =~ /^R\d+$/);

$automateddigit = '';

$istream = `cleartool desc -fmt "%[istream]p" project:$ENV{CLEARCASE_PROJECT}`;

$componentlist = `cleartool desc -fmt "%[components]Cp" stream:$ENV{CLEARCASE_STREAM}`;
$componentsnbr = split(',', $componentlist);

if ($componentsnbr > 1) {
    $automateddigit .= '\\.\\d+';
}

Answer 1

Wenn Sie die Variable wie $ {name} übergeben, dies begrenzt ausdrücklich, wo das Ende des Variablennamens ist, und wo der Rest der Zeichenfolge in Anführungszeichen beginnt. Zum Beispiel im Code:

if ($baseline !~ /^${component}_(|.*_)$phase\.\d+(|[a-z]|-\d+|${automateddigit})$/ &&

Ohne die {} Begrenzungszeichen:

if ($baseline !~ /^$component_(|.*_)$phase\.\d+(|[a-z]|-\d+|${automateddigit})$/ &&

Beachten Sie, dass die Variable $ Komponente (Sie es so oder so beziehen können) wird wie $ Component_ aufgrund des nachlaufs im regulären Ausdruck unterstreichen falsch interpretiert werden.

Answer 2

Als erstes wird diese String-Interpolation genannt. Ein guter Grund, es in diesem Fall zu verwenden ist $ project_root um zu verhindern, wie $ interpretierte project_root_ (man beachte den hinteren Unterstrich). Es wird ausdrücklich die Variablennamen, anstatt es zu den mehr komplizierten Interpolationsregeln zu verlassen.

Siehe perldata für mehr auf Interpolation und perlre und perlop auf Besonderheiten der Interpolation innerhalb der regulären Ausdrücke.

Answer 3

Wie oben erwähnt, ist es dort Variablen-Namen zu begrenzen. Zu viele geschweiften Klammern machen schon schwierig regulären Ausdrücke noch schwieriger. Geschweiften Klammern haben ihre eigenen regexp verwendet (die Anzahl der Male ein Muster zu begrenzen, passt). Ich würde empfehlen, die regexp / x-Modifikator verwenden, und umschreiben Ihre regexp als:

if ($baseline !~ /^$component    # Start with $component
                   _             # then an underscore
                   (|.*_)        # Then nothing, or anything followed by an underscore
                   $phase        # ...
                   \.\d+         # ...
                   (|            # Then optionally:
                      [a-z]|       # lower alpha
                      -\d+|        # or ...
                      $automateddigit
                   )
                   $/x &&
    $baseline !~ /^$project_root
                   _
                   $phase
                   \.\d+
                   (|
                     [a-z]|
                     -\d+|
                     $automateddigit
                   )$/x)