क्या पर्ल में अंतर जब $ चर और $ {चर}

Question

मैं कुछ ClearCase पर्ल में लिखा ट्रिगर की समीक्षा कर रहा हूँ का उपयोग कर के बीच एक नियमित अभिव्यक्ति में एक चर गुजर रहा है। मैंने देखा है कि कुछ नियमित अभिव्यक्तियों में, चर या तो घुमावदार रूप से या उनके नाम घुंघराले ब्रैकेट में पारित किए जाते हैं।

उदाहरण के लिए, मैं एक ट्रिगर में निम्न कोड पंक्ति है:

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

$component, $phase, $automateddigit, $project_root सभी चर रहे हैं।

कुछ $variable के रूप में क्यों पारित किए गए हैं और अन्य नियमित अभिव्यक्ति में ${variable} के रूप में पास किए गए हैं?

यह है कि वे कैसे initialised कर रहे हैं से आता है?

यहाँ उन्हें initialising कोड की पंक्ति हैं:

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

आप चर $ {नाम}, के रूप में यह स्पष्ट रूप से delimits जहां चर नाम का अंत है, और जहां उद्धृत के बाकी पार कर लेते हैं स्ट्रिंग शुरू होता है। उदाहरण के लिए, अपने कोड में:

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

{} सीमांकक के बिना

:

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

ध्यान दें कि चर $ घटक (यदि आप इसे करने के लिए किसी भी तरह से उल्लेख कर सकते हैं) $ component_ के रूप में की वजह से गलत व्याख्या की जाएगी नियमित अभिव्यक्ति में पीछे अंडरस्कोर।

Answer 2

पहले, इस स्ट्रिंग प्रक्षेप कहा जाता है। एक अच्छा इस मामले में इसका इस्तेमाल करने के कारण (कृपया ध्यान अनुगामी अंडरस्कोर) $ project_root_ के रूप में व्याख्या की जा रही से $ project_root को रोकने के लिए है। यह अधिक जटिल इंटरपोलेशन नियमों को छोड़ने के बजाय, परिवर्तनीय नाम स्पष्ट करता है।

प्रक्षेप के बारे में अधिक के लिए perldata, और perlre देखें और नियमित अभिव्यक्ति ऑपरेटरों के भीतर प्रक्षेप की विशेषताओं पर perlop।

Answer 3

ऊपर उल्लेख किया है, यह चर नाम पृथक करने के लिए नहीं है। बहुत अधिक घुंघराले ब्रेसिज़ पहले से ही मुश्किल नियमित अभिव्यक्तियों को और भी कठिन बना देता है। घुंघराले ब्रेसिज़ का अपना रेगेक्सप उपयोग होता है (पैटर्न पैटर्न की संख्या को सीमित करने के लिए)। मैं regexp/एक्स संशोधक का उपयोग करके की सिफारिश करेंगे, और के रूप में अपने regexp पुनर्लेखन:

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)