बफ़र्स का उपयोग करने का एक अधिक कुशल तरीका क्या है?

Question

हाल ही में मैं काफी प्लगइन्स की संख्या को कम कर रहा हूं जिसका मैं उपयोग कर रहा हूं इसलिए मैं केवल बिल्ट-इन विम विशेषताओं का उपयोग करके उत्तर ढूंढ रहा हूं।

जब मैं बहुत सारे बफ़र्स का संपादन कर रहा होता हूं, तो मुझे अपने वर्कफ़्लो में एक दोष दिखाई देता है: मैं एक बफर पर हूं और मैं एक और स्विच करना चाहता हूं, जिसमें मुझे नाम याद नहीं है और जो वैकल्पिक बफर नहीं है । तो उपयोग :b#करना संभव नहीं है और कमांड के साथ पूर्णता का उपयोग करना :bसुविधाजनक है और न ही।

ऐसा करने के लिए मैं निम्नलिखित कर रहा था:

• पहले :buffersखुले बफ़र्स की सूची प्राप्त करने के लिए उपयोग करें
• उस बफर की संख्या याद रखें जिसका मैं उपयोग करना चाहता हूं
• Enterबफ़र्स की सूची को बंद करने के लिए दबाएँ
• उपयोग :bXकरने Xके लिए बफर की संख्या के साथ उपयोग करें।

यह वर्कफ़्लो मुझे बहुत भारी लग रहा था इसलिए मैंने निम्नलिखित पंक्तियों को अपने साथ जोड़ा .vimrc:

" Improve the navigation in the buffers 
nnoremap <Leader><S-b> :B<CR> 
command! B call Buffers() 

function! Buffers() 
    execute "buffers" 
    let buffer=input("Enter a buffer:") 
    execute "b" . buffer 
endfunction 

यह मुझे एक कमांड :B(और एक मैपिंग) देता है जो फ़ंक्शन को :buffersइनपुट के लिए प्रतीक्षा करता है और अंत :bमें इनपुट के बाद कॉल करता है।

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

Comments

मैं इसके :lsबाद :b#(पहले वापसी या भागने की जरूरत नहीं है, सीधे बफर लिस्ट से 'ls' में जा सकता हूं।) 'कुछ याद कर रहा है और गलत सवाल का जवाब दे रहा है।)

— लिंडाजेन

@ लिंडाजेन: जैसा कि मैंने कहा कि मैं :b#वह नहीं हूं जो मैं देख रहा हूं, लेकिन हां यह तथ्य है कि आप एक कीस्ट्रोक को सीधे :bदबाए बिना दर्ज करके बचा सकते हैं enter, दिलचस्प है। (वास्तव में है कि एक जवाब होना करने के लिए हो सकता है बहुत हल्का है, लेकिन यह एक टिप्पणी के लायक :-) था)

— statox

मैं अनुमान लगा रहा हूं कि लिंडाजेन का मतलब #चरित्र के बजाय एक (बफर) संख्या के लिए स्टैंड-इन के रूप में था, शाब्दिक #चरित्र के बजाय ।

— 8bittree

Answer 1

जब मैं बहुत सारे बफ़र्स का संपादन कर रहा होता हूं, तो मुझे अपने वर्कफ़्लो में एक दोष दिखाई देता है: मैं एक बफर पर हूं और मैं एक और स्विच करना चाहता हूं, जिसमें मुझे नाम याद नहीं है और जो वैकल्पिक बफर नहीं है । तो उपयोग :b#करना संभव नहीं है और कमांड के साथ पूर्णता का उपयोग करना :bसुविधाजनक है और न ही।

इसके विपरीत, मैं टैब-पूरा होने को बेहद सुविधाजनक मानता हूं। आपके लिए काम करने वाले मूल्यों के लिए सही विकल्प सेट करने से बहुत मदद मिल सकती है। ये मेरे लिए प्रासंगिक लाइनें हैं vimrc (वे मेरे लिए काम करते हैं लेकिन वे आपके लिए काम नहीं कर सकते हैं इसलिए उन्हें कॉपी न करें) :

nnoremap ,b :buffer *
set wildmenu
set wildignore+=*.swp,*.bak
set wildignore+=*.pyc,*.class,*.sln,*.Master,*.csproj,*.csproj.user,*.cache,*.dll,*.pdb,*.min.*
set wildignore+=*/.git/**/*,*/.hg/**/*,*/.svn/**/*
set wildignore+=*/min/*,*/vendor/*,*/node_modules/*,*/bower_components/*
set wildignore+=tags,cscope.*
set wildignore+=*.tar.*
set wildignorecase
set wildmode=full

उस के साथ, सही बफर शायद ही कभी पांच या छह कीस्ट्रोक्स से अधिक होता है:

---

यह मुझे एक कमांड :B(और एक मैपिंग) देता है जो फ़ंक्शन को :buffersइनपुट के लिए प्रतीक्षा करता है और अंत :bमें इनपुट के बाद कॉल करता है।

बैरी आर्थर साल पहले एक बहुत सरल समाधान के साथ आया था जो तब से काफी लोकप्रिय हो गया है:

nnoremap <leader>b :ls<CR>:b<Space>

जिनमें से मैंने कुछ साल पहले थोड़ा और बहुमुखी संस्करण प्रस्तावित किया था:

nnoremap gb :ls<CR>:b

---

चूँकि हम vimscript की बात कर रहे हैं, यहाँ एक अच्छा सा फंक्शन है जो मैंने लिखा है कि "ऑटो-पॉपुलेट्स" कमांड-लाइन को कमांड-जैसे कमांड जैसे :lsया उसके बाद सही कमांड स्टब के साथ :ilist। ऊपर के मैपिंग पर उस फ़ंक्शन का लाभ यह है कि मुझे विशिष्ट मैपिंग याद रखने की आवश्यकता नहीं है। यह विम की तरह ही काम करता है, लेकिन थोड़ा ट्विस्ट के साथ ।

" smooth listing
cnoremap <expr> <CR> <SID>CCR()

function! s:CCR()
    if getcmdtype() == ":"
        let cmdline = getcmdline()
            if cmdline =~ '\v\C^(dli|il)' | return "\<CR>:" . cmdline[0] . "jump  " . split(cmdline, " ")[1] . "\<S-Left>\<Left>"
        elseif cmdline =~ '\v\C^(cli|lli)' | return "\<CR>:silent " . repeat(cmdline[0], 2) . "\<Space>"
        elseif cmdline =~ '\C^changes' | set nomore | return "\<CR>:sil se more|norm! g;\<S-Left>"
        elseif cmdline =~ '\C^ju' | set nomore | return "\<CR>:sil se more|norm! \<C-o>\<S-Left>"
        elseif cmdline =~ '\C^ol' | set nomore | return "\<CR>:sil se more|e #<"
        elseif cmdline =~ '\C^undol' | return "\<CR>:u "
        elseif cmdline =~ '\C^ls' | return "\<CR>:b"
        elseif cmdline =~ '/#$' | return "\<CR>:"
        else | return "\<CR>" | endif
    else | return "\<CR>" | endif
endfunction

---

उस ने कहा, मैं "फ़ाइल-आधारित नेविगेशन" पर "प्रतीक-आधारित नेविगेशन" का एक बड़ा प्रस्तावक हूं। लागू होने पर, प्रतीक-आधारित नेविगेशन फ़ाइल-आधारित नेविगेशन की तुलना में बहुत तेज़ और बहुत अधिक आर्थिक है।

आखिरी जीआईएफ , प्रतीक-आधारित नेविगेशन का एक मतलब दिखाता है । उदाहरण मूर्खतापूर्ण है लेकिन ... ठीक है।

Comments

मुझे लगता है कि मैंने wild*विकल्पों के साथ पर्याप्त नहीं खेला है , मैं इसे अपने तरीके से ट्विक करने की कोशिश करूंगा। बैरी आर्थर समाधान के बारे में यह @ nobe4 के उत्तर के करीब है जो दिलचस्प है। अंत में मुझे CCR()वास्तव में इसे प्राप्त करने के लिए अपने कार्य पर गहन रूप से विचार करना होगा लेकिन यह आशाजनक है। आपके उत्तर के लिए धन्यवाद।

— statox

देखिये मेरा यह जवाब । विशेष रूप से कॉमिक।

— रोमेनियल

मैं निश्चित रूप से इनमें से कुछ चुरा लूंगा!

— statox

Answer 2

मुझे कुछ समय पहले एक ही समस्या का सामना करना पड़ा और मुझे एक समाधान मिला:

nnoremap <leader>b :buffers<CR>:buffer<space>

यह बफ़र सूची खोलेगा और इसे छुपाने के बिना , आपको बफ़र स्विच करने का विकल्प देगा।

मुझे लगता है कि यह समझ में आता है कि विम के पास "सूची और चयन" विकल्प नहीं है, ये दो अलग-अलग क्रियाएं हैं। लेकिन विम एक साथ कमांड को संयोजित करने के लिए पर्याप्त शक्तिशाली है।

इसे यूनिक्स दर्शन के रूप में सोचें: एक काम करें और इसे अच्छी तरह से करें।

:buffersबफ़र्स को सूचीबद्ध करता है और :buffer xxxआपको एक का चयन करने की अनुमति देता है।

Comments

यह एक अच्छा तरीका है कि मैंने अपने प्रश्न में सुझाए गए फ़ंक्शन को हल्का किया, दिलचस्प!

— statox

यदि आप अंत में अंतरिक्ष को अधिक दृश्यमान बनाना चाहते हैं, तो आप ऐसा कर सकते हैं: nnoremap <नेता> b: बफ़र्स <CR>: बफर <स्पेस> |

— टायलर डर्डन

Answer 3

कुछ समय के लिए मैंने इस तरह nobe4 की तकनीक का उपयोग किया:

nnoremap <Leader>b :set nomore<Bar>:ls<Bar>:set more<CR>:b<Space>

फिर मैंने उसके साथ टैब-पूर्णता का उपयोग करना शुरू कर दिया (जैसा कि रोमेलिन ने सुझाव दिया है)

लेकिन अभी हाल ही में मैंने सबसे कम विधि के साथ सबसे तेज़ विधि पाई है जिसका उपयोग करना है:

{count} CTRL-^

यह इतना अलग नहीं है, :b#<Enter>लेकिन जैसा कि आप कहते हैं, आपको बफर नंबर जानने की जरूरत है !

तो इसके लिए मैं MiniBufExplorer प्लगइन चलाता हूं , जो शीर्ष पर फ़ाइल नाम की सूची प्रदर्शित करता है (जैसे लगभग हर दूसरे संपादक)। मुझे यकीन है कि कई विकल्प हैं।

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

nnoremap <C-E> :<C-U>call SwitchToBuffer()<CR>

function! SwitchToBuffer()
  if v:count > 0
    exec v:count . "b"
    return
  endif

  " Whatever you want to do if you didn't provide a count
  " In this case, fall back to nobe4's technique:
  call feedkeys(":ls\n:b ")
endfunction

तो मेरी वर्तमान बफर स्विचिंग प्रक्रिया कुछ इस तरह से होती है:

1. MiniBufExplorer को देखें
2. मारो 3 Ctrl-E

अफसोस की बात है कि MBE और उपरोक्त स्क्रिप्ट विम बिल्ड नहीं हैं, जैसा आपने अनुरोध किया था। जब मैं बिना किसी कॉन्फिगरेशन वाली रिमोट मशीन पर होता हूं, तो मैं बस उपयोग करता हूं :b [partial]और टैब-पूर्णता।