मैं अभिव्यक्ति में पर्ल के /// का उपयोग कैसे कर सकता हूं?

Question

मुझे इसके लिए एक सिरदर्द मिला: आप एक असाइनमेंट के विपरीत अभिव्यक्ति में s /// का उपयोग कैसे करते हैं। स्पष्ट करने के लिए मैं क्या मतलब है, मैं अजगर के re.sub (...) का एक पर्ल बराबर की तलाश में हूँ जब निम्न संदर्भ में प्रयोग किया:

newstring = re.sub('ab', 'cd', oldstring) 

एक ही रास्ता मैं कैसे में यह करने के लिए पता पर्ल अब तक है:

$oldstring =~ s/ab/cd/; 
$newstring = $oldstring; 

नोट अतिरिक्त कार्यभार।

Answer 1

आपको =~ काम करता है के बारे में एक गलतफहमी प्रतीत होती है। =~ एक बाध्यकारी ऑपरेटर है जो एक चर को एक regexp ऑपरेटर के साथ जोड़ता है। यह कोई असाइनमेंट नहीं करता है।

रेगेक्सपी ऑपरेटर सभी विषय परिवर्तनीय $_ के साथ डिफ़ॉल्ट रूप से काम करते हैं, इसलिए s/foo/bar/;$_ =~ s/foo/bar/; जैसा ही है। कोई असाइनमेंट नहीं होता है। विषय चर बदल गया है।

मामला किसी भी अन्य चर पर काम करते समय समान है। $var =~ s/foo/bar/;foo के पहले उदाहरण को bar के साथ बदलकर $var को बदलता है। कोई असाइनमेंट नहीं होता है।

सबसे अच्छी सलाह जो मैं आपको दे सकता हूं वह पर्ल में पायथन और पर्ल में पर्ल लिखना है। दो भाषाओं की अपेक्षा न करें।

आप ऐसा कर सकते हैं जैसे डीवीके सुझाव देता है और एक सबराउटिन लिखता है जो आपके द्वारा उपयोग किए जाने वाले प्रतिस्थापन व्यवहार को पुन: पेश करेगा।

या आप कुछ बेवकूफ पर्ल कोशिश कर सकते हैं।एक पंक्ति में कई परिवर्तनों को लागू करने की आपकी व्यक्त इच्छा के आधार पर, मैंने कुछ उदाहरण प्रदान किए हैं जो आपको उपयोगी लग सकते हैं।

यहाँ मैं $var topicalize और कई हार्ड-कोडेड परिवर्तनों को लागू करने के एक आइटम पर एक for पाश का उपयोग करें:

for($var) { 
    s/foo/bar/; 
    s/fizz/buzz/; 
    s/whop/bop-a-loo-bop/; 
    s/parkay/butter/; 
    s/cow/burger/; 
} 

या शायद आप रूपांतरण के एक चर समूह आवेदन करना होगा। मैं पुराने/नए परिवर्तन जोड़े को परिभाषित करने वाले सरणी संदर्भों की एक सूची पर लूप को एक सबराउटिन परिभाषित करता हूं। यह उदाहरण किसी भी प्रकार के परिवर्तनों को संभालने के लिए पर्ल की सूची उन्मुख तर्क प्रसंस्करण का लाभ उठाता है।

my $foo = transform(
    'abcd' => 
    [ 'a', 'b' ], 
    [ 'bb', 'c' ], 
    [ 'cc', 'd' ], 
    [ 'dd', 'DONE' ], 
); 

sub transform { 
    my $var = shift; 
    for (@_) { 
     my ($old, $new) = @$_; 
     $var =~ s/$old/$new/; 
    } 

    return $var; 
} 

अंत के बारे में परिणत कि इसके पहले तर्क को संशोधित करता है एक संस्करण प्रदान करने के लिए खिलवाड़ का एक सा: मैं शायद पहले दो के आधार पर किसी एक विकल्प का प्रयोग करेंगे मेरी अपनी परियोजना के लिए

my $foo = 'abcd'; 

transform_in_place(
    $foo => 
    [ 'a', 'b' ], 
    [ 'bb', 'c' ], 
    [ 'cc', 'd' ], 
    [ 'dd', 'DONE' ], 
); 

print "$foo\n"; 

sub transform_in_place { 
    for my $i (1..$#_) { 
     my ($old, $new) = @{$_[$i]}; 
     $_[0] =~ s/$old/$new/; 
    } 
} 

विशेष समस्या की जरूरत है।

Answer 2

आप एक बिल्कुल वैसा ही कार्यक्षमता के लिए ($new = $old) =~ s/whatever/whateverelse/; उपयोग कर सकते हैं आप देख रहे हैं:

use strict; 
my $old = "OLD"; 
my $new; 
($new = $old) =~ s/OLD/NEW/; 
print "old=$old, new=$new"; 

का उत्पादन:

old=OLD, new=NEW 

वास्तव में क्या आप

चाहते आप एक समारोह के लिए देख रहे हैं , आप असाइनमेंट से बचने के लिए बस अपना खुद का परिभाषित कर सकते हैं:

use strict; 
sub re_sub { 
    my ($find, $replace, $old) = @_; 
    my $new = $old; 
    $new =~ s/$find/$replace/; 
    return $new; 
} 

my $old = "ab"; 
my $new = re_sub('ab', 'cd', $old); 
print "new=$new\n"; 

new=cd में परिणाम।

Answer 3

पर्ल की नियमित अभिव्यक्ति प्रतिस्थापन हमेशा 'जगह' होता है। तो अगर आप एक नया वेरिएबल को स्ट्रिंग कॉपी और नया वेरिएबल पर काम करने की जरूरत है:

(my $newstring = $oldstring) =~ s/ab/cd/; 

Answer 4

आप $ newstring प्रतिस्थापन का परिणाम है, सही हो सकता है करना चाहते हैं?

कुछ इस तरह:

($newstring = $oldstring) =~ s/ab/cd; 

काम करना चाहिए। असाइनमेंट $newstring से $oldstring सेट करता है और फिर $newstring का मूल्यांकन करता है, जो प्रतिस्थापन कार्य करता है।

Answer 5

इस पर आधारित, क्या मुझे लगता है कि आपके पास एक पंक्ति में दो एस /// नहीं हो सकते हैं, जो कि दूसरे के परिणाम का उपयोग करता है, बिना मध्यवर्ती असाइनमेंट के? - माइक

हाँ आप सही हैं। मैं करना होगा कि आप एक ही स्ट्रिंग के लिए कई प्रतिस्थापन लागू करना चाहते हैं

$newstring = $oldstring ; 
    $newstring =~ s/ab/cd/ ; 
    $newstring =~ s/xx/yy/ ; 

क्योंकि s// बनाया प्रतिस्थापन की संख्या, नहीं बदली हुई स्ट्रिंग रिटर्न निम्नलिखित काम नहीं करेगा।

$newstring = $oldstring) =~ s/ab/cd/ =~ s/xx/yy/ ; 

सारांश में, पर्ल के regex संचालन पायथन के लिए बहुत अलग हैं और आप बेहतर नहीं बल्कि पर्ल पर पायथन अवधारणाओं को मैप करने के