स्वैप फ़ंक्शन तर्क

Question

जब रीफैक्टरिंग कोड यह फ़ंक्शन तर्कों को स्वैप करने में सक्षम होने के लिए उपयोगी होगा।

उदाहरण के लिए परिवर्तन:

func(foo[0], bar(), baz.spam)

में

func(baz.spam, foo[0], bar())

क्या फ़ंक्शन कोष्ठक और अल्पविराम को यथावत रखते हुए, बाएँ / दाएँ तर्क को स्वैप करने का कोई तरीका है?

---

ध्यान दें, यह काफी हद तक शामिल हो सकता है यदि आप उन तर्कों का हिसाब लगाना चाहते हैं जो स्वयं अपने तर्कों के साथ फ़ंक्शन कॉल हैं - जैसे: func(baz->spam, foo[0], bar(a, b, c))- इन मामलों का समर्थन करने से संभवतः कुछ अधिक व्यापक पार्सिंग शामिल होगी।

Answer 1

प्लगइन्स के बिना

| कर्सर स्थिति इंगित करता है

func(foo[0], bar(), |baz.spam)

कदम:

1. dt) हटा देगा baz.spam
2. Ff कर्सर को वर्ण f में ले जाएगा foo[0]
3. vt,p फू को हटा देगा [0] और इसे बदलें baz.spam
4. $P मुर्गियों से पहले फू [0] चिपकाएँगे
5. किसी अन्य के लिए चरण 1-4 दोहराएं।

प्लगइन्स के साथ

• पीटर रिनकर द्वारा विम-तर्क : फ़ंक्शन तर्कों (डिफ़ॉल्ट मैपिंग: <,और >,) के चारों ओर घूमने के लिए पाठ ऑब्जेक्ट्स प्रदान करता है ।
• टॉम मैकडॉनल्ड द्वारा विम-एक्सचेंज : दो चयनों का आदान-प्रदान करने के लिए आसान मैपिंग प्रदान करता है (डिफ़ॉल्ट मैपिंग: cxसामान्य मोड में और Xदृश्य मोड में)।
• एंड्रयू Radev द्वारा vim-sideways : फ़ंक्शन तर्क (और अन्य सीमांकित-द्वारा-कुछ आइटम) बाएँ और दाएँ ले जाएँ (डिफ़ॉल्ट मैपिंग:) NA।
• vim-swap by machakann : पुन : सीमांकित आइटम (डिफ़ॉल्ट मैपिंग: g<और g>)।

Comments

नॉन-प्लगइन सॉल्यूशन केस के लिए बहुत विशिष्ट है ...

— elyashiv

@elyashiv विचार यह है कि आप किसी भी फ़ंक्शन तर्क के लिए एक समान तकनीक का उपयोग कर सकते हैं। मूल रूप से, एक शब्द को यैंक करें, नेत्रहीन एक और शब्द, पेस्ट का चयन करें, जो विम हटाए गए चरित्र को रजिस्टर में जमा कर देगा, और फिर पेस्ट करें जहां आप पहले से yanked थे।

— अक्षय

विम-बग़ल में +1! अंतिम खंड एक बहुत अच्छी सुविधा का वर्णन करता है: cia "तर्क में परिवर्तन"। ❤️

— मार्टिन Courteaux

Answer 2

मैं 3 विधियाँ प्रस्तुत करता हूँ। पहले दो विशेष मामले हैं, जिन्हें कम कीस्ट्रोक्स की आवश्यकता होती है। अंतिम एक सामान्य है। |कर्सर स्थिति का प्रतिनिधित्व करता है।

---

आसन्न तर्क स्वैप करें (पिछले दो के लिए काम नहीं करता है)

function func(foo[0], |bar(), baz.spam, qux->norf)

कदम:

1. dW वर्तमान शब्द हटाएं (तर्क)
2. W अगले तर्क के पहले चार पर जाएं
3. P कर्सर से पहले पेस्ट करें

अंतिम दो तर्क स्वैप करें

function func(foo[0], bar()|, baz.spam, qux->norf)

कदम:

1. dt, अगले कॉमा तक हटाएं
2. E अगले तर्क के अंतिम चरित्र पर जाएं
3. P कर्सर से पहले पेस्ट करें

किन्हीं दो तर्कों को स्वैप करें

function func(|foo[0], bar(), baz.spam, qux->norf)

कदम:

1. vt,d अल्पविराम तक हटाएं
2. W कई बार जब तक आप उस तर्क तक नहीं पहुंच जाते, जिसे आप स्वैप करना चाहते हैं
3. gP पेस्ट करने से पहले पेस्ट करें और पेस्ट की गई सामग्री के बाद कर्सर को कर्सर पर रखें
4. dt,अगले कॉमा तक हटाएं की जगह ,से )अगर यह अंतिम तर्क है
5. `< अंतिम दृश्य क्षेत्र की शुरुआत पर वापस जाएं (कर्सर अल्पविराम पर रखा जाएगा)
6. P कर्सर से पहले पेस्ट करें

---

संपादित करें: जैसा कि @ aharris88 द्वारा इंगित किया गया है कि ओपी चाहता है कि अंतिम तर्क पहले हो और बाकी सभी सही हों।

तर्क को दाईं ओर घुमाएं

function func(foo[0], bar(), baz.spam|, qux->norf)

कदम:

1. dw हटाना ,␣
2. dt) अंतिम तर्क हटाएं
3. %p कोष्ठक खोलने और अंतिम तर्क पेस्ट करने के लिए कूदो
4. a,␣ अल्पविराम और स्थान डालें
5. <Esc> सामान्य मोड पर लौटें

या, यदि आप कभी सामान्य मोड नहीं छोड़ना चाहते हैं:

1. "rdw,␣एक रजिस्टर में हटा देंr
2. dt) अंतिम तर्क हटाएं
3. %p कोष्ठक खोलने और अंतिम तर्क पेस्ट करने के लिए कूदो
4. "rp रजिस्टर की सामग्री पेस्ट करें r

---

बोनस: प्रत्येक मामले के लिए एक GIF: swap1 , swap2 , swap3 और घुमाएं

Comments

हालांकि यह जवाब स्वैप तर्क देता है, यह सवाल का जवाब नहीं देता है, जो आखिरी तर्क को शुरुआत में स्थानांतरित करना है।

— अहरिश a

@ aharris88, आप सही हैं। मैंने अपना उत्तर संपादित किया।

— गोंकोलो रिबेरो 19