क्या विम्मेक फ़ाइल को मोड़ने के लिए सबसे अच्छा अभ्यास है

Question

मुझे हाल ही में एहसास हुआ कि मेरी vimrcअब 400 से अधिक लाइनें लंबी हैं (जो कि IMO बहुत ज्यादा है मैं इसे कम करने की कोशिश करूँगा) और इसे नेविगेट करने, पढ़ने और संपादित करने के लिए आसान बनाने के लिए मैंने विम की तह की अवधारणा की जांच करने का निर्णय लिया (जो मैं परिचित नहीं था) ।

• मैंने फोल्डिंग मेथड को सेट करने की कोशिश की, indentलेकिन मुझे परिणाम पसंद नहीं आया (यह ज्यादातर गड़बड़ था क्योंकि मेरा एक बड़ा हिस्सा vimrcवास्तव में इंडेंट नहीं है)।
• मैंने भी सेट foldmethodकरने की कोशिश की exprऔर syntaxमैं कुछ भी ठीक से नहीं कर पाया।
• यहाँ diffतह विधि के रूप में उपयोग करना प्रासंगिक नहीं लगता है। (या अगर यह मुझे समझ में नहीं आया कि इसका उपयोग कैसे किया जाए)
• तो अब के लिए मैं उस markerविधि का उपयोग कर रहा हूं जो मुझे "{{{और "}}}मार्करों के कारण पूरी तरह से संतुष्ट नहीं करती है जो मुझे फ़ाइल में "शोर" मिला।

इसलिए मैं यह जानना चाहूंगा कि क्या अच्छी तरह से तह करने के बारे में सर्वोत्तम अभ्यास या सामान्य दिशानिर्देश हैंvimrc ।

नोट 1: जैसा कि हम सभी जानते हैं कि एसओ एक मंच नहीं है और व्यक्तिगत राय एकत्र करने के लिए नहीं बनाया गया है और जो मैं देख रहा हूं वह नहीं है: बेशक मुझे लगता है कि कुछ लोगों की प्राथमिकताएं हैं, लेकिन मैं जानना चाहता हूं कि क्यों मार्कर (उदाहरण के लिए) इंडेंट का उपयोग करने से अधिक पठनीयता में सुधार करता है।

नोट 2: इसके अलावा मेरा मुख्य लक्ष्य मुझे vimrcजितना संभव हो उतना स्पष्ट करना है, अगर एक अच्छा बनाने के लिए अन्य सर्वोत्तम अभ्यास मौजूद हैं तो vimrcमैं इसके बारे में उत्सुक हूं।

संपादित करें 1: मुझे यह अनुमान लगाना चाहिए कि मेरा vimrcपहले से ही वर्गों में विभाजित है (और कभी-कभी उपधारा) मुख्य हैं

• आम विकल्प
• प्लगइन्स (प्रत्येक प्लगइन और उसके विन्यास के लिए एक उपधारा युक्त)
• मैपिंग
• नेविगेशन (उपसमूह युक्त)
• रंग
• आदि...

और यह ऐसी संरचना है जिसने मुझे तह करने के बारे में सोचा: मुझे लगता है कि केवल एक निश्चित बिंदु पर मेरी दिलचस्पी वाले अनुभाग को आउटपुट करने में सक्षम होना कुछ बहुत सुविधाजनक है।

संपादित करें 2:vimrc कई फाइलों में उप-विभाजनों का उल्लेख करने का उत्तर मान्य है, लेकिन एक व्यक्तिगत प्राथमिकता के रूप में मैं तह का उपयोग करूंगा क्योंकि मुझे लगता है कि जीआईटी रेपो में केवल एक फाइल को बनाए रखना आसान है जिसमें मेरे डॉटफाइल्स हैं। यह केवल एक व्यक्तिगत प्राथमिकता है और मुझे पता है कि इस दृष्टिकोण का उपयोग करना भी संभव है लेकिन मैं तह का उपयोग करना पसंद करूंगा।

Comments

मुझे लगता है कि "{{{चीजों को करने का तरीका सबसे 'विम जैसा' है, सोलराइज्ड प्लगइन इसका उपयोग करता है और हालाँकि यह शोर हो सकता है यह आपको मैनुअल

— फोल्ड्स

Answer 1

मेरे पास नीचे vimrcदिए गए मॉडल हैं, जिन्हें मैंने गॉडलीजेक, सारणी के लेखक से कॉपी किया है :

"" vim:fdm=expr:fdl=0
"" vim:fde=getline(v\:lnum)=~'^""'?'>'.(matchend(getline(v\:lnum),'""*')-2)\:'='

यह 2+ "की तह से शुरू होने वाली किसी भी लाइन को बनाएगा । अधिक "गहरा गुना है। यदि आप की जरूरत है तो यह आपको वर्गों को विभाजित करने की अनुमति देता है।

Comments

मैं अभी इसका परीक्षण नहीं कर सकता, लेकिन यह मेरे लिए एक आदर्श समाधान प्रतीत होता है! साझा करने के लिए धन्यवाद!

— statox

कुछ समझाते हैं: getline (v: lnum) लाइन नंबर द्वारा दिए गए लाइन के स्ट्रिंग को लौटाता है (v: lnum); = ~ का अर्थ है नियमित अभिव्यक्ति मैच; "^" "का अर्थ है कि सभी पंक्तियाँ दो" s से शुरू होती हैं; माचिस (getline (v: lnum), '"* *') - 2 की अतिरिक्त संख्या", "का अर्थ है कि" "स्तर 1 के साथ गुना होगा," " "" "स्तर 2 और इतने पर के साथ गुना होगा; गेटलाइन (v: lnum) = ~ '^ ^" "v के आधार पर सही या गलत रिटर्न: lnum लाइन दो से शुरू होती है" या नहीं "; अगर सही है, तो फेक को सेट किया जाता है >extra number of "(प्रारंभ स्तर जो इस पंक्ति में <के बाद नंबर द्वारा बैठा है) या '='(पिछली पंक्ति के स्तर का उपयोग करें), जिसका अर्थfold-expr

— वैन abel

हाल के vim अपडेट 8.1.1517 के बाद), मुझे इस कॉन्फ़िगरेशन के साथ "मॉडल का प्रसंस्करण करते समय त्रुटि का पता चला" हो रहा है।

— Apollo

Answer 2

यह एक अच्छा विचार है कि पहले अपनी खुद की श्रेणियों को अपने में परिभाषित करें .vimrc(जैसे उपले और उप-सूची के साथ एक सूची) और संबंधित श्रेणियों में अपने सभी प्लगइन्स / सेटिंग्स / फ़ंक्शन जोड़ें। अनुकूलित तह के साथ संयुक्त यह बहुत अच्छा काम कर सकता है:

ऊपर दिया गया उदाहरण संभव श्रेणियों को दिखाता है जो मुझे अपनी संरचना के लिए सहायक लगते हैं .vimrc। यह निम्नलिखित अनुकूलित गुना सेटिंग्स का उपयोग करता है:

""""""""""""""""""""""""
"  THIS IS A CATEGORY  "
""""""""""""""""""""""""
"" Autofolding .vimrc
" see http://vimcasts.org/episodes/writing-a-custom-fold-expression/
""" defines a foldlevel for each line of code
function! VimFolds(lnum)
  let s:thisline = getline(a:lnum)
  if match(s:thisline, '^"" ') >= 0
    return '>2'
  endif
  if match(s:thisline, '^""" ') >= 0
    return '>3'
  endif
  let s:two_following_lines = 0
  if line(a:lnum) + 2 <= line('$')
    let s:line_1_after = getline(a:lnum+1)
    let s:line_2_after = getline(a:lnum+2)
    let s:two_following_lines = 1
  endif
  if !s:two_following_lines
      return '='
    endif
  else
    if (match(s:thisline, '^"""""') >= 0) &&
       \ (match(s:line_1_after, '^"  ') >= 0) &&
       \ (match(s:line_2_after, '^""""') >= 0)
      return '>1'
    else
      return '='
    endif
  endif
endfunction

""" defines a foldtext
function! VimFoldText()
  " handle special case of normal comment first
  let s:info = '('.string(v:foldend-v:foldstart).' l)'
  if v:foldlevel == 1
    let s:line = ' ◇ '.getline(v:foldstart+1)[3:-2]
  elseif v:foldlevel == 2
    let s:line = '   ●  '.getline(v:foldstart)[3:]
  elseif v:foldlevel == 3
    let s:line = '     ▪ '.getline(v:foldstart)[4:]
  endif
  if strwidth(s:line) > 80 - len(s:info) - 3
    return s:line[:79-len(s:info)-3+len(s:line)-strwidth(s:line)].'...'.s:info
  else
    return s:line.repeat(' ', 80 - strwidth(s:line) - len(s:info)).s:info
  endif
endfunction

""" set foldsettings automatically for vim files
augroup fold_vimrc
  autocmd!
  autocmd FileType vim 
                   \ setlocal foldmethod=expr |
                   \ setlocal foldexpr=VimFolds(v:lnum) |
                   \ setlocal foldtext=VimFoldText() |
     "              \ set foldcolumn=2 foldminlines=2
augroup END

अपनी खुद की श्रेणियों और उपश्रेणियों को परिभाषित करने के लिए निम्नलिखित सिंटैक्स का उपयोग करें:

""""""""""""""
"  Category  "
""""""""""""""
"" Subcategory
""" Subsubcategory
" Just a comment, gets ignored no matter where

यदि आप vim-snippets (जैसे UltiSnips के साथ ) का उपयोग करते हैं तो शीर्ष स्तर की श्रेणी को वास्तव में आसान बनाया जा सकता है : बस vim-snippets द्वारा प्रदत्त boxया bboxस्निपेट का विस्तार करें ( विस्तार ट्रिगर लिखें boxया bboxदबाएं)।

दो बार अंतरिक्ष को दबाकर खुले और बंद किए गए सिलवटों को टॉगल करने के लिए:

let mapleader = "\<space>"
" Toggle folds
nnoremap <silent> <leader><Space> @=(foldlevel('.')?'za':"\<Space>")<CR>
vnoremap <leader><space> zf

इस तरह से आपके पास एक अच्छी तरह से संरचित है .vimrcजिसे आसानी से नेविगेट किया जा सकता है।

Comments

अच्छा एनिमेटेड gif के लिए +1 :) बस जिज्ञासु, आप टाइप की गई कुंजियों को प्रदर्शित करने के लिए क्या प्रयोग करते हैं?

— mMontu

@montu: मैंने इसे (दोनों डेबियन रिपॉज में) रिकॉर्ड करने के लिए चाबियाँ और gtk-recordmydesktop प्रदर्शित करने के लिए स्क्रीनकी का उपयोग किया। 5fps के साथ एक 45 सेकंड क्लिप एक MiB से कम है। फिर इसे ऑनलाइन जीआईएफ में परिवर्तित कर दिया (जो कि चित्र गुणवत्ता पूर्ण होने से पहले विकृतियां सामने आईं) थीं।

— cbaumhardt

Answer 3

मैं अपने प्राइमरी vimrcको कई अन्य वर्गीकृत फाइलों की लिंक के रूप में उपयोग करता हूं , प्रत्येक को साथ ले जाते हुए सोर्स करता हूं , जैसे एक फाइल में विम विकल्प, दूसरे में प्लगइन सेटिंग्स।

"--- Vim Options
source ~/.vim/config/vim_options.vim

"--- Here Be Functions!
" (need to be sourced before stuff that uses 'em)
runtime! functions/*.vim

"--- Key Mapping
source ~/.vim/config/key_mapping.vim

"--- Folding
source ~/.vim/config/folding.vim

"--- Autocmds
source ~/.vim/config/autocmds.vim

"--- We Are Plugged In!
source ~/.vim/config/plugins.vim

" vim: ft=vim fdm=marker

ओपी प्रश्न के अधिक प्रत्यक्ष उत्तर के रूप में, मैं मार्कर विधि का उपयोग करता हूं, लेकिन रिक्ति के साथ दाईं ओर और अधिकांश भाग के लिए व्यक्तिगत से अधिक श्रेणियां। मैं हालांकि प्रत्येक प्लगइन अलग से करता हूं।

Comments

मैं अपने प्रश्न में सटीक रूप से भूल गया कि: मैं vimrcअलग-अलग फाइलों में "अलग" करने का प्रशंसक नहीं हूं क्योंकि (आईएमओ) यह जटिलता को बढ़ाता है और इसे बनाए रखना अधिक कठिन बनाता है। फोल्डिंग के बारे में आपका क्या मतलब है "ऑफ द राइट साइड विद स्पेसिंग"?

— statox

मेरा मतलब है " {{{कि आपके रिक्त स्थान textwidthसही किनारों के पास हैं। मैं तह .vim फ़ाइल में एक व्यक्तिगत फोल्डटेक्स्ट फ़ंक्शन भी करता हूँ। मैं अलग-अलग फ़ाइलों को पसंद करता हूं ताकि मेरे git रेपो केवल एक विशिष्ट प्रकार के मॉड प्रति कमिट करें।

— धूमकेतु

Answer 4

आप कह सकते हैं कि "सबसे अच्छा अभ्यास" मुख्य रूप से राय का विषय है, :) लेकिन दो दृष्टिकोण हैं जो (1) स्पष्ट अर्थ बनाते हैं, और (2) सभी कॉन्फिग फाइलों पर लागू किया जा सकता है, न केवल विम का: तार्किक खंडों द्वारा तह और उपखंड (या इससे भी अधिक गहरा, यदि आप बहादुर महसूस करते हैं), और अपने कॉन्फिगर को कई छोटी फाइलों में विभाजित करके :source-ing कर लें।

मैं व्यक्तिगत रूप से तह पसंद करता हूं क्योंकि यह चीजों को एक्सेस करना आसान बनाता है, जबकि अभी भी मुझे लेने के लिए कुछ पदानुक्रम देता है। autocmdइन सबसे "प्राकृतिक" तार्किक इकाइयाँ बनाने के बाद से फ़ंक्शंस फ़ंक्शन और अंतरतम स्तरों पर एस भी एक अच्छा विचार है। markerतह इन सभी के लिए सबसे अधिक समझ में आता है, क्योंकि तार्किक पदानुक्रम आवश्यक रूप से इंडेंट स्तरों, या सिंटैक्स हाइलाइटिंग में परिलक्षित नहीं होते हैं। मैं भी बढ़ाता हूं foldcolumn, जो मुझे एक दृश्य संकेत देता है कि मैं कहां हूं:

# vim: filetype=vim foldmethod=marker foldlevel=0 foldcolumn=3

एक साइड नोट पर, यह foldtextफ़ंक्शन (ड्रू नील, IIRC द्वारा एक समान फ़ंक्शन का एक संशोधन) मुझे डिफ़ॉल्ट की तुलना में अधिक समझ में आता है:

function! MyFoldText()
    let line = getline(v:foldstart)

    let nucolwidth = &foldcolumn + &number * &numberwidth
    let windowwidth = winwidth(0) - nucolwidth - 3
    let foldedlinecount = v:foldend - v:foldstart

    " expand tabs into spaces
    let chunks = split(line, "\t", 1)
    let line = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - strwidth(v:val) % &tabstop)'), '') . chunks[-1]

    let line = strpart(line, 0, windowwidth - 2 - len(foldedlinecount))
    let fillcharcount = windowwidth - len(line) - len(foldedlinecount) - 1
    return line . '...' . repeat(' ', fillcharcount) . foldedlinecount . ' '
endfunction
set foldtext=MyFoldText()

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

Comments

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

— statox

कृपया यह भी बता सकते हैं कि कृपया कस्टम तह पद्धति का उपयोग कैसे करें? मैं स्थापित करने का प्रयास fdmकरने के लिए foldtextऔर MyFoldText()लेकिन ऐसा लगता है कि यह उपयोग करने के लिए सही तरीके से नहीं है की तरह।

— statox

@statox CtrlSFके लिए सर्वाधिक कारगर एजी या पावती है, जो अनिवार्य विशेषज्ञ हैं के संस्करणों grep। foldtextएक कस्टम फोल्डिंग विधि नहीं है, लेकिन फोल्डेड टेक्स्ट दिखने के तरीके को बदलने के लिए एक फ़ंक्शन है। मेरे स्निपेट में अंतिम पंक्ति यह दिखाती है कि इसका उपयोग कैसे किया जाता है set foldtext=MyFoldText():।

— lcd047

Answer 5

बुनियादी सर्वोत्तम प्रथाएँ:

• वर्गों में विभाजित करें:

  • प्लगइन्स
  • सेटिंग्स
  • rebinds

• प्रत्येक अनुभाग / खंडन पर टिप्पणी करें

• (बैकअप अपने .vimrcया _vimrcGithub पर)

बस मेरी व्यक्तिगत प्राथमिकता। शायद इतनी मदद हालांकि नहीं।

Comments

मैं व्यक्तिगत रूप से तह का उपयोग नहीं करता हूं, और आपको इसकी आवश्यकता नहीं है। बस अपने vimrc को व्यवस्थित करें और यह सब अच्छा होना चाहिए।

— गुस्ताव ब्लोमकविस्ट

मेरा vimrc पहले से ही अनुभाग (सामान्य विकल्प, प्लग इन, मैपिंग, नेविगेशन, रंग, आदि ...) में व्यवस्थित है। एक अनुभाग (या उपधारा) को मोड़ने में सक्षम होने के लिए तथ्य यह है कि आप जो संपादन / तलाश कर रहे हैं उस पर ध्यान केंद्रित करना वास्तव में अच्छा है।

— statox

ठीक है। बुरे उत्तर के लिए क्षमा करें।

— गुस्ताव ब्लोमकविस्ट

यही कारण है कि एक बुरा जवाब नहीं है और मैं नहीं detailled पर्याप्त सवाल है, कोई जरूरत नहीं खेद होने के लिए ;-) देने के लिए भी दोषी हूँ

— statox

Answer 6

@ पीटररिनकर के उत्तर से प्रेरित होकर , मैंने एटीएक्स स्टाइल हेडर का उपयोग करने के लिए निम्नलिखित को तैयार किया। इसे अपने अंत में जोड़ें.vimrc

"# Folding

" Fold with ATX style headers - "# is H1, "## is H2, and so on
" vim:fdm=expr:fdl=0
" vim:fde=getline(v\:lnum)=~'^"#'?'>'.(matchend(getline(v\:lnum),'"#*')-1)\:'='

Answer 7

यदि आपके पास मेरे जैसे बड़े कार्य हैं, तो आप इसका उपयोग अपने कार्यों को मोड़ने के लिए कर सकते हैं:

fun! MyFoldLevel(linenum)
    if ! exists('w:nextline')
        let w:nextline = 0
        let w:insideafun = 0
    endif

    if w:nextline == 1
        let w:nextline = 0
        let w:insideafun = 0
    endif

    let l:line = getline(a:linenum)

    if l:line =~# '^[[:space:]]*fun'
        let w:insideafun = 1
        return '>1'
    elseif l:line =~# '^[[:space:]]*endf'
        let w:nextline = 1
        return '<1'
    endif

    if w:insideafun == 1
        return 1
    else
        return 0
    endif
endfun

और इस मॉडल को अपने vimrc में जोड़ें:

" vim:fde=MyFoldLevel(v\:lnum):fdm=expr:

Answer 8

@Peter रिनकर और @ go2null के विचार का विस्तार। यदि आप विम मॉडल में फोल्डिंग विकल्प सेट नहीं करना चाहते हैं। फोल्डिंग विधि और फोल्डिंग एक्सप्रेशन को सेट करने के लिए आप निम्न ऑटोकैमड का उपयोग कर सकते हैं।

augroup vim_folding
    autocmd!
    autocmd FileType vim set foldmethod=expr foldlevel=0
    " note that double quote in foldexpr has to be escaped with backslash
    autocmd FileType vim set foldexpr=getline(v:lnum)=~'^\"#'?'>'.(matchend(getline(v:lnum),'\"#*')-1):'='
augroup END

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

यदि आपको लंबी foldexprस्ट्रिंग पसंद नहीं है , तो हम उसके लिए एक फ़ंक्शन परिभाषित कर सकते हैं:

function! VimFolds(lnum)
    let s:cur_line = getline(a:lnum)

    if s:cur_line =~ '^"#'
        return '>' . (matchend(s:cur_line, '"#*')-1)
    else
        return '='
    endif

endfunction

तब के बारे में autocmd लाइन को बदलने के foldexprलिए

autocmd FileType vim set foldexpr=VimFolds(v:lnum)