vim - सबस - सियाल सीमा निफे




विम में टिप्पणी/असम्बद्धता लाइनों का त्वरित तरीका क्या है? (20)

Ctrl वी

तीर कुंजी का उपयोग कर ड्रॉप करें

शिफ्ट I

शिफ्ट #

Esc

फिर प्रतीक्षा करें और किया

मेरे पास वी में एक रूबी कोड फ़ाइल खुलती है, लाइनों के साथ लाइनों पर टिप्पणी की जाती है:

class Search < ActiveRecord::Migration
  def self.up
    # create_table :searches do |t|
    #   t.integer :user_id
    #   t.string :name
    #   t.string :all_of
    #   t.string :any_of
    #   t.string :none_of
    #   t.string :exact_phrase
    # 
    #   t.timestamps
    # end
  end

  def self.down
    # drop_table :searches
  end
end

मान लें कि मैं पहली def ... end खंड में सभी लाइनों को अनदेखा करना चाहता हूं। विम में ऐसा करने का एक प्रभावी तरीका क्या है?

आम तौर पर, मैं टिप्पणी और असम्बद्धता लाइनों के लिए एक आसान और तरल तरीका ढूंढ रहा हूं। यहां मैं रूबी कोड से निपट रहा हूं, लेकिन यह जावास्क्रिप्ट ( // ) या हैमल ( -# ) हो सकता है।


टिप्पणियां टॉगल करें

अगर आपको केवल टॉगल टिप्पणियों की आवश्यकता है तो मैं tpope द्वारा commentary.vim साथ tpope

स्थापना

रोगज़नक़:

cd ~/.vim/bundle
git clone git://github.com/tpope/vim-commentary.git

vim-प्लग:

Plug 'tpope/vim-commentary'

Vundle:

Plugin 'tpope/vim-commentary'

आगे अनुकूलन

इसे अपनी .vimrc फ़ाइल में जोड़ें: noremap <leader>/ :Commentary<cr>

अब आप Leader + / दबाकर टिप्पणियां टॉगल कर सकते हैं, जैसे कि सब्लिम और एटम।


आप tpope ( commentary.vim ) द्वारा vim-commentary का उपयोग कर सकते हैं, आप इसे निम्न के रूप में उपयोग कर सकते हैं:

दबाकर दृश्य मोड दर्ज करें

'v'

फिर दबायें

'j' repeatedly or e.g 4j to select 4 row

अब चयन के साथ आपको बस इतना करना है कि कुंजी कुंजी है:

'gc'

यह निरंतर दोहराने वाली कुंजियों के लिए सभी चयनों पर टिप्पणी करेगा:

'gc'

उन कार्यों के लिए मैं ज्यादातर समय ब्लॉक चयन का उपयोग करता हूं।

अपने कर्सर को पहले # वर्ण पर रखें, Ctrl V (या gVim के लिए Ctrl क्यू ) दबाएं , और अंतिम टिप्पणी पंक्ति तक नीचे जाएं और x दबाएं, जो लंबवत सभी # वर्ण हटा देगा।

पाठ के ब्लॉक पर टिप्पणी करने के लिए लगभग समान है:

  1. सबसे पहले, पहली पंक्ति पर जाएं जिसे आप टिप्पणी करना चाहते हैं, Ctrl V दबाएं । यह संपादक को VISUAL BLOCK मोड में रखेगा।
  2. फिर तीर कुंजी का उपयोग करें और अंतिम पंक्ति तक चुनें
  3. अब Shift I दबाएं , जो संपादक को INSERT मोड में रखेगा और फिर # INSERT । यह पहली पंक्ति में हैश जोड़ देगा।
  4. फिर Esc दबाएं (इसे एक सेकंड दें), और यह अन्य सभी चयनित लाइनों पर # वर्ण डालेगा।

डिफ़ॉल्ट रूप से डेबियन / उबंटू के साथ भेजे गए विम के स्ट्रिप-डाउन संस्करण के लिए, इसके बजाय तीसरे चरण में टाइप करें : s/^/#


कभी-कभी मुझे एक रिमोट बॉक्स में घुमाया जाता है जहां मेरे प्लगइन्स और .vimrc मेरी मदद नहीं कर सकते हैं, या कभी-कभी NerdCommenter को यह गलत हो जाता है (उदाहरण के लिए जावास्क्रिप्ट HTML के अंदर एम्बेडेड)।

इन मामलों में एक निम्न-तकनीक विकल्प अंतर्निहित norm कमांड है, जो आपकी निर्दिष्ट सीमा में प्रत्येक पंक्ति पर किसी भी मनमानी vim आदेश चलाता है। उदाहरण के लिए:

# साथ टिप्पणी :

1. visually select the text rows (using V as usual)
2. :norm i#

यह प्रत्येक पंक्ति की शुरुआत में "#" सम्मिलित करता है। ध्यान दें कि जब आप टाइप करते हैं: रेंज भर जाएगी, तो यह वास्तव में इस तरह दिखेगा :'<,'>norm i#

असम्बद्ध # :

1. visually select the text as before (or type gv to re-select the previous selection)
2. :norm x

यह प्रत्येक पंक्ति के पहले चरित्र को हटा देता है। अगर मैंने 2-चार टिप्पणी जैसे // // का उपयोग किया था तो मैं बस करूँगा :norm xx दोनों वर्णों को हटाने के लिए।

यदि टिप्पणियों को ओपी के प्रश्न के रूप में इंडेंट किया गया है, तो आप इस तरह अपना विलोपन एंकर कर सकते हैं:

:norm ^x

जिसका अर्थ है "पहले गैर-अंतरिक्ष चरित्र पर जाएं, फिर एक वर्ण हटाएं"।

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

नोट 2 : यदि आप खुद को norm का उपयोग करके पाते हैं तो आप निश्चित रूप से मैपिंग भी जोड़ सकते हैं। उदाहरण के लिए ~ / .vimrc में निम्न पंक्ति डालने से आप अपने दृश्य चयन के बाद :norm ctrl-n टाइप कर सकते हैं

vnoremap <C-n> :norm

नोट 3 : बेयर-हड्डियों के विम में कभी-कभी norm कमांड नहीं होता है, इसलिए गोमांस वाले संस्करण का उपयोग करना सुनिश्चित करें, यानी आम तौर पर / usr / bin / vim, not / bin / vi

(इस जवाब में शामिल सुधार के लिए @ मॅनब्रोस्की और @ रैक्सलिस के लिए धन्यवाद)


पहले प्रेस -> Ctrl V

आवश्यकतानुसार तीर कुंजी ऊपर या नीचे दबाएं

फिर दबाएं -> शिफ्ट I

फिर टिप्पणी का उपयोग करें -> Shift #

Esc


मुझे टॉकमेंट प्लगइन का उपयोग करना पसंद है: http://www.vim.org/scripts/script.php?script_id=1173

मैंने एक लाइन या कोड के हाइलाइट किए गए ब्लॉक पर टिप्पणी करने के लिए जीसी और जीसीसी मैप किया है। यह फ़ाइल प्रकार का पता लगाता है और वास्तव में अच्छी तरह से काम करता है।


मेरे .vimrc का एक अनुभाग यहां दिया गया है:

"insert and remove comments in visual and normal mode
vmap ,ic :s/^/#/g<CR>:let @/ = ""<CR>
map  ,ic :s/^/#/g<CR>:let @/ = ""<CR>
vmap ,rc :s/^#//g<CR>:let @/ = ""<CR>
map  ,rc :s/^#//g<CR>:let @/ = ""<CR>

सामान्य और दृश्य मोड में, यह मुझे टिप्पणियों को हटाने के लिए टिप्पणियां डालने के लिए आईसी दबाता है , और आरसी देता है।


मेरे सामने 30 उत्तरों के साथ, मैं एक आसान समाधान देने की कोशिश करूंगा: लाइन की शुरुआत में # डालें। फिर एक रेखा नीचे जाओ और डॉट ( . ) दबाएं। दोहराने के लिए, j करो . , j . , इत्यादि ... असम्बद्धता के लिए, # हटाएं (आप # x पर हिट कर सकते हैं), और k का उपयोग कर रिवर्स करें . ,आदि...



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

vmap co :call EnhancedCommentify('','guess')<CR>
vmap cc :call EnhancedCommentify('','comment')<CR>
vmap cd :call EnhancedCommentify('','decomment')<CR> 

मैं अपनी .vimrc फ़ाइल में एक साधारण जोड़ के साथ आया हूं जो बहुत अच्छी तरह से काम करता है और आसानी से बढ़ाया जा सकता है। आप टिप्पणी_मैप और इसके टिप्पणी नेता को बस एक नई फ़ाइल टाइप जोड़ें।

मैंने सामान्य और दृश्य मोड में मैपिंग जोड़ा, लेकिन आप अपनी पसंद के किसी भी चीज़ को रीमेप कर सकते हैं। मैं केवल 'टॉगल' शैली समारोह पसंद करता हूं। एक भालू जिसमें कई मैपिंग आदि होते हैं।

let s:comment_map = { 
    \   "c": '\/\/',
    \   "cpp": '\/\/',
    \   "go": '\/\/',
    \   "java": '\/\/',
    \   "javascript": '\/\/',
    \   "lua": '--',
    \   "scala": '\/\/',
    \   "php": '\/\/',
    \   "python": '#',
    \   "ruby": '#',
    \   "rust": '\/\/',
    \   "sh": '#',
    \   "desktop": '#',
    \   "fstab": '#',
    \   "conf": '#',
    \   "profile": '#',
    \   "bashrc": '#',
    \   "bash_profile": '#',
    \   "mail": '>',
    \   "eml": '>',
    \   "bat": 'REM',
    \   "ahk": ';',
    \   "vim": '"',
    \   "tex": '%',
    \ }

function! ToggleComment()
    if has_key(s:comment_map, &filetype)
        let comment_leader = s:comment_map[&filetype]
        if getline('.') =~ "^\\s*" . comment_leader . " " 
            " Uncomment the line
            execute "silent s/^\\(\\s*\\)" . comment_leader . " /\\1/"
        else 
            if getline('.') =~ "^\\s*" . comment_leader
                " Uncomment the line
                execute "silent s/^\\(\\s*\\)" . comment_leader . "/\\1/"
            else
                " Comment the line
                execute "silent s/^\\(\\s*\\)/\\1" . comment_leader . " /"
            end
        end
    else
        echo "No comment leader found for filetype"
    end
endfunction


nnoremap <leader><Space> :call ToggleComment()<cr>
vnoremap <leader><Space> :call ToggleComment()<cr>

ध्यान दें:

मैं फ़ाइल प्रकार / लोडिंग में किसी भी कॉलबैक या हुक का उपयोग नहीं करता, क्योंकि मुझे लगता है कि वे वीम के स्टार्टअप को .vimrc static function / map से अधिक धीमा कर देते हैं, लेकिन यह मेरी प्राथमिकता है। मैंने इसे सरल और निष्पादित रखने की भी कोशिश की है। यदि आप ऑटोकॉन्ड्स का उपयोग करते हैं तो आपको उन्हें एक ऑटोकॉमांड समूह में रखना सुनिश्चित करना होगा या अन्यथा कॉलबैक फ़ाइलटाइप में कई बार प्रति फ़ाइल लोड हो जाएंगे और बहुत सारे प्रदर्शन में गिरावट आती है।


मैं टिम पोप की commentary.vim प्लगइन का उपयोग करता हूं।


मैं पहली और आखिरी पंक्तियों (एमए और एमबी) को चिह्नित करता हूं, और फिर करता हूं: 'ए,' बीएस / ^ # //


यदि आप पहले से ही लाइन नंबर जानते हैं, तो n,ms/# // काम करेगा।


यह सरल स्निपेट मेरे .vimrc से है:

function! CommentToggle()
    execute ':silent! s/\([^ ]\)/\/\/ \1/'
    execute ':silent! s/^\( *\)\/\/ \/\/ /\1/'
endfunction

map <F7> :call CommentToggle()<CR>

यह // - टिप्पणियों के लिए है, लेकिन आप इसे अन्य पात्रों के लिए आसानी से अनुकूलित कर सकते हैं। आप jqno के रूप में एक नेता को सेट करने के लिए autocmd का उपयोग कर सकते हैं।

यह स्वाभाविक रूप से श्रेणियों और दृश्य मोड के साथ काम करने का एक बहुत ही सरल और कुशल तरीका है।


यहां उत्तरों में विचारों से शुरूआत, मैंने अपना खुद का टिप्पणी फ़ंक्शन शुरू किया। यह टिप्पणियों को चालू और बंद करता है। यह //print('blue'); //this thing is blue जैसी चीज़ों को संभाल सकता है //print('blue'); //this thing is blue //print('blue'); //this thing is blue और सिर्फ पहली टिप्पणी को टॉगल करती है। इसके अलावा यह टिप्पणियां और एक ही स्थान जोड़ता है जहां पहली गैर सफेद जगह लाइन की शुरुआत में नहीं है। आमतौर पर यह अनावश्यक रूप से सफेद जगहों की प्रतिलिपि नहीं करता है, लेकिन इस अतिरिक्त कार्य से बचने के लिए ज़ूम (: मदद के लिए एच \ zs) का उपयोग करता है, जब टिप्पणी और इंडेंट लाइन। उम्मीद है कि यह वहां कुछ minimalists मदद करता है। सुझावों का स्वागत है।

" these lines are needed for ToggleComment()
autocmd FileType c,cpp,java      let b:comment_leader = '//'
autocmd FileType arduino         let b:comment_leader = '//'
autocmd FileType sh,ruby,python  let b:comment_leader = '#'
autocmd FileType zsh             let b:comment_leader = '#'
autocmd FileType conf,fstab      let b:comment_leader = '#'
autocmd FileType matlab,tex      let b:comment_leader = '%'
autocmd FileType vim             let b:comment_leader = '"'

" l:pos   --> cursor position
" l:space --> how many spaces we will use b:comment_leader + ' '

function! ToggleComment()
    if exists('b:comment_leader')
        let l:pos = col('.')
        let l:space = ( &ft =~ '\v(c|cpp|java|arduino)' ? '3' : '2' )
        if getline('.') =~ '\v(\s*|\t*)' .b:comment_leader
            let l:space -= ( getline('.') =~ '\v.*\zs' . b:comment_leader . '(\s+|\t+)@!' ?  1 : 0 )
            execute 'silent s,\v^(\s*|\t*)\zs' .b:comment_leader.'[ ]?,,g'
            let l:pos -= l:space
        else
            exec 'normal! 0i' .b:comment_leader .' '
            let l:pos += l:space
        endif
        call cursor(line("."), l:pos)
    else
        echo 'no comment leader found for filetype'
    end
endfunction

nnoremap <Leader>t :call ToggleComment()<CR>
inoremap <Leader>t <C-o>:call ToggleComment()<CR>
xnoremap <Leader>t :'<,'>call ToggleComment()<CR>

यहां बताया गया है कि मैं इसे कैसे करता हूं:

  1. पहली पंक्ति पर जाएं जिसे आप टिप्पणी करना चाहते हैं।

  2. जीवीआईएम में Ctrl + q या VIM में Ctrl + v दबाएं , फिर टिप्पणी करने के लिए लाइनों पर पहले वर्ण का चयन करने के लिए नीचे जाएं।

  3. फिर सी दबाएं, और टिप्पणी चरित्र जोड़ें।

विघटन एक ही तरीके से काम करता है, बस टिप्पणी चरित्र के बजाय एक जगह टाइप करें।


vim-commentary नामक tpope द्वारा इस जीवन को बदलने वाली प्लगइन है

commentary.vim

यह प्लगइन प्रदान करता है :

  • मानसिक स्वास्थ्य
  • उचित इंडेंट टिप्पणियां
  • खाली / अनावश्यक लाइनों पर टिप्पणी नहीं करता है

उपयोग :

  • वंडल (या पथजन I अनुमान) के माध्यम से स्थापित करें।
  • अपने टेक्स्ट को हाइलाइट करें और दबाएं : जो इस प्रकार दिखाएगा :<,'>
  • टिप्पणी यहां लिखें :<,'>Commentary और एंटर दबाएं
  • बूम। आपका पूरा कली

Vi में निम्नलिखित तीन पंक्तियों को कैसे असम्बद्ध करें:

#code code
#code
#code code code

कर्सर को ऊपरी बाएं # प्रतीक पर रखें और Ctrl V दबाएं । यह आपको दृश्य ब्लॉक मोड में डालता है। सभी तीन लाइनों का चयन करने के लिए नीचे तीर या जे तीन बार दबाएं। फिर डी दबाएं। सभी टिप्पणियां गायब हो गईं। पूर्ववत करने के लिए, यू दबाएं।

Vi में निम्नलिखित तीन पंक्तियों पर टिप्पणी कैसे करें:

code code
code
code code code

ऊपरी बाएं चरित्र पर कर्सर रखें, Ctrl V दबाएं । यह आपको दृश्य ब्लॉक मोड में डालता है। सभी तीन लाइनों का चयन करने के लिए या जे तीन बार दबाएं। फिर दबायें:

मैं / एएससी

यह एक राजधानी I, //, और एस्केप है।

जब आप ईएससी दबाते हैं, तो सभी चयनित लाइनों को आपके द्वारा निर्दिष्ट टिप्पणी प्रतीक मिलेगा।







comments