मैं विम या पर्ल में एक भी नियमित अभिव्यक्ति में एक से अधिक आइटम स्थानापन्न कर सकते हैं?

Question

मान लीजिए कि मैं स्ट्रिंग है मैं एक नियमित अभिव्यक्ति के साथ "धीमी गति से भूरी लोमड़ी ऊर्जावान कुत्ते पर कूदता है" करने के लिए इसे बदल सकते हैं "जल्दी भूरी लोमड़ी आलसी कुत्ते पर कूदता है" चलो? वर्तमान में, मैं इस स्थिति के लिए नियमित अभिव्यक्तियों के दो सेट का उपयोग करता हूं। (इस मामले में, मैं s/quick/slow/ का उपयोग करता हूं जिसके बाद s/lazy/energetic/ है।)

Answer 1

प्रतिस्थापन का दूसरा भाग एक डबल उद्धृत स्ट्रिंग है, इसलिए कोई भी सामान्य इंटरपोलेशन हो सकता है। इसका मतलब है आप एक हैश में सूचकांक को कब्जा के मूल्य का उपयोग कर सकते हैं:

#!/usr/bin/perl 

use strict; 
use warnings; 


my %replace = (
    quick => "slow", 
    lazy => "energetic", 
); 

my $regex = join "|", keys %replace; 
$regex = qr/$regex/; 

my $s = "The quick brown fox jumps over the lazy dog"; 

$s =~ s/($regex)/$replace{$1}/g; 

print "$s\n"; 

Answer 2

आप निम्न कार्य कर सकते हैं।

:%s/quick\(.*\)lazy/slow\1energetic 

चाल दो शब्दों के बीच पाठ से मेल खाने के लिए अभिभावकों का उपयोग करना है। इसके बाद आप \1 का उपयोग करके प्रतिस्थापन स्ट्रिंग में इस पाठ को संदर्भित कर सकते। आप दूसरे मिलान किए गए अभिभावक अभिव्यक्ति के लिए \2 का भी उपयोग कर सकते हैं। यह आपको टेक्स्ट के बीच पाठ को परेशान किए बिना एकाधिक शब्दों को प्रतिस्थापित करने की अनुमति देता है।

Answer 3

पर्ल में:

s/quick(.*)lazy/slow${1}energetic/; 

vim में:

s/quick\(.*\)lazy/slow\1energetic/; 

Answer 4

एक साफ रास्ता यह करने के लिए नहीं है रुबी में gsub ब्लॉक के साथ:

s = "The quick brown fox jumps over the lazy dog" 
subs = {'quick' => 'slow', 'lazy' => 'industrious'} 
s.gsub(/quick|lazy/) { |match| subs[match] } 
# => "The slow brown fox jumps over the industrious dog" 

Answer 5

आप एक शब्दकोश का उपयोग कर vim में ऐसा कर सकते हैं:

त्वरित भूरी लोमड़ी त्वरित ly आलसी ब्रूक के बगल में भाग गया:

:%s/quick\|lazy/\={'quick':'slow','lazy':'energetic'}[submatch(0)]/g 

यह निम्न पाठ बदल जाएगा।

में:

धीमी भूरी लोमड़ी धीमी ly ऊर्जावान ब्रूक के बगल में भाग गया।

यह देखने के लिए कि यह कैसे काम करता है, :help sub-replace-expression और :help Dictionary देखें। संक्षेप में,

• \= आपको एक विम अभिव्यक्ति के परिणामस्वरूप प्रतिस्थापित करने देता है।
• {'quick':'slow', 'lazy':'energetic'} एक vim शब्दकोश (पर्ल या गहरे लाल रंग का, या जावास्क्रिप्ट में एक वस्तु में एक हैश की तरह) लुकअप के लिए [] उपयोग करता है।
• submatch(0) मिलान किया स्ट्रिंग

यह जब कोड पुनर्रचना काम में आ सकते हैं - कहते हैं कि तुम foo, bar के लिए चर नाम का आदान-प्रदान करना चाहते हैं, और baz बदलते

• foo → bar
• bar → baz
• baz → foo

%s/// आदेशों की एक दृश्य का उपयोग करना मुश्किल हो सकता है, जब तक आप अस्थायी चर नाम का इस्तेमाल किया है - लेकिन क्या आप वाकई उन कुछ और पूरा उपयोग नहीं कर रहे थे बनाने के लिए होगा। इसके बजाय, आप एक पास में यह करने के लिए एक शब्दकोश का उपयोग कर सकते हैं:

:%s/\<\%(foo\|bar\|baz\)\>/\={'foo':'bar','bar':'baz','baz':'foo'}[submatch(0)]/g 

कौन इस कोड

int foo = 0; 
float bar = pow(2.0, (float) foo); 
char baz[256] = {}; 

sprintf(baz,"2^%d = %f\n", foo, bar); 

में बदल जाता है:

int bar = 0; 
float baz = pow(2.0, (float) bar); 
char foo[256] = {}; 

sprintf(foo,"2^%d = %f\n", bar, baz); 

यदि आप पाते हैं अपने आप को इस एक बहुत कर रही है, आप अपने ~/.vimrc:

" Refactor the given lines using a dictionary 
" replacing all occurences of each key in the dictionary with its value 
function! Refactor(dict) range 
    execute a:firstline . ',' . a:lastline . 's/\C\<\%(' . join(keys(a:dict),'\|'). '\)\>/\='.string(a:dict).'[submatch(0)]/ge' 
endfunction 

command! -range=% -nargs=1 Refactor :<line1>,<line2>call Refactor(<args>) 

012 में निम्नलिखित जोड़ना चाह सकते हैं

यह आपको :Refactor {'frog':'duck', 'duck':'frog'} कमांड का उपयोग करने देता है, और मैन्युअल रूप से मैन्युअल रूप से रेगेक्स बनाने की तुलना में थोड़ा कम दोहराव देता है। \ B

Answer 6

चास के जवाब अच्छा है, केवल दूसरी बात मैं उल्लेख करें कि यदि आप शब्द स्वैप कर रहे हैं तो आप शायद

\ b (| बार | | baz qux foo) पर मिलान किया जाना चाहते है

मिलान सबस्ट्रिंग से बचने के लिए। आप शब्द अदला-बदली की एक बहुत कर हैं, तो आप regexps थोड़ा सीमित खोजने के लिए शुरू करते हैं और तरह कुछ करने के लिए चाहते हो सकता है:

जल्दी भूरी लोमड़ी जल्दी से भाग गया:

join '', map { exists $subst{$_} ? $subst{$_} : $_ } split /\b/, $string 

Answer 7

आप vim प्रतिस्थापन जोड़ सकते हैं आलसी झील के बगल में।

:s/quick/slow/|s/lazy/energetic/ 

धीमी भूरी लोमड़ी जल्दी से ऊर्जावान ब्रूक के बगल में भाग गया।

लाभ यहाँ आप सिर्फ एक बार

Rgds