क्या पर्ल नियमित अभिव्यक्ति का मिलान करने की संख्या का मूल्यांकन करने का कोई तरीका है?

Question

मैं perldoc perlre पर Regular Expressions Cookbook और स्टैक ओवरफ़्लो पर संबंधित प्रश्नों पर पोरिंग कर रहा हूं और मुझे लगता है कि यह एक बहुत ही उपयोगी अभिव्यक्ति प्रतीत नहीं होता है: मैं वर्तमान मिलान की संख्या कैसे जानता हूं?

पिछले बंद समूह मैच ($^N) के लिए अभिव्यक्ति कर रहे हैं, मैच 3 की सामग्रियों (\g{3} अगर मैं सही ढंग से समझ में आ डॉक्स), $', $& और $`। लेकिन ऐसा कोई वैरिएबल प्रतीत नहीं होता है जिसका उपयोग मैं कर सकता हूं जो बस मुझे बताता है कि वर्तमान मैच की संख्या क्या है।

क्या यह वाकई गायब है? यदि हां, तो क्या कोई समझाया गया तकनीकी कारण है कि इसे कार्यान्वित करना मुश्किल क्यों है, या क्या मैं सिर्फ पेल्डडोक को पर्याप्त रूप से पर्याप्त नहीं पढ़ रहा हूं?

कृपया ध्यान दें कि मुझे अंतर्निहित चर में रुचि है, (${$count++}) का उपयोग करने जैसे कामकाज।

संदर्भ के लिए, मैं एक नियमित अभिव्यक्ति बनाने की कोशिश कर रहा हूं जो कि मैच के कुछ उदाहरणों से मेल खाएगा (उदाहरण के लिए चरित्र "ई" की सभी घटनाओं से मेल खाता है लेकिन 3, 7 और 10 की घटनाओं से मेल नहीं खाता जहां 3, 7 और 10 केवल सरणी में संख्याएं हैं)। this SO question पर अधिक मूर्खतापूर्ण उत्तर बनाने की कोशिश करते समय मैं इसमें भाग गया।

मैं रेगेक्स को वास्तव में 3, 7 और 10 को रेगेक्स में डालने के लिए तारों के रूप में मूल्यांकन करना चाहता हूं।

Answer 1

मैंने थोड़ी देर के लिए इसके साथ खेला। दोबारा, मुझे पता है कि यह वास्तव में वह नहीं है जिसे आप ढूंढ रहे हैं, लेकिन मुझे नहीं लगता कि जिस तरह से आप चाहते हैं उसमें मौजूद है।

मेरे पास दो विचार थे। सबसे पहले, split के साथ विभाजक प्रतिधारण मोड का उपयोग करके, आप आउटपुट सूची में अजीब संख्या वाले तत्वों के रूप में इंटरस्टिशियल बिट्स प्राप्त करते हैं। split से सूची के साथ, आप कौन-से मिलान आप पर हैं गिनती और इसे वापस एक साथ रख आप इसे कितना पसंद:

use v5.14; 

$_ = 'ab1cdef2gh3ij4k5lmn6op7qr8stu9vw10xyz'; 

my @bits = split /(\d+)/; # separator retention mode 

my @skips = qw(3 7 10); 
my $s; 
while(my($index, $value) = each @bits) { 
    # shift indices to match number (index = 2 n - 1) 
    if($index % 2 and ! (($index + 1)/2 ~~ @skips)) { 
     $s .= '^'; 
     } 
    else { 
     $s .= $value; 
     } 
    } 

मैं:

ab^cdef^gh3ij^k^lmn^op7qr^stu^vw10xyz 

मैंने सोचा कि मैं वास्तव में मैं जब तक मेरी split जवाब पसंद आया दूसरा विचार था। state एक प्रतिस्थापन के अंदर काम करता है?ऐसा लगता है कि यह करता है:

use v5.14; 
$_ = 'ab1cdef2gh3ij4k5lmn6op7qr8stu9vw10xyz'; 
my @skips = qw(3 7 10); 

s/(\d+)/ 
    state $n = 0; 
    $n++; 
    $n ~~ @skips ? $1 : '$' 
    /eg; 

say; 

यह मैं देता है:

ab$cdef$gh3ij$k$lmn$op7qr$stu$vw10xyz 

मुझे नहीं लगता कि आपको लगता है कि तुलना में बहुत सरल प्राप्त कर सकते हैं करते हैं, भले ही उस जादू चर अस्तित्व में।

मेरे पास तीसरा विचार था जिसे मैंने कोशिश नहीं की थी। मुझे आश्चर्य है कि state कोड सम्मिलन के अंदर काम करता है। यह हो सकता है, लेकिन फिर मुझे यह पता लगाना होगा कि मैच में असफल होने के लिए उनमें से किसी एक का उपयोग कैसे किया जाए, जिसका वास्तव में मतलब है कि इसे उस बिट पर छोड़ना है जो मेल हो सकता है। यह वास्तव में जटिल लगता है, जो शायद बोरोडिन आपको छद्म कोड में दिखाने के लिए दबा रहा था।

Answer 2

मैं अन्य प्रश्न के लिए इसका उपयोग करने की वास्तव में उपयोगिता या ज्ञान को पूरी तरह से अनदेखा कर रहा हूं।

मैंने सोचा था कि @- या @+ आप क्या चाहते हैं, क्योंकि वे गिने मैचों में से ऑफसेट पकड़ कर सकते हैं, लेकिन ऐसा लगता है regex इंजन पहले से ही जानता है की तरह क्या पिछले सूचकांक हो जाएगा:

use v5.14; 

use Data::Printer; 

$_ = 'abc123abc345abc765abc987abc123'; 

my @matches = m/ 
    ([0-9]+) 
    (?{ 
     print 'Matched \$' . $#+ . " group with $^N\n"; 
     say p(@+); 
    }) 
    .*? 
    ([0-9]+) 
    (?{ 
     print 'Matched \$' . $#+ . " group with $^N\n"; 
     say p(@+); 
    }) 
    /x; 

say "Matches: @matches"; 

यह तार देता है जो अंतिम सूचकांक को 2 के रूप में दिखाता है, भले ही यह $2 से मेल नहीं खाता है।

Matched \$2 group with 123 
[ 
    [0] 6, 
    [1] 6, 
    [2] undef 
] 
Matched \$2 group with 345 
[ 
    [0] 12, 
    [1] 6, 
    [2] 12 
] 
Matches: 123 345 

सूचना है कि पहली बार के आसपास, $+[2] undef है, इसलिए है कि एक अभी तक भरा नहीं किया गया है। आप इसके साथ कुछ करने में सक्षम हो सकते हैं, लेकिन मुझे लगता है कि शायद आपके प्रश्न की भावना से दूर हो रहा है। यदि आप वास्तव में फैंसी थे, तो आप एक बंधे स्केलर बना सकते हैं जिसमें @+ में अंतिम परिभाषित इंडेक्स का मूल्य है, मुझे लगता है।