Ik heb een Ruby-codebestand geopend in vi, er zijn regels becommentarieerd met #:

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

Stel dat ik alle regels in de eerste def ... endsectie wil verwijderen. Wat is een efficiënte manier om dat te doen in Vim?

Over het algemeen ben ik op zoek naar een gemakkelijke en vlotte manier om commentaar te geven op en commentaar op regels te verwijderen. Hier heb ik te maken met Ruby-code, maar het kan JavaScript (//) of Haml (-#) zijn.

Antwoord 1, autoriteit 100%

Ik gebruik het NERD Commenter-script. Hiermee kunt u gemakkelijk opmerkingen in uw code plaatsen, verwijderen of schakelen tussen opmerkingen.

Zoals vermeld in de reacties :

voor iedereen die in de war is door het gebruik, de standaard leader is “\”, dus 10\cc zal tien regels becommentariëren en 10\cu zal die tien regels verwijderen

Antwoord 2, autoriteit 90%

Voor die taken gebruik ik meestal blokselectie.

Plaats uw cursor op het eerste teken #, druk op CtrlV(of CtrlQ voor gVim), en ga naar beneden tot de laatste regel met commentaar en druk op x, waarmee alle #-tekens verticaal worden verwijderd.

Voor het becommentariëren van een tekstblok is bijna hetzelfde:

1. Ga eerst naar de eerste regel die u wilt toevoegen, druk op CtrlV. Hierdoor wordt de editor in de modus VISUAL BLOCKgezet.
2. Gebruik vervolgens de pijltjestoets en selecteer tot de laatste regel
3. Druk nu op ShiftI, waardoor de editor in de modus INSERTkomt en druk vervolgens op #. Dit voegt een hash toe aan de eerste regel.
4. Druk vervolgens op Esc(geef het even), en het zal een #-teken invoegen op alle andere geselecteerde regels.

Voor de uitgeklede versie van vim die standaard bij debian/ubuntu wordt geleverd, typt u in plaats daarvan : s/^/#in de derde stap (elke resterende markering van het eerste teken van elke regel kan worden verwijderd met :nohl).

Hier zijn twee kleine schermopnamen voor visuele referentie.

Opmerking:

Opmerking opheffen:

Antwoord 3, autoriteit 93%

Als commentaar op blokken in vim:

• druk op Esc(om de bewerkings- of andere modus te verlaten)
• druk op ctrl+v(visuele blokkeringsmodus)
• gebruik de ↑/↓pijltoetsen om de gewenste regels te selecteren (het zal niet alles markeren – het is OK!)
• Shift+i(hoofdletter I)
• voeg de gewenste tekst in, b.v. %
• druk op EscEsc

Om blokkades in vim ongedaan te maken:

• druk op Esc(om de bewerkings- of andere modus te verlaten)
• druk op ctrl+v(visuele blokkeringsmodus)
• gebruik de ↑/↓pijltjestoetsen om de regels te selecteren waarvan je commentaar wilt verwijderen.

  Als u meerdere tekens wilt selecteren, gebruik er dan één of combineer deze methoden:

  • gebruik de pijltoetsen links/rechts om meer tekst te selecteren
  • om stukken tekst te selecteren, gebruik shift+ ←/→pijltoets
  • je kunt herhaaldelijk op de verwijdertoetsen hieronder drukken, zoals een gewone verwijderknop

• druk op dof xom tekens te verwijderen, herhaaldelijk indien nodig

Antwoord 4, autoriteit 94%

Soms zit ik in een externe box waar mijn plug-ins en .vimrc me niet kunnen helpen, of soms heeft NerdCommenter het bij het verkeerde eind (bijv. JavaScript ingebed in HTML).

In deze gevallen is een low-tech alternatief het ingebouwde norm-commando, dat willekeurige vim-commando’s uitvoert op elke regel in het door u opgegeven bereik. Bijvoorbeeld:

Reageren met#:

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

Hiermee wordt “#” ingevoegd aan het begin van elke regel. Merk op dat wanneer u typt: het bereik wordt ingevuld, zodat het er echt uitziet als :'<,'>norm i#

Commentaar verwijderen#:

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

Hiermee wordt het eerste teken van elke regel verwijderd. Als ik een opmerking met 2 tekens had gebruikt, zoals //, dan zou ik gewoon :norm xxdoen om beide tekens te verwijderen.

Als de opmerkingen zijn ingesprongen zoals in de OP’s vraag, dan kunt u uw verwijdering als volgt verankeren:

:norm ^x

wat betekent “ga naar het eerste teken zonder spatie en verwijder vervolgens één teken”. Merk op dat, in tegenstelling tot blokselectie, deze techniek zelfs werkt als de opmerkingen ongelijk zijn ingesprongen!

Opmerking: aangezien normletterlijk alleen gewone vim-commando’s uitvoert, ben je niet beperkt tot opmerkingen, je zou ook wat complexe bewerkingen aan elke regel kunnen doen. Als je het escape-teken nodig hebt als onderdeel van je opdrachtenreeks, typ je ctrl-v en druk je op de escape-toets (of nog makkelijker, neem gewoon een snelle macro op en gebruik dan norm om die macro op elke regel uit te voeren).

Opmerking 2: Je kunt natuurlijk ook een mapping toevoegen als je merkt dat je normveel gebruikt. Als u bijvoorbeeld de volgende regel in ~/.vimrc plaatst, kunt u ctrl-ntypen in plaats van :normna het maken van uw visuele selectie

vnoremap <C-n> :norm

Opmerking 3: Bare-bones vim heeft soms niet de opdracht normerin gecompileerd, dus zorg ervoor dat je de verbeterde versie gebruikt, dwz meestal /usr /bin/vim, niet /bin/vi

(Met dank aan @Manbroski en @rakslice voor de verbeteringen die in dit antwoord zijn verwerkt)

Antwoord 5, autoriteit 76%

Ik heb het volgende in mijn .vimrc:

" Commenting blocks of code.
augroup commenting_blocks_of_code
  autocmd!
  autocmd FileType c,cpp,java,scala let b:comment_leader = '// '
  autocmd FileType sh,ruby,python   let b:comment_leader = '# '
  autocmd FileType conf,fstab       let b:comment_leader = '# '
  autocmd FileType tex              let b:comment_leader = '% '
  autocmd FileType mail             let b:comment_leader = '> '
  autocmd FileType vim              let b:comment_leader = '" '
augroup END
noremap <silent> ,cc :<C-B>silent <C-E>s/^/<C-R>=escape(b:comment_leader,'\/')<CR>/<CR>:nohlsearch<CR>
noremap <silent> ,cu :<C-B>silent <C-E>s/^\V<C-R>=escape(b:comment_leader,'\/')<CR>//e<CR>:nohlsearch<CR>

Je kunt nu ,cctypen om een regel te becommentariëren en ,cuom de commentaar op een regel ongedaan te maken (werkt zowel in de normale als in de visuele modus).

(Ik heb het jaren geleden van een website gestolen, dus ik kan niet meer helemaal uitleggen hoe het werkt :). Er is een commentaarwaar het wordt uitgelegd.)

Antwoord 6, autoriteit 73%

Specificeer op welke regels je wilt reageren in vim:

Onthul de regelnummers:

:set number

dan

:5,17s/^/#/     this will comment out line 5-17

of dit:

:%s/^/#/        will comment out all lines in file

Antwoord 7, autoriteit 34%

Dit is hoe ik het doe:

1. Ga naar het eerste teken op de eerste regel waarop je een opmerking wilt plaatsen.

2. Druk op Ctrl+qin GVIM of Ctrl+vin VIM en ga naar beneden om het eerste teken te selecteren op de regels om commentaar te geven.

3. Druk vervolgens op cen voeg het commentaarteken toe.

Commentaar verwijderen werkt op dezelfde manier, typ gewoon een spatie in plaats van het commentaarteken.

Antwoord 8, autoriteit 23%

Opmerkingen wisselen

Als alles wat je nodig hebt is opmerkingen schakelen, ga ik liever voor commentaar. vimdoor tpope.

Installatie

Pathogeen:

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

vim-plug:

Plug 'tpope/vim-commentary'

Vundle:

Plugin 'tpope/vim-commentary'

Verdere aanpassing

Voeg dit toe aan uw .vimrc-bestand: noremap <leader>/ :Commentary<cr>

Je kunt nu wisselen tussen opmerkingen door op Leader+/te drukken, net zoals Sublime en Atom.

Antwoord 9, autoriteit 22%

Ik heb een eenvoudige toevoeging aan mijn .vimrc-bestand bedacht die redelijk goed werkt en gemakkelijk kan worden uitgebreid. Je voegt gewoon een nieuw bestandstype toe aan de comment_map en zijn commentaarleider.

Ik heb een toewijzing toegevoegd aan de normale en visuele modi, maar je kunt ze opnieuw toewijzen aan alles wat je maar wilt. Ik heb liever alleen een ‘toggle’-stijlfunctie. Een beer heeft meerdere toewijzingen enz.

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>

Opmerking:

Ik gebruik geen callbacks of hooks in de bestandstypes/laden, omdat ik vind dat ze het opstarten van Vim meer vertragen dan de .vimrcstatische functie/kaart, maar dat is gewoon mijn voorkeur. Ik heb ook geprobeerd het simpel en performant te houden. Als u autocommands gebruikt, moet u ervoor zorgen dat u ze in een autocommand-groep plaatst, anders worden de callbacks meerdere keren per geladen bestand aan het bestandstype toegevoegd en veroorzaken ze veel prestatievermindering.

Antwoord 10, autoriteit 14%

Gebruik Control-V om rechthoeken met tekst te selecteren: ga naar het eerste #teken, typ Ctrl+V, ga één keer naar rechts, en dan naar beneden, tot het einde van de opmerkingen. Typ nu x: je verwijdert alle #-tekens gevolgd door één spatie.

Antwoord 11, autoriteit 10%

Hier is een gedeelte van mijn .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>

In normale en visuele modus kan ik op ,icdrukken om opmerkingen in te voegen en ,rcom opmerkingen te verwijderen.

Antwoord 12, autoriteit 10%

Ik gebruik vim 7.4 en dit werkt voor mij.
Ervan uitgaande dat we 3 regels becommentariëren/uncommenteren.

Reageren:

als de regel geen tab/spatie aan het begin heeft:
ctrl + Vdan jjjdan shift + I (cappital i)dan //dan esc esc
als de regel tab/spatie aan het begin heeft, kunt u nog steeds het bovenstaande doen of omwisselen voor c:
ctrl + Vdan jjjdan cdan //en dan esc esc

Reactie ongedaan maken:

als de regels aan het begin geen tab/spatie hebben:
ctrl + Vdan jjjdan ll (lower cap L)dan c

als de regels tab/spatie aan het begin hebben, plaats je er één boven en esc
ctrl + Vdan jjjdan ll (lower cap L)dan cdan spacedan esc

Antwoord 13, autoriteit 6%

Ik heb het antwoord van Phil en jqno gecombineerd en opmerkingen met spaties ongedaan gemaakt:

autocmd FileType c,cpp,java,scala let b:comment_leader = '//'
autocmd FileType sh,ruby,python   let b:comment_leader = '#'
autocmd FileType conf,fstab       let b:comment_leader = '#'
autocmd FileType tex              let b:comment_leader = '%'
autocmd FileType mail             let b:comment_leader = '>'
autocmd FileType vim              let b:comment_leader = '"'
function! CommentToggle()
    execute ':silent! s/\([^ ]\)/' . escape(b:comment_leader,'\/') . ' \1/'
    execute ':silent! s/^\( *\)' . escape(b:comment_leader,'\/') . ' \?' . escape(b:comment_leader,'\/') . ' \?/\1/'
endfunction
map <F7> :call CommentToggle()<CR>

hoe het werkt:

Laten we aannemen dat we met #-comments werken.

Het eerste commando s/\([^ ]\)/# \1/zoekt naar het eerste niet-spatieteken [^ ]en vervangt dat door # +itself. De zelfvervanging wordt gedaan door het \(..\)in het zoekpatroon en \1in het vervangingspatroon.

Het tweede commando s/^\( *\)# \?# \?/\1/zoekt naar regels die beginnen met een dubbele opmerking ^\( *\)# \?# \?(accepteert 0 of 1 spaties tussen opmerkingen) en vervangt deze eenvoudig door het niet-commentaargedeelte \( *\)(wat hetzelfde aantal voorafgaande spaties betekent).

Voor meer details over vim-patronen, check dituit.

Antwoord 14, autoriteit 5%

Met 30 antwoorden voor de boeg, zal ik proberen een nog eenvoudigere oplossing te geven: voeg een #toe aan het begin van de regel. Ga dan een regel naar beneden en druk op punt (.). Om te herhalen, doe je j,.,j,., etc…Om commentaar ongedaan te maken, verwijder je een #(je kunt xboven de #drukken), en doe het omgekeerde met k,.,etc…

15, Autoriteit 5%

Als u de lijnnummers al kent, zou dan n,ms/# //werken.

16, Autoriteit 5%

Ik hou van gebruik van de TcomTment-plug-in:
http://www.vim.org/scripts/script.php?Script_id=1173

Ik heb GC en GCC in kaart gebracht om een ​​regel of een gemarkeerd blok code te beantwoorden. Het detecteert het bestandstype en werkt heel goed.

17, Autoriteit 4%

Ja, er zijn al 33 (meestal repetitieve) antwoorden op deze vraag.

Hier is een andere benadering van hoe commentaar van lijnen in VIM: bewegingen . Het basisidee is om commentaar of onzekerheid uit te voeren met behulp van dezelfde methode als rukken van een alinea door yipte typen of 2 regels te verwijderen door djte typen.

Deze aanpak laat u dingen doen zoals:

• ccjOm de volgende 2 regelingen uit te voeren, en cukom deze te negeren;

• cci{om commentaar te geven op een blokkering en cui{om het commentaar op te heffen;

• ccipom een hele alinea te becommentariëren, en cuipom de commentaar ongedaan te maken.

• ccGom alles tot op de laatste regel te becommentariëren, en cuggom alles tot op de eerste regel te verwijderen.

Alles wat je nodig hebt zijn 2 functies die die over bewegingen werken, en 2 toewijzingen voor elke functie. Eerst de toewijzingen:

nnoremap <silent> cc  :set opfunc=CommentOut<cr>g@
vnoremap <silent> cc  :<c-u>call  CommentOut(visualmode(), 1)<cr>
nnoremap <silent> cu  :set opfunc=Uncomment<cr>g@
vnoremap <silent> cu  :<c-u>call  Uncomment(visualmode(), 1)<cr>

(Zie de handleiding over de operator g@en de variabele operatorfunc.)

En nu de functies:

function! CommentOut(type, ...)
  if a:0
    silent exe "normal!  :'<,'>s/^/#/\<cr>`<"
  else
    silent exe "normal!  :'[,']s/^/#/\<cr>'["
  endif
endfunction
function! Uncomment(type, ...)
  if a:0
    silent exe "normal!  :'<,'>s/^\\(\\s*\\)#/\\1/\<cr>`<"
  else
    silent exe "normal!  :'[,']s/^\\(\\s*\\)#/\\1/\<cr>`["
  endif
endfunction

Wijzig de reguliere expressies hierboven naar uw smaak met betrekking tot waar de #moet zijn:

Antwoord 18, autoriteit 4%

Ik markeer de eerste en laatste regel (ma en mb), en doe dan :’a,’bs/^# //

Antwoord 19, autoriteit 4%

Er is een levensveranderende plug-in van tpopegenaamd vim-commentary

https://github.com/tpope/vim-commentary

Deze plug-in biedt :

• gezond verstand
• Correct ingesprongen opmerkingen
• geeft geen reactie op lege / onnodige lijnen

gebruik :

• installeren via vundle (of pathogeen, denk ik).
• Markeer uw tekst en druk op : die zal laten zien als :<,'>
• Type COMMENTARY HIER :<,'>Commentaryen druk op ENTER .
• Boom. Je werkknop.

20, Autoriteit 3%

Ik gebruik verbeterdeCommentificeren . Het reacties alles wat ik nodig had (programmeertalen, scripts, configuratiebestanden). Ik gebruik het met de bindingen van de visuele modus. Selecteer eenvoudig tekst die u wilt reageren en druk op CO / CC / CD.

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

Antwoord 21, autoriteit 2%

Ik gebruik de plug-in vim-commentaryvan Tim Pope.

Antwoord 22, autoriteit 2%

Visual en Shift-Iwerkten niet voor mij.

Het eenvoudigste dat werkte zonder plug-ins is

1. Selecteer blok - Ven vervolgens jof k(gebruik geen pijltjestoetsen) 🙂

2. Druk vervolgens op :het vraagt opdracht om :'<,'>

   Reageren

   Using #  - `s/^/#/` 
   Using `//` - `s/^/\/\//`
   

   Om commentaar te verwijderen

   Using #  - `s/^#//` 
   Using `//` - `s/^\/\//`
   

Uitleg -

'<,'>- Toepassen op visueel blok

s- vervanging

^- begint met

na /teken #toe te voegen in dit geval van \/\/escaped voor //

Antwoord 23, autoriteit 2%

Dit eenvoudige fragment is van mijn .vimrc:

function! CommentToggle()
    execute ':silent! s/\([^ ]\)/\/\/ \1/'
    execute ':silent! s/^\( *\)\/\/ \/\/ /\1/'
endfunction
map <F7> :call CommentToggle()<CR>

Het is voor //-Comments, maar je kunt het gemakkelijk aanpassen voor andere karakters. Je zou autocmd kunnen gebruiken om een leider in te stellen zoals jqno suggereerde.

Dit is een zeer eenvoudige en efficiënte manier om natuurlijk met bereiken en visuele modus te werken.

Antwoord 24, autoriteit 2%

"comment (cc) and uncomment (cu) code 
noremap   <silent> cc      :s,^\(\s*\)[^# \t]\@=,\1# ,e<CR>:nohls<CR>zvj
noremap   <silent> cu      :s,^\(\s*\)# \s\@!,\1,e<CR>:nohls<CR>zvj

Je kunt een of meerdere regels becommentariëren/verwijderen met #. Om meerdere regels te maken, selecteert u de regels en typt u cc/cu snelkoppeling, of typt u een nummer en vervolgens cc/cu, b.v. 7cc zal 7 regels van de cursor becommentariëren.

Ik heb de originele code gekregen van de persoon op Wat is de meest elegante manier om blokken ruby-code in Vim te becommentariëren/verwijderen?en heb enkele kleine wijzigingen aangebracht (sneltoetsen gewijzigd en een spatie toegevoegd na de #).

Antwoord 25, autoriteit 2%

Je kunt vim-commentary by tpope gebruiken (https://github.com/tpope/vim-commentary ) je kunt het als volgt gebruiken:

Ga naar de visuele modus door op

. te drukken

'v'

Druk vervolgens op

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

Nu hoef je alleen nog maar met de selectie te doen:

'gc'

Hiermee wordt de hele selectie als commentaar verwijderd, om herhalingstoetsen te verwijderen:

'gc'

Antwoord 26, autoriteit 2%

Hier is een eenvoudige oneliner gebaseerd op de C-vgevolgd door de hierboven beschreven I-methode.

Deze opdracht (:Comment) voegt een gekozen tekenreeks toe aan het begin van alle geselecteerde regels.

command! -range -nargs=1 Comment :execute "'<,'>normal! <C-v>0I" . <f-args> . "<Esc><Esc>"

Voeg deze regel toe aan uw .vimrcom een opdracht te maken die een enkel argument accepteert en het argument aan het begin van elke regel in de huidige selectie plaatst.

Bijvoorbeeld als de volgende tekst is geselecteerd:

1
2

en je voert dit uit: :Comment //, het resultaat is:

//1
//2

Antwoord 27, autoriteit 2%

Te beginnen met de ideeën in antwoorden hier, begon ik mijn eigen commentaarfunctie.
Het schakelt opmerkingen in en uit. Het kan zaken aan als //print('blue'); //this thing is blueen schakelt gewoon de eerste opmerking in. Verder voegt het commentaar en een enkele spatie toe precies waar de eerste niet-witruimte is en niet helemaal aan het begin van de regel.
Bovendien kopieert het niet onnodig de witruimten, maar gebruikt het zooms (:h \zs voor hulp) om dit extra werk te vermijden, bij commentaar en ingesprongen regel.
Ik hoop dat het enkele minimalisten helpt. Suggesties zijn welkom.

" 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>

Antwoord 28, autoriteit 2%

Ik gebruik comments.vim van Jasmeet Singh Anand(gevonden op vim.org),

Het werkt met C, C++, Java, PHP[2345], proc, CSS, HTML, htm, XML, XHTML, vim, vimrc, SQL, sh, ksh, csh, Perl, tex, fortran, ml, caml , ocaml, vhdl, haskel en normale bestanden

Het becommentarieert en verwijdert commentaar op regels in verschillende bronbestanden in zowel de normale als de visuele modus

Gebruik:

• CtrlCom een enkele regel commentaarte geven
• CtrlXom commentaar ongedaan te makeneen enkele regel
• ShiftVen selecteer meerdere regels, dan CtrlCom commentaar te geven op de geselecteerde meerdere regels
• ShiftVen selecteer meerdere regels, dan CtrlXom commentaar op de geselecteerde meerdere regels te verwijderen