vim - keys - विम के साथ आपका सबसे अधिक उत्पादक शॉर्टकट क्या है?




शॉर्टकट मेनू (20)

मैंने Vim , पेशेवरों और विपक्ष दोनों के बारे में बहुत कुछ सुना है। ऐसा लगता है कि आपको किसी भी अन्य संपादक की तुलना में विम के साथ तेजी से (डेवलपर के रूप में) होना चाहिए। मैं कुछ बुनियादी चीजें करने के लिए विम का उपयोग कर रहा हूं और मैं विम के साथ 10 गुना कम उत्पादक हूं।

जब आप गति के बारे में बात करते हैं तो केवल दो चीजों की परवाह करनी चाहिए (आप उनके बारे में पर्याप्त परवाह नहीं कर सकते हैं, लेकिन आपको चाहिए) हैं:

  1. वैकल्पिक रूप से बाएं और दाएं हाथों का उपयोग करना कीबोर्ड का उपयोग करने का सबसे तेज़ तरीका है।
  2. जितना तेज़ हो सके माउस को छूना दूसरा तरीका नहीं है। आपके हाथों को स्थानांतरित करने, माउस को पकड़ने, इसे स्थानांतरित करने और इसे कीबोर्ड पर वापस लाने में उम्र लगती है (और आपको यह सुनिश्चित करने के लिए कीबोर्ड पर देखना होगा कि आपने अपना हाथ सही जगह पर सही तरीके से वापस कर दिया हो)

यहां दो उदाहरण दिए गए हैं कि मैं विम के साथ बहुत कम उत्पादक क्यों हूं।

कॉपी / कट और पेस्ट करें। मुझे हर व़क्त यह करना है। सभी समकालीन संपादकों के साथ आप बाईं ओर शिफ्ट दबाते हैं, और आप पाठ का चयन करने के लिए कर्सर को अपने दाहिने हाथ से ले जाते हैं। फिर Ctrl + C प्रतियां, आप कर्सर और Ctrl + V पेस्ट को ले जाते हैं।

विम के साथ यह भयानक है:

  • एक लाइन की प्रतिलिपि बनाने के लिए yy (आप लगभग पूरी लाइन कभी नहीं चाहते!)
  • [number xx]yy xx लाइनों को बफर में कॉपी करने के लिए [number xx]yy । लेकिन आप कभी नहीं जानते कि आपने जो चुना है उसे चुना है। मुझे अक्सर [number xx]dd करना पड़ता है तो u पूर्ववत करना चाहते हैं!

एक और उदाहरण? खोजें और बदलें।

  • PSPad : Ctrl + f फिर टाइप करें जिसे आप खोजना चाहते हैं, फिर एंटर दबाएं
  • विम में: / , फिर टाइप करें जिसे आप खोजना चाहते हैं, फिर यदि कुछ विशेष वर्ण प्रत्येक विशेष चरित्र से पहले \ डालते हैं, तो एंटर दबाएं

और विम के साथ सब कुछ इस तरह है: ऐसा लगता है कि मुझे नहीं पता कि इसे सही तरीके से कैसे संभालना है।

एनबी: मैंने पहले ही विम cheat sheet पढ़ी है :)

मेरा सवाल यह है कि:

विम का उपयोग करने का तरीका क्या है जो आपको समकालीन संपादक के मुकाबले ज्यादा उत्पादक बनाता है?


What is the way you use Vim that makes you more productive than with a contemporary editor?

Being able to execute complex, repetitive edits with very few keystrokes (often using macros ). Take a look at VimGolf to witness the power of Vim!

After over ten years of almost daily usage, it's hard to imagine using any other editor.


विम प्लगइन्स

यहां बहुत सारे अच्छे उत्तर हैं, और वी के ज़ेन के बारे में एक अद्भुत है। एक बात जो मैंने नहीं देखी है वह यह है कि विम प्लगइन के माध्यम से बेहद एक्स्टेंसिबल है। स्क्रिप्ट और प्लगइन्स हैं जो इसे सभी प्रकार की पागल चीजें करने के लिए मूल लेखक कभी नहीं मानते हैं। अविश्वसनीय रूप से आसान vim प्लगइन्स के कुछ उदाहरण यहां दिए गए हैं:

rails.vim

Rails.vim एक प्लगइन tpope द्वारा लिखा है। यह रेल विकास के लिए लोगों के लिए एक अविश्वसनीय उपकरण है। यह जादुई संदर्भ-संवेदनशील चीजें करता है जो आपको नियंत्रक में किसी विधि से संबंधित दृश्य तक, मॉडल पर, और उस मॉडल के लिए यूनिट परीक्षणों तक आसानी से कूदने की अनुमति देता है। रेलवे डेवलपर के रूप में सैकड़ों घंटे नहीं होने पर उसने दर्जनों को बचाया है।

gist.vim

यह प्लगइन आपको विजुअल मोड में टेक्स्ट का एक क्षेत्र चुनने और gist.github.com पर पोस्ट करने के लिए एक त्वरित कमांड टाइप करने की अनुमति देता है । यह आसान पेस्टबिन पहुंच के लिए अनुमति देता है, जो अविश्वसनीय रूप से आसान है यदि आप आईआरसी या आईएम पर किसी के साथ सहयोग कर रहे हैं।

space.vim

यह प्लगइन स्पेसबार को विशेष कार्यक्षमता प्रदान करता है। यह स्पेसबार को अवधि के समान कुछ में बदल देता है, लेकिन क्रियाओं को दोहराने के बजाय यह गति को दोहराता है। एक फ्लाई पर परिभाषित तरीके से फ़ाइल के माध्यम से तेज़ी से आगे बढ़ने के लिए यह बहुत आसान हो सकता है।

surround.vim

यह प्लगइन आपको कुछ फैशन में सीमित पाठ के साथ काम करने की क्षमता देता है। यह आपको ऑब्जेक्ट देता है जो चीजों के अंदर चीजों को इंगित करता है, कोट्स के अंदर चीजें इत्यादि। यह सीमित पाठ में हेरफेर करने के लिए आसान हो सकता है।

supertab.vim

यह स्क्रिप्ट विम के लिए फैंसी टैब पूर्णता कार्यक्षमता लाती है। स्वत: पूर्ण सामग्री पहले से ही विम के मूल में है, लेकिन यह कई अलग-अलग मल्टीकी शॉर्टकट के बजाय इसे त्वरित टैब पर लाती है। उपयोग करने के लिए बहुत आसान, और अविश्वसनीय रूप से मजेदार। हालांकि यह वीएस की इंटेलिजेंस नहीं है, यह एक अच्छा कदम है और एक टैब पूर्णता उपकरण से आप जिस कार्यक्षमता की अपेक्षा करना चाहते हैं, उसका एक बड़ा सौदा लाता है।

syntastic.vim

यह टूल बाहरी सिंटैक्स जांच कमांड को vim में लाता है। मैंने इसे व्यक्तिगत रूप से उपयोग नहीं किया है, लेकिन मैंने इसके बारे में महान चीजें सुनी हैं और अवधारणा को हरा करना मुश्किल है। इसे मैन्युअल रूप से करने के बिना सिंटैक्स की जांच करना एक अच्छा समय बचाने वाला है और जब आप अंततः परीक्षण करना बंद कर देते हैं, तो आप उन्हें सिंटैक्टिक बग पकड़ने में मदद कर सकते हैं।

fugitive.vim

विम के अंदर से गिट तक सीधी पहुंच। दोबारा, मैंने इस प्लगइन का उपयोग नहीं किया है, लेकिन मैं उपयोगिता देख सकता हूं। दुर्भाग्य से मैं ऐसी संस्कृति में हूं जहां svn को "नया" माना जाता है, इसलिए मुझे कुछ समय तक काम पर गिट दिखाई नहीं देगी।

nerdtree.vim

विम के लिए एक पेड़ ब्राउज़र। मैंने हाल ही में इसका उपयोग शुरू किया, और यह वास्तव में आसान है। यह आपको एक लंबवत विभाजन में खुली फ़ाइलों को आसानी से खोलने देता है। यह एक ऐसी परियोजना के लिए बहुत अच्छा है जिसमें बहुत से स्रोत फाइलें होती हैं जिन्हें आप अक्सर कूदते हैं।

FuzzyFinderTextmate.vim

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

निष्कर्ष

विम के लिए बहुत सारे अविश्वसनीय उपकरण उपलब्ध हैं। मुझे यकीन है कि मैंने केवल सतह को खरोंच कर लिया है, और यह आपके डोमेन पर लागू टूल्स के लिए खोज करने योग्य है। परंपरागत वी के शक्तिशाली टूलसेट का संयोजन, इसके बारे में विम के सुधार, और प्लगइन्स जो आगे बढ़ते हैं, यह कभी भी कल्पना किए गए पाठ को संपादित करने के सबसे शक्तिशाली तरीकों में से एक है। विम आसानी से emacs, ग्रहण, दृश्य स्टूडियो, और textmate के रूप में शक्तिशाली है।

धन्यवाद

duwanis को उनके विम कॉन्फ़िगरेशन के लिए धन्यवाद, जिनसे मैंने बहुत कुछ सीखा है और यहां सूचीबद्ध अधिकांश प्लगइन उधार लिया है।


विम के साथ आपकी समस्या यह है कि आप vi grok नहीं है।

आप yy साथ काटने का जिक्र करते हैं और शिकायत करते हैं कि आप लगभग पूरी लाइनों को काटना नहीं चाहते हैं। वास्तव में प्रोग्रामर, संपादन स्रोत कोड, अक्सर पूरी लाइनों, लाइनों की रेखाओं और कोड के ब्लॉक पर काम करना चाहते हैं। हालांकि, yy अज्ञात प्रतिलिपि बफर में टेक्स्ट को यंक करने के कई तरीकों में से एक है (या "रजिस्टर" जैसा कि इसे vi में कहा जाता है)।

वी का "जेन" यह है कि आप एक भाषा बोल रहे हैं। प्रारंभिक y एक क्रिया है। कथन yy y_ लिए समानार्थी है। y को टाइप करना आसान बनाने के लिए दोगुना हो गया है, क्योंकि यह एक आम ऑपरेशन है।

इसे dd P रूप में भी व्यक्त किया जा सकता है (वर्तमान रेखा को हटाएं और एक प्रतिलिपि को जगह में पेस्ट करें; अज्ञात रजिस्टर में प्रतिलिपि को साइड इफेक्ट के रूप में छोड़ दें)। y और d "क्रियाएं" उनके "विषय" के रूप में किसी भी आंदोलन लेते हैं। इस प्रकार yW "यहां से (कर्सर) वर्तमान / अगले (बड़े) शब्द के अंत तक y'a है" और y'a "यहां से y'a को ' ' नामक चिह्न वाली रेखा से y'a है।"

यदि आप केवल मूल ऊपर, नीचे, बाएं, और सही कर्सर आंदोलनों को समझते हैं तो vi आपके लिए "नोटपैड" की प्रति से अधिक उत्पादक नहीं होगा। (ठीक है, आपके पास अभी भी सिंटैक्स हाइलाइटिंग होगी और एक पिडलिंग ~ 45 केबी से भी बड़ी फ़ाइलों को संभालने की क्षमता होगी, लेकिन यहां मेरे साथ काम करें)।

vi में 26 "अंक" और 26 "पंजीयक" हैं। m कमांड का उपयोग कर किसी भी कर्सर स्थान पर एक चिह्न सेट किया गया है। प्रत्येक चिह्न को एक निचले केस अक्षर द्वारा नामित किया जाता है। इस प्रकार mz वर्तमान स्थान पर ' ' चिह्न सेट करता है, और mz ' z ' चिह्न सेट करता है। आप ' (सिंगल कोट) कमांड का उपयोग करके एक चिह्न वाले रेखा पर जा सकते हैं। इस प्रकार 'a ' 'चिह्न वाली रेखा की शुरुआत में 'a चाल। आप ` (बैकक्वॉट) कमांड का उपयोग करके किसी भी चिह्न के सटीक स्थान पर जा सकते हैं। इस प्रकार `z ' z ' चिह्न के सटीक स्थान पर सीधे स्थानांतरित हो जाएगा।

चूंकि ये "आंदोलन" हैं, इसलिए उन्हें अन्य "बयानों" के लिए विषयों के रूप में भी इस्तेमाल किया जा सकता है।

इसलिए, पाठ के मनमाना चयन को काटने का एक तरीका एक निशान छोड़ना होगा (मैं आमतौर पर ' ' का उपयोग अपने "पहले" चिह्न के रूप में करता हूं, ' जेड ' के रूप में मेरे अगले चिह्न, ' बी ' के रूप में, और ' ' के रूप में फिर भी एक और (मुझे कभी भी वीआई का उपयोग करने के 15 वर्षों में चार से अधिक अंकों का उपयोग करने की याद नहीं है; एक व्यक्ति अपने स्वयं के सम्मेलनों को बनाता है कि मैक्रोज़ द्वारा अंक और रजिस्टरों का उपयोग कैसे किया जाता है जो किसी के इंटरैक्टिव संदर्भ को परेशान नहीं करते हैं)। फिर हम जाते हैं हमारे वांछित पाठ के दूसरे छोर पर; हम किसी भी अंत में शुरू कर सकते हैं, इससे कोई फर्क नहीं पड़ता। फिर हम प्रतिलिपि बनाने के लिए कट या y`a का उपयोग कर सकते हैं। इस प्रकार पूरी प्रक्रिया में 5 कीस्ट्रोक ओवरहेड (छः अगर हमने "डालने" मोड में शुरू किया है और एएससी आउट कमांड मोड की आवश्यकता है)। एक बार जब हमने कट या कॉपी किया है तो एक प्रतिलिपि में पेस्ट करना एक सिंगल कीस्ट्रोक है: p

मैं कहता हूं कि टेक्स्ट को काट या कॉपी करने का यह एक तरीका है। हालांकि, यह केवल कई में से एक है। अक्सर हम अपने कर्सर को चारों ओर घुमाने और निशान छोड़ने के बिना पाठ की सीमा का अधिक संक्षेप में वर्णन कर सकते हैं। उदाहरण के लिए यदि मैं पाठ के अनुच्छेद में हूं तो मैं क्रमशः अनुच्छेद की शुरुआत या अंत में { और } आंदोलनों का उपयोग कर सकता हूं। तो, पाठ के अनुच्छेद को स्थानांतरित करने के लिए मैंने इसे { d} (3 कीस्ट्रोक) का उपयोग करके काट दिया। (यदि मैं पैराग्राफ की पहली या आखिरी पंक्ति पर पहले से ही होता हूं तो मैं बस क्रमशः d} या d{ उपयोग कर सकता हूं।

"पैराग्राफ" की धारणा कुछ ऐसी चीज से चूक जाती है जो आमतौर पर सहजता से उचित होती है। इस प्रकार यह अक्सर कोड के साथ-साथ गद्य के लिए भी काम करता है।

अक्सर हम कुछ पैटर्न (नियमित अभिव्यक्ति) को जानते हैं जो एक अंत या दूसरे पाठ को चिह्नित करते हैं जिसमें हम रुचि रखते हैं। आगे या पीछे की खोज vi में आंदोलन हैं। इस प्रकार वे हमारे "बयान" में "विषयों" के रूप में भी इस्तेमाल किया जा सकता है। इसलिए मैं मौजूदा लाइन से "पिछली पंक्ति" वाली पंक्ति में "वर्तमान" रेखा को कॉपी करने के लिए स्ट्रिंग "फू" और y?bar वाली अगली पंक्ति में कटौती करने के लिए d/foo का उपयोग कर सकता हूं। अगर मैं पूरी लाइन नहीं चाहता हूं तो भी मैं खोज आंदोलनों (अपने स्वयं के बयान के रूप में) का उपयोग कर सकता हूं, अपना निशान छोड़ सकता हूं और पहले बताए गए `x कमांड का उपयोग कर सकता हूं।

"क्रियाएं" और "विषयों" वी के अलावा "ऑब्जेक्ट्स" (शब्द की व्याकरणिक अर्थ में) भी है। अब तक मैंने केवल अनाम पंजीकरण के उपयोग का वर्णन किया है। हालांकि, मैं "ऑब्जेक्ट" संदर्भ को " (डबल कोट मॉडिफायर) के साथ उपसर्ग करके 26" नामित "रजिस्टरों में से किसी एक का उपयोग कर सकता हूं। इस प्रकार यदि मैं "add उपयोग करता हूं तो मैं वर्तमान लाइन को ' ' रजिस्टर में काट रहा हूं और यदि मैं "by/foo उपयोग करता हूं, फिर मैं ' बी ' रजिस्टर में" foo "युक्त अगली पंक्ति में पाठ की प्रतिलिपि बना रहा हूं। रजिस्टर से पेस्ट करने के लिए मैं पेस्ट को उसी संशोधक अनुक्रम के साथ उपसर्ग करता हूं: "ap कर्सर के बाद पाठ में ' ' रजिस्टर की सामग्री की एक प्रति "bP और "bP वर्तमान पंक्ति से पहले ' बी ' से एक प्रति "bP

"उपसर्ग" की यह धारणा भी हमारे टेक्स्ट मैनिपुलेशन "भाषा" में व्याकरणिक "विशेषण" और "क्रियाएँ" के अनुरूप जोड़ती है। अधिकांश आदेश (क्रियाएं) और आंदोलन (क्रियाओं के आधार पर क्रियाएं या वस्तुएं) संख्यात्मक उपसर्ग भी ले सकती हैं। इस प्रकार 3J मतलब है "अगली तीन पंक्तियों में शामिल हों" और d5} अर्थ है "यहां से पांचवें पैराग्राफ के अंत तक वर्तमान लाइन से हटाएं।"

यह सभी मध्यवर्ती स्तर vi है । इसमें से कोई भी विम विशिष्ट नहीं है और यदि आप उन्हें सीखने के लिए तैयार हैं तो वीआई में कहीं अधिक उन्नत चालें हैं। यदि आप केवल इन मध्यवर्ती अवधारणाओं को महारत हासिल करना चाहते हैं तो आपको शायद यह पता चलेगा कि आपको शायद ही कभी किसी मैक्रोज़ को लिखने की आवश्यकता है क्योंकि टेक्स्ट मैनिपुलेशन भाषा संपादक की "मूल" भाषा का उपयोग करके अधिकतर चीजों को आसानी से करने के लिए पर्याप्त संक्षिप्त और अभिव्यक्तिपूर्ण है।

अधिक उन्नत चाल का एक नमूनाकरण:

इसमें कई हैं : कमांड, सबसे विशेष रूप से :% s/foo/bar/g वैश्विक प्रतिस्थापन तकनीक। (यह उन्नत नहीं है लेकिन अन्य : आदेश हो सकते हैं)। संपूर्ण : आदेशों का सेट ऐतिहासिक रूप से वी के पिछले अवतारों द्वारा एड (लाइन एडिटर) और बाद में पूर्व (विस्तारित लाइन संपादक) उपयोगिताओं के रूप में विरासत में मिला था। असल में वीआई का नाम इसलिए है क्योंकि यह पूर्व में दृश्य इंटरफ़ेस है।

: आदेश सामान्य रूप से पाठ की रेखाओं पर काम करते हैं। एड और पूर्व एक युग में लिखे गए थे जब टर्मिनल स्क्रीन असामान्य थीं और कई टर्मिनल "टेलीटाइप" (टीटीवी) डिवाइस थे। तो टेक्स्ट की मुद्रित प्रतियों से काम करना आम था, एक बेहद तेज़ इंटरफ़ेस के माध्यम से कमांड का उपयोग करके (सामान्य कनेक्शन की गति 110 बॉड थी, या मोटे तौर पर, प्रति सेकंड 11 वर्ण - जो एक तेज टाइपिस्ट की तुलना में धीमी है; लेट्स सामान्य थे बहु-उपयोगकर्ता इंटरैक्टिव सत्र; इसके अतिरिक्त पेपर को बचाने के लिए अक्सर कुछ प्रेरणा होती थी)।

तो अधिकांश का वाक्यविन्यास : आदेशों में एक आदेश या पते की श्रेणी (रेखा संख्या) शामिल होती है जिसके बाद कमांड होता है। स्वाभाविक रूप से कोई शाब्दिक रेखा संख्याओं का उपयोग कर सकता है: 127 और 215 के बीच प्रत्येक पंक्ति पर "foo" में "बार" की पहली घटना को बदलने के लिए :127,215 s/foo/bar । कोई भी कुछ संक्षेपों का उपयोग कर सकता है . या क्रमशः वर्तमान और अंतिम लाइनों के लिए $ । कोई भी क्रमशः curent लाइन के बाद या उससे पहले ऑफ़सेट को संदर्भित करने के लिए रिश्तेदार उपसर्गों का उपयोग कर सकता है। इस प्रकार:: :.,$j अर्थ है "मौजूदा रेखा से अंतिम पंक्ति तक, उन सभी को एक पंक्ति में शामिल करें"। :% समानार्थी है :1,$ (सभी लाइनें)।

:... g और :... v आदेश कुछ स्पष्टीकरण सहन करते हैं क्योंकि वे अविश्वसनीय रूप से शक्तिशाली हैं। :... g "ग्लोबली" के लिए एक उपसर्ग है जो बाद की कमांड को सभी लाइनों पर लागू करता है जो पैटर्न (नियमित अभिव्यक्ति) से मेल खाते हैं :... v उन सभी पंक्तियों पर ऐसा आदेश लागू करता है जो दिए गए पैटर्न से मेल नहीं खाते हैं ("v "से" converse ")। जैसा कि अन्य पूर्व आदेशों के साथ इन्हें संबोधित / रेंज संदर्भों से पूर्वनिर्धारित किया जा सकता है। इस प्रकार :.,+21g/foo/d अर्थ है "मौजूदा 21 से स्ट्रिंग" foo "वाली किसी भी पंक्ति को अगले 21 लाइनों के माध्यम से हटाएं" जबकि :.,$v/bar/d अर्थ है "यहां से अंत तक फ़ाइल, किसी भी लाइन को हटाएं जिसमें स्ट्रिंग "बार" न हो।

यह दिलचस्प है कि आम यूनिक्स कमांड grep वास्तव में इस पूर्व कमांड से प्रेरित था (और जिस तरीके से इसे दस्तावेज किया गया था उसके नाम पर रखा गया है)। पूर्व कमांड :g/re/p (जीईपी) जिस तरह से उन्होंने "वैश्विक अभिव्यक्ति" (पुनः) युक्त "वैश्विक" "प्रिंट" लाइनों को कैसे दस्तावेज किया था, दस्तावेज किया था। जब एड और एक्स का उपयोग किया जाता था, तो :p कमांड पहले व्यक्ति में से एक था जिसे किसी ने भी सीखा और अक्सर किसी फ़ाइल को संपादित करते समय इस्तेमाल किया जाता था। यह था कि आपने वर्तमान सामग्री को मुद्रित किया था (आमतौर पर केवल एक पृष्ठ का उपयोग करते हुए :.,+25p या कुछ ऐसे)।

ध्यान दें कि :% g/.../d या (इसके reVerse / converse counterpart:: :% v/.../d सबसे आम उपयोग पैटर्न हैं। हालांकि कुछ अन्य ex आदेश हैं जो याद रखने योग्य हैं:

हम लाइनों के चारों ओर घूमने के लिए m का उपयोग कर सकते हैं, और j लाइनों में शामिल होने के लिए। उदाहरण के लिए यदि आपके पास कोई सूची है और आप उन्हें हटाए बिना सभी सामग्री मिलान (या विपरीत रूप से कुछ पैटर्न से मेल नहीं खाते) को अलग करना चाहते हैं, तो आप कुछ ऐसा उपयोग कर सकते हैं :% g/foo/m$ ... और सभी " foo "लाइनों को फ़ाइल के अंत में ले जाया जाएगा। (स्क्रैच स्पेस के रूप में अपनी फ़ाइल के अंत का उपयोग करने के बारे में अन्य युक्ति नोट करें)। यह शेष सूची से निकाले जाने पर सभी "foo" लाइनों के सापेक्ष क्रम को संरक्षित रखेगा। (यह कुछ ऐसा करने के बराबर होगा: 1G!GGmap!Ggrep foo<ENTER>1G:1,'ag/foo'/d (फ़ाइल को अपनी पूंछ में कॉपी करें, grep माध्यम से पूंछ को फ़िल्टर करें, और सभी चीज़ें हटाएं सिर से)।

आमतौर पर लाइनों में शामिल होने के लिए, मैं उन सभी लाइनों के लिए एक पैटर्न पा सकता हूं जिन्हें अपने पूर्ववर्ती (सभी पंक्तियों जो "^" से शुरू होते हैं, उदाहरण के लिए "बुलेट सूची" में "^ *" से शुरू होते हैं)। उस मामले के लिए मैं इसका उपयोग करूंगा :% g/^ /-1j (प्रत्येक मिलान रेखा के लिए, एक पंक्ति पर जाएं और उनसे जुड़ें)। (बीटीडब्ल्यू: बुलेट सूचियों के लिए बुलेट लाइनों की खोज करने और अगले में शामिल होने की कोशिश करने के लिए कुछ कारणों से काम नहीं करता है ... यह एक बुलेट लाइन में दूसरे में शामिल हो सकता है, और यह किसी भी बुलेट लाइन में शामिल नहीं होगा इसकी निरंतरताएं; यह केवल मैचों पर जोड़ीदार काम करेगी)।

उल्लेख करने की लगभग आवश्यकता नहीं है आप g और v (वैश्विक / परिवर्तनीय-वैश्विक) आदेशों के साथ हमारे पुराने मित्र (विकल्प) का उपयोग कर सकते हैं। आमतौर पर आपको ऐसा करने की आवश्यकता नहीं होती है। हालांकि, कुछ ऐसे मामले पर विचार करें जहां आप केवल कुछ अन्य पैटर्न से मेल खाने वाली रेखाओं पर प्रतिस्थापन करना चाहते हैं। अक्सर आप कैप्चर के साथ एक जटिल पैटर्न का उपयोग कर सकते हैं और उन लाइनों के हिस्सों को सुरक्षित रखने के लिए संदर्भों का उपयोग कर सकते हैं जिन्हें आप बदलना नहीं चाहते हैं। हालांकि, प्रतिस्थापन से मैच को अलग करना अक्सर आसान होगा :% g/foo/s/bar/zzz/g - "foo" युक्त सभी पंक्तियों के लिए "zzz" के साथ सभी "बार" विकल्प। (कुछ ऐसा है :% s/\(.*foo.*\)bar\(.*\)/\1zzz\2/g केवल उन मामलों के लिए काम करेगा जो "बार" के उदाहरण हैं जिन्हें "foo" द्वारा पूर्ववत किया गया था एक ही पंक्ति; यह पहले से ही काफी हद तक पर्याप्त है, और उन सभी मामलों को पकड़ने के लिए आगे बढ़ना होगा जहां "बार" से पहले "फू")

मुद्दा यह है कि ex कमांड सेट में केवल p , s , और d लाइनों से अधिक हैं।

पते : अंक भी संदर्भित कर सकते हैं। इस प्रकार आप इसका उपयोग कर सकते हैं:: :'a,'bg/foo/j किसी भी पंक्ति में स्ट्रिंग फू युक्त किसी भी पंक्ति में शामिल होने के लिए, यदि यह ' ' और ' बी ' अंकों के बीच की रेखाओं के बीच है। (हां, पूर्ववर्ती ex कमांड उदाहरणों में से सभी को इस तरह के एड्रेसिंग एक्सप्रेशन के साथ उपसर्ग करके फाइल की लाइनों के सबसेट तक ही सीमित किया जा सकता है)।

यह बहुत अस्पष्ट है (मैंने पिछले 15 वर्षों में कुछ बार ऐसा कुछ किया है)। हालांकि, मैं स्वतंत्र रूप से स्वीकार करूंगा कि मैंने अक्सर चीजों को सामान्य रूप से और अंतःक्रियात्मक रूप से किया है जो शायद सही ढंग से किया जा सकता है अगर मैं सही incantation सोचने के लिए समय ले लिया।

एक और बहुत उपयोगी vi या ex कमांड है :r किसी अन्य फ़ाइल की सामग्री में पढ़ने के लिए। इस प्रकार:: :r foo वर्तमान पंक्ति पर "foo" नाम की फ़ाइल की सामग्री को सम्मिलित करता है।

अधिक शक्तिशाली है :r! आदेश। यह एक आदेश के परिणाम पढ़ता है। यह vi सत्र को निलंबित करने, कमांड चलाने, अपने आउटपुट को अस्थायी फ़ाइल में रीडायरेक्ट करने, आपके vi सत्र को फिर से शुरू करने और अस्थायी सामग्री में पढ़ने के समान है। फ़ाइल।

और भी शक्तिशाली हैं ! (बैंग) और :... ! ( पूर्व धमाके) आदेश। ये बाहरी आदेश भी निष्पादित करते हैं और परिणामों को वर्तमान पाठ में पढ़ते हैं। हालांकि, वे आदेश के माध्यम से हमारे पाठ के चयन फ़िल्टर भी करते हैं! यह हम 1G!Gsort G का उपयोग कर हमारी फाइल में सभी लाइनों को सॉर्ट कर सकते हैं 1G!Gsort ( G vi "goto" कमांड है; यह फ़ाइल की आखिरी पंक्ति पर जाने के लिए डिफ़ॉल्ट है, लेकिन लाइन नंबर से प्रीफिक्स किया जा सकता है, जैसे कि 1, पहली पंक्ति)। यह पूर्व संस्करण के बराबर है :1,$!sort । लेखक अक्सर उपयोग करते हैं ! पाठ के सुधार या "शब्द रैपिंग" चयन के लिए यूनिक्स एफएमटी या फोल्ड यूटिलिटीज के साथ। एक बहुत ही आम मैक्रो {!}fmt (वर्तमान पैराग्राफ को {!}fmt ) है। प्रोग्रामर कभी-कभी इंडेंट या अन्य कोड रीफॉर्मेटिंग टूल के माध्यम से अपने कोड, या केवल इसके भाग चलाने के लिए इसका उपयोग करते हैं।

का उपयोग करना :r! और ! आदेशों का अर्थ है कि किसी बाहरी उपयोगिता या फ़िल्टर को हमारे संपादक के विस्तार के रूप में माना जा सकता है। मैंने कभी-कभी उन स्क्रिप्ट के साथ उपयोग किया है जो डेटाबेस से डेटा खींचते हैं, या वेजेट या लिंक्स कमांड के साथ जो किसी वेबसाइट से डेटा खींचते हैं, या एसएसएच कमांड जो रिमोट सिस्टम से डेटा खींचते हैं।

एक और उपयोगी पूर्व आदेश है :so ( :source लिए संक्षिप्त)। यह एक फ़ाइल की सामग्री को कमांड की श्रृंखला के रूप में पढ़ता है। जब आप vi शुरू करते हैं तो यह सामान्य रूप से, निष्पादित करता है :source ~/.exinitrc फ़ाइल पर :source (और विम आमतौर पर ~/.vimrc , स्वाभाविक रूप से पर्याप्त) करता है। इसका उपयोग यह है कि आप मैक्रोज़, संक्षिप्ताक्षर और संपादक सेटिंग्स के नए सेट में बस सोर्स करके फ्लाई पर अपनी संपादक प्रोफ़ाइल बदल सकते हैं। यदि आप चुपके हैं तो आप मांग पर फ़ाइलों पर लागू करने के लिए पूर्व संपादन आदेशों के अनुक्रमों को संग्रहीत करने के लिए एक चाल के रूप में भी इसका उपयोग कर सकते हैं।

उदाहरण के लिए मेरे पास एक सात पंक्ति फ़ाइल (36 वर्ण) है जो WC के माध्यम से फ़ाइल चलाती है, और उस शब्द गणना डेटा वाले फ़ाइल के शीर्ष पर एक सी-शैली टिप्पणी डालती है। मैं एक कमांड का उपयोग कर फ़ाइल में "मैक्रो" लागू कर सकता हूं जैसे: vim +'so mymacro.ex' ./mytarget

( Vi और Vim के लिए कमांड लाइन विकल्प आमतौर पर किसी दिए गए लाइन नंबर पर संपादन सत्र शुरू करने के लिए उपयोग किया जाता है। हालांकि यह एक छोटा ज्ञात तथ्य है कि कोई भी किसी भी पूर्व पूर्व आदेश / अभिव्यक्ति, जैसे "स्रोत" द्वारा + का पालन कर सकता है जैसा कि मैंने यहां किया है; एक साधारण उदाहरण के लिए मेरे पास स्क्रिप्ट्स हैं जो इन्हें आमंत्रित करती हैं: vi +'/foo/d|wq!' ~/.ssh/known_hosts मेरे एसएसएच से एक प्रविष्टि को निकालने के लिए ज्ञात मेजबान फ़ाइल गैर-इंटरैक्टिव रूप से मैं सर्वरों का एक सेट फिर से इमेजिंग कर रहा हूँ)।

आम तौर पर पर्ल, एडब्ल्यूके, sed (जो वास्तव में, grep की तरह एडी कमांड द्वारा प्रेरित उपयोगिता) का उपयोग करके ऐसे "मैक्रोज़" लिखना बहुत आसान है।

@ कमांड शायद सबसे अस्पष्ट vi कमांड है। कभी-कभी एक दशक के लिए उन्नत सिस्टम प्रशासन पाठ्यक्रम पढ़ाने में मैंने बहुत कम लोगों से मुलाकात की है जिन्होंने कभी इसका इस्तेमाल किया है। @ एक रजिस्टर की सामग्री निष्पादित करता है जैसे कि यह एक vi या ex कमांड था।
उदाहरण: मैं अक्सर उपयोग करता हूं :r!locate ... मेरे सिस्टम पर कुछ फ़ाइल ढूंढने और अपना नाम मेरे दस्तावेज़ में पढ़ने के लिए। वहां से मैं किसी भी बाहरी हिट को हटा देता हूं, जिसमें मुझे दिलचस्पी रखने वाली फ़ाइल का पूरा पथ छोड़ दिया जाता है। पथ के प्रत्येक घटक के माध्यम से श्रमिक रूप से टैब -िंग (या बदतर, अगर मैं बिना किसी टैबलेट के मशीन पर फंस जाता हूं vi की प्रतिलिपि में समर्थन) मैं बस उपयोग करता हूं:

  1. 0i:r (वर्तमान लाइन को वैध में बदलने के लिए : आर कमांड),
  2. "cdd (" सी "रजिस्टर में लाइन को हटाने के लिए) और
  3. @c उस आदेश को निष्पादित करें।

यह केवल 10 कीस्ट्रोक है (और अभिव्यक्ति "cdd @c प्रभावी रूप से मेरे लिए एक उंगली मैक्रो है, इसलिए मैं इसे लगभग सामान्य छह अक्षर शब्द जितनी जल्दी टाइप कर सकता हूं)।

एक गंभीर विचार

मैंने केवल वी की शक्ति की सतह पर खरोंच की है और मैंने जो भी वर्णन किया है उनमें से कोई भी "सुधार" का हिस्सा नहीं है जिसके लिए विम नाम दिया गया है! मैंने जो कुछ भी वर्णन किया है, उसे 20 या 30 साल पहले वीआई की किसी भी पुरानी प्रति पर काम करना चाहिए।

ऐसे लोग हैं जिन्होंने कभी भी वीआई की शक्ति का अधिक उपयोग किया है।


आप टेक्स्ट चुनने और प्रतिलिपि बनाने के बारे में बात कर रहे हैं, मुझे लगता है कि आपको विम विजुअल मोड को देखना चाहिए।

दृश्य मोड में, आप विम कमांड का उपयोग करके टेक्स्ट का चयन करने में सक्षम हैं, फिर आप चयन के साथ जो चाहें कर सकते हैं।

निम्नलिखित सामान्य परिदृश्यों पर विचार करें:

आपको अगले मिलान करने वाले कोष्ठक में चयन करने की आवश्यकता है।

तुम यह कर सकते थे:

  • v% अगर कर्सर प्रारंभ / समापन संश्लेषण पर है
  • vib अगर कर्सर कोष्ठक ब्लॉक के अंदर है

आप उद्धरण के बीच पाठ का चयन करना चाहते हैं:

  • vi " डबल उद्धरण के लिए
  • vi ' एकल उद्धरण के लिए

आप एक घुंघराले ब्रेस ब्लॉक (सी-शैली भाषाओं पर बहुत आम) चुनना चाहते हैं:

  • viB
  • vi{

आप पूरी फाइल का चयन करना चाहते हैं:

  • ggVG

विजुअल ब्लॉक चयन एक और वास्तव में उपयोगी सुविधा है, यह आपको पाठ के आयताकार क्षेत्र का चयन करने की अनुमति देता है, आपको बस इसे शुरू करने के लिए Ctrl - V दबाएं , और उसके बाद इच्छित टेक्स्ट ब्लॉक का चयन करें और किसी भी प्रकार का ऑपरेशन करें जैसे यंक, हटाएं, पेस्ट करें, संपादित करें आदि। कॉलम उन्मुख पाठ को संपादित करना बहुत अच्छा है।


<Ctrl> + W, V to split the screen vertically
<Ctrl> + W, W to shift between the windows

!python % [args] to run the script I am editing in this window

ZF in visual mode to fold arbitrary lines


. Repeat last text-changing command

I save a lot of time with this one.

Visual mode was mentioned previously, but block visual mode has saved me a lot of time when editing fixed size columns in text file. (accessed with Ctrl-V).


CTRL + A increments the number you are standing on.


gi

Go to last edited location (very useful if you performed some searching and than want go back to edit)

^P and ^N

Complete previous (^P) or next (^N) text.

^O and ^I

Go to previous ( ^O - "O" for old) location or to the next ( ^I - "I" just near to "O" ). When you perform searches, edit files etc., you can navigate through these "jumps" forward and back.


All in Normal mode:

f<char> to move to the next instance of a particular character on the current line, and ; to repeat.

F<char> to move to the previous instance of a particular character on the current line and ; to repeat.

If used intelligently, the above two can make you killer-quick moving around in a line.

* on a word to search for the next instance.

# on a word to search for the previous instance.


Another useful vi "shortcut" I frequently use is 'xp'. This will swap the character under the cursor with the next character.


Bulk text manipulations!

Either through macros:

  • Start with recording: qq
  • Do stuff
  • Stop recording: q
  • Repeat: @q (the first time), @@ after that.
  • Repeat 20 times: [email protected]@

Or through regular expressions:

  • Replace stuff: :%s/[fo]+/bar/g

(But be warned: if you do the latter, you'll have 2 problems :).)


I am a member of the American Cryptogram Association. The bimonthly magazine includes over 100 cryptograms of various sorts. Roughly 15 of these are "cryptarithms" - various types of arithmetic problems with letters substituted for the digits. Two or three of these are sudokus, except with letters instead of numbers. When the grid is completed, the nine distinct letters will spell out a word or words, on some line, diagonal, spiral, etc., somewhere in the grid.

Rather than working with pencil, or typing the problems in by hand, I download the problems from the members area of their website.

When working with these sudokus, I use vi, simply because I'm using facilities that vi has that few other editors have. Mostly in converting the lettered grid into a numbered grid, because I find it easier to solve, and then the completed numbered grid back into the lettered grid to find the solution word or words.

The problem is formatted as nine groups of nine letters, with - s representing the blanks, written in two lines. The first step is to format these into nine lines of nine characters each. There's nothing special about this, just inserting eight linebreaks in the appropriate places.

The result will look like this:

T-O-----C
-E-----S-
--AT--N-L
---NASO--
---E-T---
--SPCL---
E-T--OS--
-A-----P-
S-----C-T

So, first step in converting this into numbers is to make a list of the distinct letters. First, I make a copy of the block. I position the cursor at the top of the block, then type :y}}p . : puts me in command mode, y yanks the next movement command. Since } is a move to the end of the next paragraph, y} yanks the paragraph. } then moves the cursor to the end of the paragraph, and p pastes what we had yanked just after the cursor. So y}}p creates a copy of the next paragraph, and ends up with the cursor between the two copies.

Next, I to turn one of those copies into a list of distinct letters. That command is a bit more complex:

:!}tr -cd A-Z | sed 's/\(.\)/\1\n/g' | sort -u | tr -d '\n'

: again puts me in command mode. ! indicates that the content of the next yank should be piped through a command line. } yanks the next paragraph, and the command line then uses the tr command to strip out everything except for upper-case letters, the sed command to print each letter on a single line, and the sort command to sort those lines, removing duplicates, and then tr strips out the newlines, leaving the nine distinct letters in a single line, replacing the nine lines that had made up the paragraph originally. In this case, the letters are: ACELNOPST .

Next step is to make another copy of the grid. And then to use the letters I've just identified to replace each of those letters with a digit from 1 to 9. That's simple: :!}tr ACELNOPST 0-9 . The result is:

8-5-----1
-2-----7-
--08--4-3
---4075--
---2-8---
--7613---
2-8--57--
-0-----6-
7-----1-8

This can then be solved in the usual way, or entered into any sudoku solver you might prefer. The completed solution can then be converted back into letters with :!}tr 1-9 ACELNOPST .

There is power in vi that is matched by very few others. The biggest problem is that only a very few of the vi tutorial books, websites, help-files, etc., do more than barely touch the surface of what is possible.


I recently (got) discovered this site: http://vimcasts.org/

It's pretty new and really really good. The guy who is running the site switched from textmate to vim and hosts very good and concise casts on specific vim topics. इसकी जांच - पड़ताल करें!


I recently discovered q: . It opens the "command window" and shows your most recent ex-mode (command-mode) commands. You can move as usual within the window, and pressing <CR> executes the command. You can edit, etc. too. Priceless when you're messing around with some complex command or regex and you don't want to retype the whole thing, or if the complex thing you want to do was 3 commands back. It's almost like bash's set -o vi , but for vim itself (heh!).

See :help q: for more interesting bits for going back and forth.


Last week at work our project inherited a lot of Python code from another project. Unfortunately the code did not fit into our existing architecture - it was all done with global variables and functions, which would not work in a multi-threaded environment.

We had ~80 files that needed to be reworked to be object oriented - all the functions moved into classes, parameters changed, import statements added, etc. We had a list of about 20 types of fix that needed to be done to each file. I would estimate that doing it by hand one person could do maybe 2-4 per day.

So I did the first one by hand and then wrote a vim script to automate the changes. Most of it was a list of vim commands eg

" delete an un-needed function "
g/someFunction(/ d

" add wibble parameter to function foo "
%s/foo(/foo( wibble,/

" convert all function calls bar(thing) into method calls thing.bar() "
g/bar(/ normal nmaf(ldi(`aPa.

The last one deserves a bit of explanation:

g/bar(/  executes the following command on every line that contains "bar("
normal   execute the following text as if it was typed in in normal mode
n        goes to the next match of "bar(" (since the :g command leaves the cursor position at the start of the line)
ma       saves the cursor position in mark a
f(       moves forward to the next opening bracket
l        moves right one character, so the cursor is now inside the brackets
di(      delete all the text inside the brackets
`a       go back to the position saved as mark a (i.e. the first character of "bar")
P        paste the deleted text before the current cursor position
a.       go into insert mode and add a "." 

For a couple of more complex transformations such as generating all the import statements I embedded some python into the vim script.

After a few hours of working on it I had a script that will do at least 95% of the conversion. I just open a file in vim then run :source fixit.vim and the file is transformed in a blink of the eye.

We still have the work of changing the remaining 5% that was not worth automating and of testing the results, but by spending a day writing this script I estimate we have saved weeks of work.

Of course it would have been possible to automate this with a scripting language like Python or Ruby, but it would have taken far longer to write and would be less flexible - the last example would have been difficult since regex alone would not be able to handle nested brackets, eg to convert bar(foo(xxx)) to foo(xxx).bar() . Vim was perfect for the task.


Multiple buffers, and in particular fast jumping between them to compare two files with :bp and :bn (properly remapped to a single Shift + p or Shift + n )

vimdiff mode (splits in two vertical buffers, with colors to show the differences)

Area-copy with Ctrl + v

And finally, tab completion of identifiers (search for "mosh_tab_or_complete"). That's a life changer.


Spend 30 mins doing the vim tutorial (run vimtutor instead of vim in terminal). You will learn the basic movements, and some keystrokes, this will make you at least as productive with vim as with the text editor you used before. After that, well, read Jim Dennis' answer again :)


These are not shortcuts, but they are related:

  1. Make capslock an additional ESC (or Ctrl)
  2. map leader to "," (comma), with this command: let mapleader=","

They boost my productivity.


Use the builtin file explorer! The command is :Explore and it allows you to navigate through your source code very very fast. I have these mapping in my .vimrc :

map <silent> <F8>   :Explore<CR>
map <silent> <S-F8> :sp +Explore<CR>

The explorer allows you to make file modifications, too. I'll post some of my favorite keys, pressing <F1> will give you the full list:

  • - : The most useful: Change to upper directory ( cd .. )
  • mf : Mark a file
  • D : Delete marked files or the file the cursor is on, if nothing ismarked.
  • R : Rename the file the cursor is on.
  • d : Create a new directory in the current directory
  • % : Create a new file in the current directory

Visual Mode

As several other people have said, visual mode is the answer to your copy/cut & paste problem. Vim gives you 'v', 'V', and Cv. Lower case 'v' in vim is essentially the same as the shift key in notepad. The nice thing is that you don't have to hold it down. You can use any movement technique to navigate efficiently to the starting (or ending) point of your selection. Then hit 'v', and use efficient movement techniques again to navigate to the other end of your selection. Then 'd' or 'y' allows you to cut or copy that selection.

The advantage vim's visual mode has over Jim Dennis's description of cut/copy/paste in vi is that you don't have to get the location exactly right. Sometimes it's more efficient to use a quick movement to get to the general vicinity of where you want to go and then refine that with other movements than to think up a more complex single movement command that gets you exactly where you want to go.

The downside to using visual mode extensively in this manner is that it can become a crutch that you use all the time which prevents you from learning new vi(m) commands that might allow you to do things more efficiently. However, if you are very proactive about learning new aspects of vi(m), then this probably won't affect you much.

I'll also re-emphasize that the visual line and visual block modes give you variations on this same theme that can be very powerful...especially the visual block mode.

On Efficient Use of the Keyboard

I also disagree with your assertion that alternating hands is the fastest way to use the keyboard. It has an element of truth in it. Speaking very generally, repeated use of the same thing is slow. This most significant example of this principle is that consecutive keystrokes typed with the same finger are very slow. Your assertion probably stems from the natural tendency to use the s/finger/hand/ transformation on this pattern. To some extent it's correct, but at the extremely high end of the efficiency spectrum it's incorrect.

Just ask any pianist. Ask them whether it's faster to play a succession of a few notes alternating hands or using consecutive fingers of a single hand in sequence. The fastest way to type 4 keystrokes is not to alternate hands, but to type them with 4 fingers of the same hand in either ascending or descending order (call this a "run"). This should be self-evident once you've considered this possibility.

The more difficult problem is optimizing for this. It's pretty easy to optimize for absolute distance on the keyboard. Vim does that. It's much harder to optimize at the "run" level, but vi(m) with it's modal editing gives you a better chance at being able to do it than any non-modal approach (ahem, emacs) ever could.

On Emacs

Lest the emacs zealots completely disregard my whole post on account of that last parenthetical comment, I feel I must describe the root of the difference between the emacs and vim religions. I've never spoken up in the editor wars and I probably won't do it again, but I've never heard anyone describe the differences this way, so here it goes. The difference is the following tradeoff:

Vim gives you unmatched raw text editing efficiency Emacs gives you unmatched ability to customize and program the editor

The blind vim zealots will claim that vim has a scripting language. But it's an obscure, ad-hoc language that was designed to serve the editor. Emacs has Lisp! Enough said. If you don't appreciate the significance of those last two sentences or have a desire to learn enough about functional programming and Lisp to develop that appreciation, then you should use vim.

The emacs zealots will claim that emacs has viper mode, and so it is a superset of vim. But viper mode isn't standard. My understanding is that viper mode is not used by the majority of emacs users. Since it's not the default, most emacs users probably don't develop a true appreciation for the benefits of the modal paradigm.

In my opinion these differences are orthogonal. I believe the benefits of vim and emacs as I have stated them are both valid. This means that the ultimate editor doesn't exist yet. It's probably true that emacs would be the easiest platform on which to base the ultimate editor. But modal editing is not entrenched in the emacs mindset. The emacs community could move that way in the future, but that doesn't seem very likely.

So if you want raw editing efficiency, use vim. If you want the ultimate environment for scripting and programming your editor use emacs. If you want some of both with an emphasis on programmability, use emacs with viper mode (or program your own mode). If you want the best of both worlds, you're out of luck for now.





vi