पर्ल रेगेक्स बनाम राकू रेगेक्स, इंजन में अंतर?


10

मैं पर्ल से रैकु तक की समस्या के लिए एक रेगेक्स आधारित समाधान को बदलने की कोशिश कर रहा हूं। Perlmonks पर विवरण

पर्ल समाधान इस regex बनाता है:

(?<P>(?:vvvvvvvvvv)?)
(?<B>(?:vv)?)
(?<Y>(?:vvvv)?)
(?<G>(?:vv)?)
(?<R>(?:v)?)
0
(?=
(?(?{ $1 })wwww|)
(?(?{ $2 })w|)
(?(?{ $3 })wwwwwwwwwwww|)
(?(?{ $4 })ww|)
(?(?{ $5 })w|)
)

जिसका मिलान हो जाता है vvvvvvvvvvvvvvvvvvv0wwwwwwwwwwwwwww। उसके बाद मैच हैश %+में आइटम को बोरी में रखना है।

मेरा रकु रूपांतरण है:

$<B> = [ [ vv ]? ]
$<P> = [ [ vvvvvvvvvv ]? ]
$<R> = [ [ v ]? ]
$<Y> = [ [ vvvv ]? ]
$<G> = [ [ vv ]? ]
0
<?before
[ { say "B"; say $/<B>; say $0; say $1; $1 } w || { "" } ]
[ { say "P"; say $/<P>; say $0; say $1; $2 } wwww || { "" } ]
[ { say "R"; say $/<R>; say $0; say $1; $3 } w || { "" } ]
[ { say "Y"; say $/<Y>; say $0; say $1; $4 } wwwwwwwwwwww || { "" } ]
[ { say "G"; say $/<G>; say $0; say $1; $5 } ww || { "" } ]

जो मेल खाता है vvvvvvvvvvvvvvvvvvv0wwwwwwwwwwwwwww। लेकिन मैच ऑब्जेक्ट, $/कुछ भी उपयोगी नहीं है। इसके अलावा, मेरे डिबग sayसभी को नील कहते हैं, इसलिए उस बिंदु पर पीछे हटने का काम नहीं लगता है?

यहाँ मेरा परीक्षण स्क्रिप्ट है:

my $max-weight = 15;
my %items      =
    'R' => { w =>  1, v =>  1 },
    'B' => { w =>  1, v =>  2 },
    'G' => { w =>  2, v =>  2 },
    'Y' => { w => 12, v =>  4 },
    'P' => { w =>  4, v => 10 }
;

my $str = 'v' x  %items.map(*.value<v>).sum ~
          '0' ~
          'w' x  $max-weight;

say $str;

my $i = 0;
my $left = my $right = '';

for %items.keys -> $item-name
{
    my $v = 'v' x %items{ $item-name }<v>;
    my $w = 'w' x %items{ $item-name }<w>;

     $left  ~= sprintf( '$<%s> = [ [ %s ]? ] ' ~"\n", $item-name, $v );
     $right ~= sprintf( '[ { say "%s"; say $/<%s>; say $0; say $1; $%d } %s || { "" } ]' ~ "\n", $item-name, $item-name, ++$i, $w );
}
use MONKEY-SEE-NO-EVAL;

my $re = sprintf( '%s0' ~ "\n" ~ '<?before ' ~ "\n" ~ '%s>' ~ "\n", $left, $right );

say $re;
dd $/ if $str ~~ m:g/<$re>/;

1
FYI करें, रक्कु प्रश्नों को PerlMonks
ikegami

जवाबों:


1

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

my $lex-var;

sub debug { .say for ++$, :$<rex-var>, :$lex-var }

my $regex = / $<rex-var> = (.) { $lex-var = $<rex-var> } <?before . { debug }> / ;

'xx' ~~   $regex;     say $/;
'xx' ~~ / $regex /;   say $/;

प्रदर्शित करता है:

1
rex-var => Nil
lex-var => x
x
 rex-var => x
2
rex-var => Nil
lex-var => x
x

पहले कॉल पर ध्यान केंद्रित करना debug(इसके साथ शुरू 1होने वाली और समाप्त होने वाली लाइनें rex-var => 「x」), हम यह देख सकते हैं:

  • कॉल के दौरान कुछ गड़बड़ हो गया है debug: $<rex-var>मान के रूप में बताया गया है Nil

  • जब रेगेक्स मैच पूरा होता है और हम मेनलाइन पर लौटते हैं, तो say $/एक पूर्ण और सही ढंग से आबाद परिणाम की रिपोर्ट करता है जिसमें rex-varनामित मैच शामिल है।

क्या गलत हो गया है की एक भावना प्राप्त करने के लिए, कृपया मेरे उत्तर का एक और SO प्रश्न पढ़ने पर विचार करें । आप सुरक्षित रूप से प्रयोग~ छोड़ सकते हैं । फुटनोट्स 1,2, और 6 भी शायद आपके परिदृश्य के लिए पूरी तरह अप्रासंगिक हैं।

दूसरे मैच के लिए, हम देखते हैं कि न केवल कॉल के दौरान $<rex-var>होने की सूचना है , अंतिम मैच चर, जैसा कि दूसरी के साथ मेनलाइन में वापस रिपोर्ट किया गया है , वह भी मैच को याद नहीं कर रहा है । और एकमात्र अंतर यह है कि रेगेक्स को बाहरी रेगेक्स के भीतर से बुलाया जाता है ।Nildebugsay $/rex-var$regex

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.