Wie kann man Zeilen in Vim schnell kommentieren/auskommentieren?

Für diese Aufgaben verwende ich meistens Blockauswahl .

Stellen Sie den Cursor auf das erste Zeichen # und drücken Sie CtrlV (oder CtrlQ für gVim) und gehen Sie bis zur letzten kommentierten Zeile und drücken Sie xDamit werden alle Zeichen von # vertikal gelöscht.

Das Kommentieren eines Textblocks ist fast dasselbe:

1. Gehen Sie zunächst zur ersten Zeile, die Sie kommentieren möchten, und drücken Sie CtrlV. Dadurch wird der Editor in den Modus VISUAL BLOCK versetzt.
2. Verwenden Sie dann die Pfeiltaste und wählen Sie bis zur letzten Zeile
3. Jetzt drücken ShiftI, der den Editor in den Modus INSERT versetzt und dann drückt #. Dies fügt einen Hash in die erste Zeile ein.
4. Dann drücken Esc (Geben Sie ihm eine Sekunde), und es wird ein #-Zeichen in alle anderen ausgewählten Zeilen eingefügt.

Für die abgespeckte Version von vim, die standardmäßig mit debian/ubuntu ausgeliefert wird, geben Sie stattdessen im dritten Schritt : s/^/# ein.

Hier sind zwei kleine Bildschirmaufnahmen als visuelle Referenz.

Kommentar:

Kommentar:

So kommentieren Sie Blöcke in vim aus:

• drücken Sie Esc (um den Bearbeitungsmodus oder einen anderen Modus zu verlassen)
• schlagen ctrl+v (visueller Blockmodus)
• verwenden Sie die Pfeiltasten nach oben/unten, um die gewünschten Zeilen auszuwählen (es wird nicht alles hervorgehoben - es ist in Ordnung!)
• Shift+i (Hauptstadt I)
• geben Sie den gewünschten Text ein, d. h. %
• drücken Sie EscEsc

So kommentieren Sie Blöcke in vim aus:

• drücken Sie Esc (um den Bearbeitungsmodus oder einen anderen Modus zu verlassen)
• schlagen ctrl+v (visueller Blockmodus)
• benutze die ↑/↓ Pfeiltasten, um die zu entkommentierenden Zeilen auszuwählen.

  Wenn Sie mehrere Zeichen auswählen möchten, verwenden Sie eines oder kombinieren Sie diese Methoden:

  • Verwenden Sie die Pfeiltasten nach links/rechts, um weiteren Text auszuwählen
  • m Textblöcke auszuwählen, verwenden Sie shift + ←/→ Pfeiltaste
  • Sie können die folgenden Löschtasten wie eine normale Löschtaste wiederholt drücken
• drücken Sie d oder x Zeichen löschen, ggf. mehrmals

Manchmal bin ich in eine Remote-Box eingebettet, in der meine Plugins und .vimrc mir nicht helfen können, oder manchmal bringt NerdCommenter einen Fehler (zB in HTML eingebettetes JavaScript). 

In diesen Fällen ist der Low-Tech-Befehl der eingebaute norm-Befehl, der nur beliebige vim-Befehle in jeder Zeile in Ihrem angegebenen Bereich ausführt. Zum Beispiel:

Kommentieren mit #:

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

Dies fügt "#" am Anfang jeder Zeile ein. Beachten Sie Folgendes, wenn Sie Folgendes eingeben: Der Bereich wird ausgefüllt, so dass er wirklich aussieht wie :'<,'>norm i#

unkommentiert #:

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

Dadurch wird das erste Zeichen jeder Zeile gelöscht. Wenn ich einen 2-Zeichen-Kommentar wie // verwendet hätte, würde ich einfach :norm xx verwenden, um beide Zeichen zu löschen. 

Wenn die Kommentare wie in der Frage des OP eingerückt sind, können Sie Ihre Löschung folgendermaßen verankern: 

:norm ^x

was bedeutet "zum ersten Nicht-Leerzeichen gehen, dann ein Zeichen löschen". Beachten Sie, dass diese Technik im Gegensatz zur Blockauswahl auch dann funktioniert, wenn die Kommentare ungleichmäßige Einrückung haben!

Note: Da norm buchstäblich nur reguläre vim-Befehle ausführt, sind Sie nicht auf Kommentare beschränkt, Sie können auch einige komplexe Bearbeitungen für jede Zeile vornehmen. Wenn Sie das Escape-Zeichen als Teil Ihrer Befehlsfolge benötigen, geben Sie ctrl-v ein, und drücken Sie die Escape-Taste (oder, noch einfacher, nehmen Sie einfach ein schnelles Makro auf und verwenden Sie norm, um dieses Makro in jeder Zeile auszuführen).

Note 2: Sie können natürlich auch ein Mapping hinzufügen, wenn Sie norm häufig verwenden. Wenn Sie beispielsweise die folgende Zeile in ~/.vimrc eingeben, können Sie nach der visuellen Auswahl ctrl-n anstelle von :norm eingeben

vnoremap <C-n> :norm

Note 3: Bei Bare-Bones vim ist manchmal der Befehl norm nicht kompiliert. Verwenden Sie daher die aufgeraute Version, dh normalerweise/usr/bin/vim, nicht/bin/vi

(Danke an @Manbroski und @rakslice für die in dieser Antwort enthaltenen Verbesserungen)

Ich habe folgendes in meinem .vimrc:

" Commenting blocks of code.
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 = '" '
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>

Jetzt können Sie ,cc eingeben, um eine Zeile zu kommentieren, und ,cu, um eine Zeile zu kommentieren (funktioniert sowohl im normalen als auch im visuellen Modus).

(Ich habe es vor einigen Jahren von einer Website gestohlen, so dass ich nicht mehr vollständig erklären kann, wie es funktioniert :). Es gibt einen Kommentar wo es erklärt wird.)

Legen Sie fest, welche Zeilen in vim kommentiert werden sollen:

Enthüllen Sie die Zeilennummern:

:set number

dann 

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

oder dieses:

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

So mache ich es:

1. Gehen Sie in der ersten Zeile, die Sie auskommentieren möchten, zum ersten Zeichen.

2. Schlagen Ctrl+q in GVIM oder Ctrl+v Gehen Sie in VIM nach unten, um das erste Zeichen in den zu kommentierenden Zeilen auszuwählen.

3. Dann drücken c, und fügen Sie das Kommentarzeichen hinzu.

Das Auskommentieren funktioniert auf die gleiche Weise. Geben Sie einfach ein Leerzeichen anstelle des Kommentarzeichens ein.

Ich habe mir eine einfache Ergänzung zu meiner .vimrc-Datei ausgedacht, die ziemlich gut funktioniert und leicht erweitert werden kann. Sie fügen einfach einen neuen Dateityp zur comment_map und deren Kommentarzeile hinzu.

Ich habe zu normalen und visuellen Modi ein Mapping hinzugefügt, aber Sie können alles nach Belieben neu zuordnen. Ich ziehe es vor, nur eine Umschaltfunktion zu haben. Ein Bär hat mehrere Mappings usw. 

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>

Hinweis:

Ich verwende keine Callbacks oder Hooks für die Dateitypen/das Laden, da ich finde, dass sie den Start von Vim mehr verlangsamen als die .vimrc statische Funktion/Map, aber das ist nur meine Präferenz. Ich habe auch versucht, es einfach und performant zu halten. Wenn Sie Autocommands verwenden, müssen Sie sicherstellen, dass diese in einer Autocommand-Gruppe enthalten sind. Andernfalls werden die Rückrufe dem Dateityp mehrmals pro geladener Datei hinzugefügt, wodurch die Leistung stark beeinträchtigt wird. 

Kommentare umschalten

Wenn Sie nur toggle comments benötigen, gehe ich lieber zu comment.vim von tpope .

Installation

Erreger:

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

vim-plug:

Plug 'tpope/vim-commentary'

Vundle: 

Plugin 'tpope/vim-commentary'

Weitere Anpassung

Fügen Sie dies Ihrer .vimrc-Datei hinzu: noremap <leader>/ :Commentary<cr>

Sie können jetzt Kommentare umschalten, indem Sie Leader + / drücken, genau wie bei Sublime und Atom.

Verwenden Sie Strg-V, um Rechtecke aus Text auszuwählen: Wechseln Sie zum ersten Zeichen #, und geben Sie Folgendes ein Ctrl+VBewegen Sie sich einmal nach rechts und dann nach unten bis zum Ende der Kommentare. Geben Sie nun x ein: Sie löschen alle #-Zeichen, gefolgt von einem Leerzeichen.

Hier ist ein Abschnitt meines .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>

Im normalen und im visuellen Modus kann ich auf drücken ,ic Kommentare einfügen und,rc Kommentare entfernen.

Mit 30 Antworten vor mir versuche ich eine noch einfachere Lösung zu geben: Fügen Sie einen # am Anfang der Zeile ein. Gehen Sie dann eine Zeile nach unten und drücken Sie Punkt (.). Um dies zu wiederholen, machen Sie j, ., j, ., etc ... Um ein Kommentar zu entfernen, entfernen Sie einen # (Sie können x über den # drücken), und umgekehrt mit k, . etc ... 

Wie Sie die folgenden drei Zeilen in vi auskommentieren:

#code code
#code
#code code code

Platzieren Sie den Mauszeiger über dem Symbol # oben links und drücken Sie CtrlV. Dies versetzt Sie in den visuellen Blockmodus. Drücken Sie den Abwärtspfeil oder J dreimal, um alle drei Zeilen auszuwählen. Dann drücken D. Alle Kommentare verschwinden. Zum Rückgängigmachen drücken Sie U.

Wie kommentiert man die folgenden drei Zeilen in vi:

code code
code
code code code

Platzieren Sie den Cursor über dem oberen linken Zeichen und drücken Sie CtrlV. Dies versetzt Sie in den visuellen Blockmodus. Drücken Sie ↓ oder J dreimal, um alle drei Zeilen auszuwählen. Dann drücken:

I//Esc

Das ist eine Hauptstadt, die ich, und Flucht.

Wenn Sie drücken ESCerhalten alle ausgewählten Zeilen das von Ihnen angegebene Kommentarsymbol.

Ich verwende vim 7.4 und das funktioniert für mich.
Angenommen, wir kommentieren/kommentieren 3 Zeilen. 

Kommentieren: 

wenn die Zeile am Anfang kein Tab/Leerzeichen hat: 
ctrl + V dann jjj dann shift + I (cappital i) dann //dann esc esc 
Wenn die Zeile am Anfang ein Tab/Leerzeichen hat, können Sie das obige noch tun oder für c tauschen: 
ctrl + V dann jjj dann c dann //dann esc esc 

Unkommentieren:

wenn die Zeilen am Anfang kein Tab/Leerzeichen haben: 
ctrl + V dann jjj dann ll (lower cap L) dann c 

wenn die Zeilen am Anfang ein Tab/Leerzeichen haben, geben Sie ein Leerzeichen und esc ein. 
ctrl + V dann jjj dann ll (lower cap L) dann c dann space dann esc 

Ich benutze gerne das tcomment Plugin: http://www.vim.org/scripts/script.php?script_id=1173

Ich habe gc und gcc zugeordnet, um eine Zeile oder einen hervorgehobenen Codeblock zu kommentieren. Es erkennt den Dateityp und funktioniert sehr gut. 

Ja, es gibt bereits 33 (meist wiederholte) Antworten auf diese Frage.

Hier ist ein weiterer Ansatz, um Zeilen in Vim zu kommentieren: Bewegungen . Die Grundidee besteht darin, Zeilen mit derselben Methode auskommentieren oder auskommentieren, indem Sie einen Absatz durch Eingabe von yip oder zwei Zeilen durch Eingabe von dj löschen.

Mit diesem Ansatz können Sie Folgendes tun:

• ccj, um die nächsten zwei Zeilen zu kommentieren, und cuk, um sie zu kommentieren;

• cci{, um einen Block auskommentieren zu können, und cui{, um ihn zu kommentieren;

• ccip, um einen ganzen Absatz zu kommentieren, und cuip, um das Kommentarzeichen zu entfernen.

• ccG, um alles bis zur letzten Zeile auszukommentieren, und cugg, um alles bis zur ersten Zeile auszukommentieren.

Sie benötigen lediglich 2 Funktionen, die über Bewegungen arbeiten, und 2 Mappings für jede Funktion. Zuerst die Zuordnungen:

nnoremap <silent> cc  :set opfunc=CommentOut<cr>[email protected]
vnoremap <silent> cc  :<c-u>call  CommentOut(visualmode(), 1)<cr>
nnoremap <silent> cu  :set opfunc=Uncomment<cr>[email protected]
vnoremap <silent> cu  :<c-u>call  Uncomment(visualmode(), 1)<cr>

(Siehe Handbuch zum Operator [email protected] und zur Variablen operatorfunc.)

Und jetzt die Funktionen:

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

Ändern Sie die regulären Ausdrücke oben entsprechend Ihrem Geschmack und dem #:

Ich benutze EnhancedCommentify . Es kommentiert alles, was ich brauchte (Programmiersprachen, Skripte, Konfigurationsdateien). Ich verwende es mit Visual-Mode-Bindungen. Wählen Sie einfach den Text aus, den Sie kommentieren möchten, und drücken Sie co/cc/cd.

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

Ich markiere die erste und letzte Zeile (ma und mb) und mache dann 'a,' bs/^ # //

Wenn Sie die Zeilennummern bereits kennen, würde n,ms/# // funktionieren.

Ich benutze Tim Popes vim-comment plugin. 

Ich habe die Antwort von Phil und jqno kombiniert und Kommentare mit Leerzeichen aufgehoben:

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/\([^ ]\)/' . b:comment_leader . ' \1/'
    execute ':silent! s/^\( *\)' . b:comment_leader . ' \?' . b:comment_leader . ' \?/\1/'
endfunction
map <F7> :call CommentToggle()<CR>

Diese Antwort lautet wie folgt: 1) Zeigen Sie den richtigen Code zum Einfügen in einen .vimrc, Um vim 7.4+ Zum Kommentieren/Entkommentieren von Blöcken zu erhalten, während die Einrückungsstufe mit 1 Verknüpfung im visuellen Modus beibehalten wird, und 2) Erklären es.

Hier ist der Code:

let b:commentChar='//'
autocmd BufNewFile,BufReadPost *.[ch]    let b:commentChar='//'
autocmd BufNewFile,BufReadPost *.cpp    let b:commentChar='//'
autocmd BufNewFile,BufReadPost *.py    let b:commentChar='#'
autocmd BufNewFile,BufReadPost *.*sh    let b:commentChar='#'
function! Docomment ()
  "make comments on all the lines we've grabbed
  execute '''<,''>s/^\s*/&'.escape(b:commentChar, '\/').' /e'
endfunction
function! Uncomment ()
  "uncomment on all our lines
  execute '''<,''>s/\v(^\s*)'.escape(b:commentChar, '\/').'\v\s*/\1/e'
endfunction
function! Comment ()
  "does the first line begin with a comment?
  let l:line=getpos("'<")[1]
  "if there's a match
  if match(getline(l:line), '^\s*'.b:commentChar)>-1
    call Uncomment()
  else
    call Docomment()
  endif
endfunction
vnoremap <silent> <C-r> :<C-u>call Comment()<cr><cr>

Wie es funktioniert:

• let b:commentChar='//': Dies erzeugt eine Variable in vim. Das b bezieht sich hier auf den Gültigkeitsbereich, der in diesem Fall im Puffer enthalten ist, dh die aktuell geöffnete Datei. Ihre Kommentarzeichen sind Zeichenfolgen und müssen in Anführungszeichen gesetzt werden. Die Anführungszeichen sind nicht Teil dessen, was beim Umschalten von Kommentaren ersetzt wird.

• autocmd BufNewFile,BufReadPost *...: Autocommands werden auf verschiedene Arten ausgelöst. In diesem Fall werden diese ausgelöst, wenn eine neue Datei oder die gelesene Datei mit einer bestimmten Erweiterung endet. Nach dem Auslösen führen Sie den folgenden Befehl aus, mit dem Sie commentChar je nach Dateityp ändern können. Es gibt andere Möglichkeiten, dies zu tun, aber sie sind für Anfänger (wie mich) verwirrender.

• function! Docomment(): Funktionen werden deklariert, indem sie mit function beginnen und mit endfunction enden. Funktionen müssen mit einem Großbuchstaben beginnen. der ! stellt sicher, dass diese Funktion alle vorherigen Funktionen überschreibt, die als Docomment() mit dieser Version von Docomment() definiert wurden. Ohne ! Hatte ich Fehler, aber das könnte daran liegen, dass ich neue Funktionen über die vim-Befehlszeile definierte.

• execute '''<,''>s/^\s*/&'.escape(b:commentChar, '\/').' /e': Execute ruft einen Befehl auf. In diesem Fall führen wir substitute aus, das einen Bereich (standardmäßig ist dies die aktuelle Zeile) wie % Für den gesamten Puffer oder '<,'> Für den hervorgehobenen Wert annehmen kann Sektion. ^\s* Ist ein regulärer Ausdruck, der mit dem Beginn einer Zeile übereinstimmt, gefolgt von einem Leerzeichen, an das dann (aufgrund von &) Angefügt wird. Das . Hier wird für die Verkettung von Zeichenfolgen verwendet, da escape() nicht in Anführungszeichen eingeschlossen werden kann. Mit escape() können Sie Zeichen in commentChar, die mit den Argumenten übereinstimmen (in diesem Fall \ und /), durch Voranstellen eines \. Danach verketten wir erneut mit dem Ende unserer Zeichenfolge substitute, die das Flag e hat. Diese Flagge lässt uns im Stillen scheitern, was bedeutet, dass wir nicht darüber schreien, wenn wir in einer bestimmten Zeile keine Übereinstimmung finden. Insgesamt können Sie in dieser Zeile ein Kommentarzeichen gefolgt von einem Leerzeichen vor dem ersten Text einfügen, um die Einrückungsstufe beizubehalten.

• execute '''<,''>s/\v(^\s*)'.escape(b:commentChar, '\/').'\v\s*/\1/e': Dies ähnelt unserem letzten großen langen Befehl. Einzigartig in diesem Fall haben wir \v, Was sicherstellt, dass wir uns nicht unserem () Entziehen müssen, und 1, Das sich auf die Gruppe bezieht, die wir mit unserem erstellt haben (). Grundsätzlich stimmen wir mit einer Zeile überein, die mit einer beliebigen Anzahl von Leerzeichen beginnt, gefolgt von unserem Kommentarzeichen und einer beliebigen Anzahl von Leerzeichen. Wir behalten nur den ersten Satz von Leerzeichen bei. Wieder lässt uns e stillschweigend scheitern, wenn wir in dieser Zeile kein Kommentarzeichen haben.

• let l:line=getpos("'<")[1]: Hiermit wird eine Variable wie bei unserem Kommentarzeichen festgelegt, jedoch bezieht sich l auf den lokalen Bereich (lokal für diese Funktion). getpos() erhält in diesem Fall die Position des Beginns unserer Hervorhebung, und [1] bedeutet, dass wir uns nur um die Zeilennummer kümmern, nicht um andere Dinge wie die Spaltennummer.

• if match(getline(l:line), '^\s*'.b:commentChar)>-1: Sie wissen, wie if funktioniert. match() prüft, ob das erste Ding das zweite Ding enthält, also greifen wir zu der Zeile, in der wir unsere Hervorhebung begonnen haben, und prüfen, ob sie mit einem Leerzeichen beginnt, gefolgt von unserem Kommentarzeichen. match() gibt den Index zurück, in dem dies zutrifft, und -1, wenn keine Übereinstimmungen gefunden wurden. Da if alle Zahlen ungleich Null als wahr bewertet, müssen wir unsere Ausgabe vergleichen, um festzustellen, ob sie größer als -1 ist. Der Vergleich in vim gibt 0 zurück, wenn er falsch ist, und 1, wenn er wahr ist. Dies ist es, was if sehen möchte, um richtig zu bewerten.

• vnoremap <silent> <C-r> :<C-u>call Comment()<cr><cr>: vnoremap bedeutet, den folgenden Befehl im visuellen Modus abzubilden, aber nicht rekursiv abzubilden (dh keine anderen Befehle zu ändern, die auf andere Weise verwendet werden könnten). Wenn Sie ein Anfänger sind, sollten Sie grundsätzlich noremap verwenden, um sicherzustellen, dass Sie nichts kaputt machen. <silent> Bedeutet "Ich möchte nicht Ihre Worte, sondern nur Ihre Handlungen" und weist Sie an, nichts in die Befehlszeile zu drucken. <C-r> Ist das, was wir mappen, was in diesem Fall Strg + R ist (beachte, dass du C-R normalerweise für "Wiederholen" im normalen Modus mit diesem Mapping verwenden kannst). C-u Ist ein bisschen verwirrend, aber im Grunde stellt es sicher, dass Sie Ihre visuelle Hervorhebung nicht aus den Augen verlieren (gemäß diese Antwort es bringt Ihren Befehl dazu, mit '<,'> Zu beginnen, welches ist das, was wir wollen). call weist vim hier nur an, die von uns benannte Funktion auszuführen, und <cr> bezieht sich auf das Drücken der Schaltfläche enter. Wir müssen es einmal drücken, um die Funktion aufzurufen (andernfalls haben wir nur call function() in die Befehlszeile eingegeben, und wir müssen es erneut drücken, damit unsere Stellvertreter den gesamten Weg durchlaufen (nicht wirklich) sicher warum, aber was auch immer).

Wie auch immer, hoffentlich hilft das. Dies führt dazu, dass alle mit v, V oder C-v Markierten Zeilen gelöscht werden. Überprüfen Sie, ob die erste Zeile mit Kommentaren versehen ist. Wenn ja, kommentieren Sie alle markierten Zeilen aus. Fügen Sie jeder Zeile eine zusätzliche Ebene mit Kommentarzeichen hinzu. Das ist mein gewünschtes Verhalten; Ich wollte nicht nur, dass es umschaltet, ob jede Zeile im Block kommentiert wurde oder nicht, also funktioniert es perfekt für mich nach fragenmehrere Fragen zum Thema.

Es gibt dieses lebensverändernde Plugin von tpope mit dem Namen vim-commentary

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

Dieses Plugin bietet :

• Geistige Gesundheit
• Richtig eingerückte Kommentare
• Kommentiert keine leeren/unnötigen Zeilen aus

Verwendung :

• Installation über Vundle (oder Pathogen, denke ich).
• Markieren Sie Ihren Text und drücken Sie : welches als :<,'> angezeigt wird
• Geben Sie hier Commentary :<,'>Commentary ein und drücken Sie Enter.
• Boom. Deine erledigte Knospe.

Ich benutze comments.vim von Jasmeet Singh Anand (gefunden auf vim.org),

Es funktioniert mit C, C++, Java, PHP [2345], proz, CSS, HTML, HTML, XML, XHTML, vim, vimrc, SQL, sh, ksh, csh, perl, tex, fortran, ml, caml, ocaml, vhdl, haskel und normale dateien

Es kommentiert und entkommentiert Zeilen in verschiedenen Quelldateien sowohl im normalen als auch im visuellen Modus

Verwendungszweck:

• CtrlC um eine einzelne Zeile zu kommentieren
• CtrlX  Kommentar einer einzelnen Zeile entfernen
• ShiftV und wählen Sie dann mehrere Zeilen aus CtrlC um die ausgewählten Mehrfachzeilen zu kommentieren
• ShiftV und wählen Sie dann mehrere Zeilen aus CtrlX um die Auswahl mehrerer Zeilen aufzuheben

Die schnellste und intuitivste Methode von allen besteht darin, ) neu zuzuordnen, um Zeilen zu kommentieren, und dann (, um Kommentare zu entfernen. Probieren Sie es aus und Sie werden nicht zurückkehren.

In Ruby oder Bash mit zwei Leerzeichen:

map ) I# <Esc>j
map ( k^2x

In C/C++ oder PHP mit vier Leerzeichen:

map ) I//  <Esc>j
map ( k^4x

Die Nachteile sind, dass Sie für Satzbewegungen ( und ) verlieren (aber das kann dies ausfüllen) und gelegentlich auf select-and-replace oder zurückgreifen CtrlV für die Handhabung langer Abschnitte. Aber das ist ziemlich selten.

Und für C-Style eignen sich die langen Kommentare am besten für:

set cindent
set formatoptions=tcqr

... was sich gut mit V[move]gq kombinieren lässt, um den Zeilenumbruch zu wiederholen.

Hier ist ein grundlegender Einzeiler basierend auf der oben beschriebenen C-v gefolgt von I.

Dieser Befehl (:Comment) fügt eine ausgewählte Zeichenfolge an den Anfang einer ausgewählten Zeile ein.

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

Fügen Sie diese Zeile zu Ihrem .vimrc hinzu, um einen Befehl zu erstellen, der ein einzelnes Argument akzeptiert und das Argument an den Anfang jeder Zeile der aktuellen Auswahl platziert.

Z.B. wenn der folgende Text ausgewählt ist:

1
2

und Sie führen Folgendes aus: :Comment //, das Ergebnis lautet:

//1
//2

Angefangen mit den Ideen in den Antworten, habe ich meine eigene Kommentarfunktion gestartet, die Kommentare ein- und ausschaltet. Es kann Dinge wie //print('blue'); //this thing is blue behandeln und nur den ersten Kommentar ein- und ausschalten. Außerdem fügt es Kommentare und ein Leerzeichen hinzu, wo sich der erste Nicht-Whitespace befindet und nicht ganz am Anfang der Zeile. Außerdem kopiert er die Whitespaces nicht unnötig, sondern verwendet Zooms (: h\zs für Hilfe) Vermeiden Sie diese zusätzliche Arbeit, wenn Sie eine kommentierte und eingerückte Zeile einfügen. Hoffe, es hilft einigen Minimalisten da draußen. Vorschläge sind willkommen.

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

Dieser einfache Ausschnitt stammt von meinem .vimrc:

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

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

Es ist für // - Kommentare, aber Sie können es leicht für andere Charaktere anpassen. Sie können autocmd verwenden, um einen Anführer als von jqno vorgeschlagen festzulegen.

Dies ist eine sehr einfache und effiziente Art und Weise, auf natürliche Weise mit Bereichen und dem visuellen Modus zu arbeiten.

Sie können vim-commentary von tpope ( https://github.com/tpope/vim-commentary ) verwenden.

Rufen Sie den visuellen Modus auf, indem Sie drücken

'v'

Dann drücken 

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

Jetzt müssen Sie nur noch die Tasten eingeben:

'gc'

Dadurch wird die gesamte Auswahl auskommentiert, um die unkommentierten Wiederholungsschlüssel zu löschen:

'gc'

Ich benutze dafür vim-multiple-cursors .

1. Um die Region auszuwählen, gehen Sie zum ersten Zeichen der ersten oder letzten Zeile der Region, die auskommentiert werden soll, indem Sie drücken  (Es ist Null, nicht der Buchstabe "o"). Dann drücken V und wählen Sie die Region mit J, K oder auf und ab Pfeiltasten.
2. Setzen Sie dann einen virtuellen Cursor auf jede Zeile der Auswahl, indem Sie drücken CtrlN.
3. Dann drücken I um gleichzeitig jede Zeile der Auswahl zu bearbeiten.

Obwohl diese Frage bereits unzählige Antworten hat, dachte ich immer noch, ich würde ein kleines Plugin, das ich geschrieben habe, ansprechen: kommentieren .

Commentify verwendet die Einstellung commentstring, um zu entscheiden, wie ein Codeblock auskommentiert werden soll, damit Sie in Ihrer Konfiguration keine Zuordnung verschiedener Kommentartypen vornehmen müssen, und unterstützt sowohl zeilenbasierte Kommentare (z. B. //) als auch Blockkommentare (z. B. , /* */).

Dieselbe Verknüpfung wird auch zugeordnet (Standardeinstellung ist ctrl+c) zum Kommentieren und Kommentieren des Blocks, damit Sie sich nicht an zwei Zuordnungen oder einen komplexen Befehlssatz erinnern müssen.

Ich mag /* ... */ (C ansi Kommentare), hier ist es mein Trick für Sie. Sie können es natürlich für verschiedene Fälle anpassen.

Kommentar mit/* ... */ 

Wählen Sie den Text aus (zum Anfang gehen, Sichtblock starten, mit } springen):

<c-V>}

Geben Sie den Befehl ein, der in der Auswahl angewendet werden soll

:norm i/* <c-v><esc>$a */

Der Befehl sieht wie folgt aus: :'<,'>norm i /* ^[$a */

Siehe (i *) für Details.

Kommentiere die/* ... */ 

Wählen Sie den Text aus (wie zuvor oder auf andere Weise):

<c-V>}

Geben Sie den Befehl ein, der in der Auswahl angewendet werden soll

:norm :s-\s*/\*\s*-<c-v><enter>$bbld$

Der Befehl sieht wie folgt aus: :'<,'>norm :s-\s*/\*\s*-^M$bbld$

Für Details siehe (ii *).

Ergebnis  

Wirkung ist Kommentare Zeile für Zeile:

Comment block
Comment block
Comment block

Wird (und umgekehrt):

/* Comment block */
/* Comment block */
/* Comment block */

Es ist besser, es als map oder @reg in Ihrem .vimrc zu speichern, da es viel zu tippen ist. Wenn Sie dem gesamten Block einen einzelnen /* und */ vorziehen, verwenden Sie:

Kommentar mit einem einzigen/* */ganzen Block

Speichern Sie es in einem Register, indem Sie beispielsweise mit qc aufnehmen und dann am Anfang eines Absatzes einen Kommentar abgeben:

v}di/*  */<esc>hhhp

und vergessen Sie q nicht noch einmal, um die Aufzeichnung zu beenden.

Siehe (iii *) für Details.

Kommentiere einen einzelnen/* */aus einem Block

Speichern Sie es im Register, sagen Sie @u. Setzen Sie den Cursor an eine beliebige Stelle innerhalb des Blocks und:

?/\*<enter>xx/\*/<enter>xx

Speichern Sie das Register, indem Sie den Befehl q abschließen.

Siehe (iv *) für Details.

Ergebnis  

Effekt ist ein einzelner Kommentar für mehrere Zeilen:

Comment block
Comment block
Comment block

Wird (und umgekehrt):

/* Comment block
Comment block
Comment block */

Erklärungen

(i *) Funktioniert durch Verwendung von norm, die denselben Befehl wiederholt in jeder ausgewählten Zeile anwendet. Der Befehl fügt einfach einen /* ein, sucht das Ende dieser Zeile und wird durch Einfügen eines */ beendet.

:norm i/* <c-v><esc>$a */

(ii *) Es verwendet auch norm, um die Suche/Ersetzung in jeder Zeile zu wiederholen. Suchen Sie nach spaces /* spaces und ersetzen Sie ihn durch nichts. Danach findet das Ende der Zeile zurück, zwei Wörter zurück, rechts einen Buchstaben, bis zum Ende löschen.

:norm :s-\s*/\*\s*-<c-v><enter>$bbld$

(iii *) Wählt den Absatz mit v} aus, löscht ihn, fügt einen Kommentar ein, öffnet und schließt, bewegt sich in die Mitte und fügt den gelöschten Block ein.

v}di/*  */<esc>hhhp

(iv *) Irgendwo in der Mitte findet rückwärts ein /*, löscht ihn; findet einen */ vorwärts, löscht ihn.

?/\*<enter>xx/\*/<enter>xx

Sehr gute Frage, aber nicht so viele gute Antworten. Zunächst würde ich sagen, dass der Blockeinfügungsmodus keine einfache Lösung ist, einfach zu viele Tastatureingaben. Es muss also offensichtlich mit ausgewählten Zeilen gearbeitet werden, um die Leistung der Code-Bearbeitung zu verbessern. Ein weiterer Punkt, den niemand erwähnt: Wo soll das Kommentarzeichen stehen - ganz am Anfang der Zeile oder vor dem eigentlichen Text? Wahrscheinlich ist es eine Frage des Geschmacks, aber meiner Meinung nach sollte es vor dem Text stehen, damit der Code lesbar bleibt: Wenn das Kommentarzeichen in die Zeile eingefügt wird, unterbricht es die visuelle Konsistenz des eingerückten Codes, sodass es wie ein Liste mit Aufzählungszeichen. Aus diesem Grund habe ich folgende Lösung gefunden (ich mache ein Beispiel für # Kommentar). In meiner vimrc:

vnoremap 1 :s:^\(\s*\)\([^#\t ]\):\1#\2:e<CR>
vnoremap 2 :s:^\(\s*\)#\(\s*\):\1\2:e<CR>

Der Schlüssel 1 fügt # vor dem Text (nach dem Leerzeichen) in jede ausgewählte Zeile ein. Es prüft, ob bereits # vorhanden ist, und # nicht zweimal eingefügt wird. Und ignoriert auch leere Zeilen.
Schlüssel 2 löscht einen #. Außerdem werden die Kommentare auf der rechten Seite der Zeile geschützt.

Update: Hier ist ein Beispiel, wie man den Befehl zum Umschalten von Kommentaren zum Dateityp macht. Um mehr über diese Dinge zu erfahren, lesen Sie: http://learnvimscriptthehardway.stevelosh.com/chapters/14.html

Damit es funktioniert, fügen Sie die folgenden Zeilen in Ihre .vimrc-Datei ein. 

" build the whole regex search/replace command
function! Build()
    let b:Comment_ON='''<,''>s:^\(\s*\)\([^\t ]\):\1' . b:cs . '\2:e'
    let b:Comment_OFF='''<,''>s:^\(\s*\)' . b:cs . '\(\s*\):\1\2:e'
endfunction

" run this group on Filetype event
augroup SetCS
    autocmd!
    "default comment sign
    autocmd FileType * let b:cs='--'
    "detect file type and assign comment sign
    autocmd FileType python,Ruby let b:cs='#'
    autocmd FileType c,cpp,Java,javascript,php let b:cs = '\/\/'
    autocmd FileType vim let b:cs='"'
    autocmd FileType * call Build()
augroup END

vnoremap 1 :<C-u>execute b:Comment_ON<CR>
vnoremap 2 :<C-u>execute b:Comment_OFF<CR>

Ich persönlich mag keine "toggle" -Funktion von Kommentaren, da dadurch Kommentare zerstört werden, die bereits im Code enthalten sind. Außerdem möchte ich, dass das Kommentarzeichen immer ganz links angezeigt wird, sodass ich leicht Kommentarblöcke sehen kann. Außerdem möchte ich, dass dies verschachtelt funktioniert (wenn ich zuerst einen Block und später einen umschließenden Block auskommentiere) . Deshalb habe ich eine der Lösungen etwas geändert. Ich benutze F5 zum Kommentieren und Shift - F5 zum unkommentieren. Ich habe auch a/g am Ende des Befehls s/hinzugefügt:

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 = '"'
autocmd FileType nasm             let b:comment_leader = ';'

function! CommentLine()
    execute ':silent! s/^\(.*\)/' . b:comment_leader . ' \1/g'
endfunction

function! UncommentLine()
    execute ':silent! s/^' . b:comment_leader . ' //g'
endfunction

map <F5> :call CommentLine()<CR>
map <S-F5> :call UncommentLine()<CR>

So kommentieren Sie eine Zeile (für alle Sprachen):

• noremap <silent> ,// :call CommentLine() <CR>

Wir können es mit Zeilenzahl und in visueller Modus funktioniert auch. Like: Um vier Zeilen zu kommentieren, benutze 4, // und um das Kommentar zu entfernen, benutze 4, /.

So kommentieren Sie eine Zeile aus (für alle Sprachen):

• noremap <silent> ,/ :call UnCommentLine() <CR>

Wenn Sie neues Symbol hinzufügen möchten [Kommentar] dann eine Liste hinzufügen und einige Zeilen hinzufügen in Funktion. Wenn Sie eine Sprache hinzufügen möchten, die das Kommentarsymbol enthält, das bereits in einer der Listen definiert ist, fügen Sie einfach Ihre Sprache hinzu Name der Sprache in der entsprechenden Liste (Um den richtigen Namen zu erhalten: Öffnen Sie Ihre Datei in vim und verwenden Sie : Setzen Sie ft , um den richtigen Namen für zu erhalten deine Sprache).

Definition von CommentLine ()

function! CommentLine() let slash_ft_list = ['c' , 'cpp', 'Java', 'scala' , 'systemverilog' , 'verilog' , 'verilog_systemverilog'] let hash_ft_list = ['sh' , 'Ruby' , 'python' , 'csh' , 'conf' , 'fstab' , 'Perl'] let perct_ft_list = ['tex'] let mail_ft_list = ['mail'] let quote_ft_list = ['vim'] if (index(slash_ft_list, &ft) != -1) :norm I// elseif (index(hash_ft_list, &ft) != -1) :norm I# elseif (index(perct_ft_list, &ft) != -1) :norm I% elseif (index(mail_ft_list, &ft) != -1) :norm I> elseif (index(quote_ft_list, &ft) != -1) :norm I" endif endfunction

Definition von UnCommentLine ()

function! UnCommentLine() let slash_ft_list = ['c' , 'cpp', 'Java', 'scala' , 'systemverilog' , 'verilog' , 'verilog_systemverilog'] let hash_ft_list = ['sh' , 'Ruby' , 'python' , 'csh' , 'conf' , 'fstab' , 'Perl'] let perct_ft_list = ['tex'] let mail_ft_list = ['mail'] let quote_ft_list = ['vim'] if (index(slash_ft_list, &ft) != -1) :norm ^2x elseif (index(hash_ft_list, &ft) != -1) :norm ^x elseif (index(perct_ft_list, &ft) != -1) :norm ^x elseif (index(mail_ft_list, &ft) != -1) :norm ^x elseif (index(quote_ft_list, &ft) != -1) :norm ^x endif endfunction

:% s/^/\/\// g

entfernen Sie die Leerzeichen zwischen den Zeichen und .__ Verwenden Sie diesen Befehl, um C- oder CPP-Dateien zu kommentieren

Die @ CMS-Lösung ist die "vim native" Methode, um In-/Out-Zeilen zu kommentieren. Im zweiten Schritt von @ CMS nach CtrlVSie könnten auch verwenden r# Kommentare hinzufügen oder x um sie zu löschen. Drew Neils Practical Vim , Seite 46, erklärt diese Technik gut.

Eine weitere gute Option ist die Verwendung eines Ex-Modus-Befehls. :[Angebot]normali##⌴. Um Tastenanschläge zu speichern, müssen Sie über 15 Zeilen auskommentieren.

"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

Sie können einzelne oder mehrere Zeilen mit # kommentieren/unkommentieren. Um mehrere Zeilen zu erstellen, wählen Sie die Zeilen aus, geben Sie dann cc/cu ein, oder geben Sie eine Nummer ein, dann cc/cu, z. 7cc kommentiert 7 Zeilen vom Cursor. 

Ich habe den Originalcode von der Person erhalten. Was ist die eleganteste Art, Blöcke von Ruby-Code in Vim zu kommentieren/zu kommentieren? und nahm einige kleine Änderungen vor (veränderte Tastenkombinationen und fügte nach dem # ein Leerzeichen ein).

Ich persönlich wollte a la Visual Studio kommentieren. Ich habe mich bei der Arbeit so daran gewöhnt, dass es mein Muskelgedächtnis übernommen hat (mit vsvim). Benutzen shift+v Wählen Sie die gewünschten Zeilen aus und drücken Sie ctrl+k, ctrl+c zu kommentieren oder Ctrl+k, Ctrl+u zu kommentieren.

:vnoremap <C-k><C-c> :norm i//<Cr>
:vnoremap <C-k><C-u> :s/\/\///g<Cr>:noh<Cr>

So kommentieren Sie die gesamte Datei aus:

1. Esc beendet den Einfügemodus
2. gg geht zum ersten Zeichen in der ersten Zeile
3. ctrl+V oder ctrl+shift+v wählt das aktuelle Zeichen aus
4. G oder shift+g geht zur letzten Zeile
5. x löscht die Auswahl

:g/.spare[1-9].*/,+2s/^/\/\//

Der obige Code wird alle Zeilen auskommentieren, die "spare" und eine Zahl danach enthalten, plus zwei Zeilen mehr aus der Zeile, in der das gefunden wurde. Weitere Informationen zu solchen Verwendungszwecken finden Sie unter: http://vim.wikia.com/wiki/Search_and_replace#Details

Es gibt verschiedene vim-Plugins wie Tcomment und Nerdcommenter. 

Ich benutze tcomment zum Kommentieren.

gcc: Hiermit wird der Kommentar für die aktuelle Zeile umgeschaltet 

Beispiel: v3jgc schaltet den Bereich von 3 Zeilen um.

Diese Befehle können für die Arbeit mit Kommentaren in jeder Sprache verwendet werden.

Diese Lösung bildet/zu kommentieren und? zu unkommentieren (Kommentar-Umschalten mithilfe des einzelnen Mappings ist zu komplex, um ordnungsgemäß implementiert zu werden). Es verwendet Kommentarzeichenfolgen aus der integrierten commentstring-Option von VIM, die aus Dateien wie /usr/share/vim/vim*/ftplugin/*.vim gefüllt wird, wenn filetype plugin on deklariert ist.

filetype plugin on
autocmd FileType * let b:comment = split(&commentstring, '%s', 1)
autocmd FileType * execute "map <silent> <Leader>/ :normal 0i" . b:comment[0] . "<C-O>$" . b:comment[1] . "<C-O>0<CR>"
autocmd FileType * execute "map <silent> <Leader>? :normal $" . repeat('x', strlen(b:comment[1])) . "0" . strlen(b:comment[0]) . "x<CR>"