गति के साथ मानचित्रण

Question

मैं यह समझने की कोशिश कर रहा हूं कि मैं मैपिंग के अंदर बाद की गति के साथ ऑपरेटर का उपयोग कैसे कर सकता हूं। उदाहरण के लिए:

nmap /c c{here we pending for a motion}/<C-r>"<CR>

नक्शा निम्नलिखित करना चाहिए:

1. cऑपरेटर को सक्रिय करें और अगले प्रस्ताव के लिए सुनें;
2. जैसे, मैं t,अगले अल्पविराम से पहले सब कुछ बदलने के लिए यहां टाइप कर सकता हूं ;
3. कर्सर और अल्पविराम के बीच सब कुछ हटाने के मोड में जाएं;
4. हटाए गए पाठ को स्वचालित रूप से एक पैटर्न के रूप में खोजा जाता है

तो इसे सरल करने के लिए, मोशन टेक्स्ट को हटा दिए जाने के बाद, मुझे हटाए गए टेक्स्ट की हाइलाइट की गई घटनाओं के साथ इन्सर्ट मोड में लेट कर दिया जाता है। अगर कोई मुझे इस मामले को सुलझाने में मदद करेगा तो मैं बहुत आभारी रहूंगा।

अपडेट करें

उत्तर लगभग वही हैं जो मैं चाहता हूं। परंतु! जब मैं दबाता हूं /cw, तो शब्द के बजाय कुछ टाइप करें, फिर दबाएं <Esc>। मैं अगली घटनाओं के साथ भी ऐसा ही करने की उम्मीद करता हूं। लेकिन बाद में n(अगली घटना पर जाएं) और .(अंतिम आदेश को दोहराएं) यह प्रतिस्थापित करने के बजाय अंतिम टाइप किए गए पाठ को पूर्व निर्धारित करता है। मानचित्रण का मुख्य लक्ष्य इसे n/Nऔर .दोहराने के लिए उपयोग कर रहा है । क्या मुझे कुछ याद आया?

Answer 1

vim ऑपरेटर-मैपिंग का समर्थन करता है :h map-operator।

क्या आप की जरूरत है एक है operatorfunc, और एक मानचित्रण। आपकी आवश्यकताओं के लिए, अनुवर्ती कोड काम करते हैं। खैर यह सिर्फ एक उदाहरण है, आप और अधिक परिष्कृत करें।

nmap  <silent> /c :set opfunc=SpecialChange<CR>g@
function! SpecialChange(type)
    silent exec 'normal! `[v`]d'    
    silent exec 'let @/=@"' 
    startinsert
endfunction

ध्यान दें कि exec 'let @/=@"'बफर में कोड को हाइलाइट करने के लिए। यदि आप तुरंत हाइलाइटिंग नहीं देखना चाहते हैं, तो आप बस कर सकते हैंlet @/=@"

Comments

मैंने अपना प्रश्न अपडेट कर दिया है। ऐसा लगता है कि आपका उत्तर मेरी जरूरतों के सबसे करीब है, लेकिन यह अगली घटना के साथ ऐसा नहीं करता है, इसलिए मैंने उस क्षण को प्रश्न में समझाया है।

— तैमूर फ़ेज़्रख्मनोव

आपके पास दो ऑपरेटर हैं ( /cऔर i) .अंतिम को दोहराते हैं। यदि आप इसे बढ़ाना चाहते हैं, तो repeatप्लगइन की जाँच करें । @TimurFayzrakhmanov भी हैं :gऔर :sआदेश भी हैं , आपकी भी मदद कर सकते हैं।

— कैंट

क्या "आपके कोड में विषम है 'let @/=@""'? मैंने सोचा कि यह संभव है, उदाहरण के लिए silent exec 'normal! [v ]c', क्योंकि cऑपरेटर वही करता है जो मैं उम्मीद करता हूं, सिवाय इसके कि यह बदले हुए पाठ को खोज पैटर्न में नहीं जोड़ता है।

— तैमूर फैज़्रखमानोव

@TimurFayzrakhmanov "" एक टाइपो था .. ठीक है .. मैं cभी साथ आया था , हालांकि इसमें एक स्थान जोड़ा गया है, क्योंकि मोड परिवर्तन है n-i-n-iमुझे लगता है ... कुछ परीक्षण आप देखेंगे।

— कैंट

@TimurFayzrakhmanov आप इसे बदल कर किसी भी प्लगइन के बिना repeatable कर सकते हैं dकरने के लिए yऔर startinsertकरने के लिए call feedkeys("cgn", 'n')(नीचे मेरा उत्तर देखें)

— जेरोम Dalbert

Answer 2

कार्यों का उपयोग करके जटिल मैपिंग को लागू करना (और दस्तावेज़ में) करना आसान है:

function! DoMagic()
   execute "normal! d".input("enter motion: ")
   let @/=@"
   startinsert
endfunction

फिर उस फ़ंक्शन को अपनी मैपिंग कॉल करें:

nmap /c :call DoMagic()<CR>

---

संपादित करें:

आपका इरादा खोज करते हैं और स्थानों की एक बड़ी संख्या में बदलने के लिए है, तो आप विकल्प के आदेश की कोशिश करनी चाहिए: :s। दृश्य चयन को खोज पैटर्न में कॉपी करने के लिए आप अपनी मैपिंग बदल सकते हैं:

function! DoMagic2()
   normal! gv"ay
   return @a
endfunction

vmap /c :<c-w>%s/<C-r>=DoMagic2()<CR>//gc<left><left><left>

Comments

यह "अच्छा" UI के साथ भी है, ओपी की आवश्यकता के लिए काम करता है, और उम्मीद से "अधिक" हो सकता है, आप क्या इनपुट पर निर्भर करते हैं। जैसे जब कोई देखता है enter motion:, तो उसने दिया: t,ggVGJZZ ^ _ ^ यह कमांड कंफर्ट के लिए एक आम समस्या है

— Kent

मैं लगभग यही चाहता हूं। उदा: मैं प्रेस करता हूं /cwतब शब्द के बजाय कुछ टाइप करें, फिर दबाएं <Esc>। मैं अगली घटनाओं के साथ भी ऐसा ही करना चाहता हूं। लेकिन बाद में n(अगली घटना पर जाएं) और .(अंतिम आदेश को दोहराएं) यह प्रतिस्थापित करने के बजाय अंतिम टाइप किए गए पाठ को पूर्व निर्धारित करता है। मानचित्रण का मुख्य लक्ष्य इसे n/Nऔर .दोहराने के लिए उपयोग कर रहा है । क्या मुझे कुछ याद आया?

— तैमूर फ़ेज़्रख्मनोव

यह फ़ंक्शन फ़ंक्शंस का उपयोग करने के विचार को स्पष्ट करने के लिए है जब आपको जटिल मैपिंग में परेशानी होती है। आपको अपनी आवश्यकताओं को पूरा करने के लिए इसे बदलना चाहिए; .अपने आदेश को दोहराने के लिए केंट की सलाह का पालन करें।

— mMontu

जवाब के लिए धन्यवाद। यह बहुत उपयोगी है, लेकिन मैं @Kent के एक स्वीकार करते हैं, क्योंकि यह गति के तुरंत बाद मैं उन्हें टाइप (लंबित बिना क्या <CR>से input())।

— तैमूर फैज़्रखमानोव

@TimurFayzrakhmanov आप भी विकल्प की कोशिश कर सकते हैं, जैसा कि अद्यतन में बताया गया है।

— mMontu

Answer 3

यह समाधान "अंतिम कमांड दोहराएं" (उर्फ .) के साथ काम करता है :

nmap <silent> /c :set opfunc=ChangeOccurence<CR>g@

function! ChangeOccurence(type)
  exec 'normal! `[v`]y'
  let @/ = @"
  call feedkeys('cgn', 'n')
endfunction

जब दोहराते हैं, तो आपको उपयोग करने की भी आवश्यकता नहीं होती है n, .यदि आप तेजी से जाना चाहते हैं, तो आप सीधे उपयोग कर सकते हैं और अगली घटना को बदल सकते हैं।

वैकल्पिक रूप से, अगर आप होने मिलान शब्द का मुख्य आकर्षण की तरह, आप बदल सकते हैं 'cgn'द्वारा 'n``cgn'।