Quel est un moyen rapide pour commenter/décommenter les lignes dans Vim?

- Je utiliser le NERD Intervenant script. Il vous permet de commentaire, décommentez ou passer des commentaires dans votre code.

Comme mentionné dans le commentaires:

pour n'importe qui qui est confondu par l'utilisation, par défaut, est le leader de "\" 10\cc commentaire d'une dizaine de lignes et 10\cu décommenter ces dix lignes

Pour commenter les blocs dans vim:

• appuyez sur Esc (pour laisser de l'édition ou de l'autre mode)
• appuyez sur ctrl+v (visual mode bloc)
• utilisez les touches fléchées haut/bas pour sélectionner les lignes que vous voulez (il ne mettent pas en évidence tout - c'est OK!)
• Maj+i (I majuscule)
• insérez le texte que vous voulez, c'est à dire %
• appuyez sur EscEsc

---

De décommenter les blocs dans vim:

• appuyez sur Esc (pour laisser de l'édition ou de l'autre mode)
• appuyez sur ctrl+v (visual mode bloc)
• utiliser le ↑/↓ les touches fléchées pour sélectionner les lignes de décommenter.

  Si vous voulez sélectionner plusieurs caractères, l'utilisation d'un ou de combiner ces méthodes:

  • utilisez les touches fléchées gauche/droite pour sélectionner plus de texte
  • pour sélectionner des morceaux de texte maj + ←/→ flèche
  • vous pouvez appuyez à plusieurs reprises sur les touches de suppression ci-dessous, comme un bouton supprimer

• appuyez sur d ou x pour supprimer des caractères, à plusieurs reprises si nécessaire

J'ai la suite dans ma .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>

Maintenant, vous pouvez taper ,cc pour commenter une ligne et ,cu décommenter une ligne (fonctionne à la fois en mode normal et en mode visuel).

(Je l'ai volé de certains site web il y a plusieurs années donc je ne peux pas expliquer totalement la façon dont il fonctionne plus :). Il y a un commentaire où c'est expliqué.)

Voici comment je le fais:

1. Aller au premier caractère de la première ligne que vous souhaitez commenter.

2. Appuyez sur Ctrl+q dans GVIM ou Ctrl+v dans VIM, puis allez vers le bas pour sélectionner le premier caractère sur les lignes de commentaire.

3. Puis appuyez sur c, et ajouter le caractère de commentaire.

Décommentant fonctionne de la même manière, il suffit de taper un espace au lieu de le caractère de commentaire.

Bascule commentaires

Si vous avez besoin d' bascule commentaires je préfère aller avec commentaire.vim par tpope.

Installation

Agent pathogène:

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

vim-plug:

Plug 'tpope/vim-commentary'

Vundle:

Plugin 'tpope/vim-commentary'

De personnalisation

Ajouter à votre .fichiers vimrc: noremap <leader>/:Commentary<cr>

Vous pouvez maintenant basculer commentaires en appuyant sur Leader+/, tout comme Sublime et de l'Atome.

Voici une partie de mon .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>

En mode normal et en mode visuel, cela me permet d'appuyer sur ,ic pour insérer des commentaires et,rc pour supprimer des commentaires.

J'aime utiliser les tcomment plugin:
http://www.vim.org/scripts/script.php?script_id=1173

J'ai mappé gc et gcc pour commenter une ligne ou un bloc de code. Il détecte le type de fichier et fonctionne vraiment bien.

Comment décommentez les trois lignes suivantes dans vi:

#code code
#code
#code code code

Placez le curseur sur le coin supérieur gauche # symbole et appuyez sur CtrlV. Cela vous met dans visual en mode bloc. Appuyez sur la flèche vers le bas ou J trois fois pour sélectionner toutes les trois lignes. Appuyez ensuite sur D. Tous les commentaires disparaissent. Pour annuler, appuyez sur U.

Comment commenter les trois lignes suivantes dans vi:

code code
code
code code code

Placez le curseur sur le coin supérieur gauche de caractère, appuyez sur la touche CtrlV. Cela vous met dans visual en mode bloc. Appuyez sur la touche ↓ ou J trois fois pour sélectionner toutes les trois lignes. Ensuite, appuyez sur:

I//Esc

C'est un I majuscule, //, et d'Évasion.

Lorsque vous appuyez sur la touche ESC, toutes les lignes seront le symbole de commentaire que vous avez spécifié.

- Je utiliser EnhancedCommentify. Il commente tout ce dont j'avais besoin (langages de programmation, scripts, les fichiers de configuration). - Je l'utiliser avec visual-mode liaisons. Il suffit de sélectionner le texte que vous souhaitez faire des commentaires et de la presse co/cc/cd.

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

Si vous connaissez déjà le numéro de ligne, puis n,ms/# // serait de travailler.

J'ai combiné Phil et jqno réponse et fait untoggle commentaires avec des espaces:

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

Cette réponse est ici de 1) montrent le bon code et le coller dans un .vimrc pour obtenir vim 7.4+ à faire bloc commenter/décommenter tout en gardant le niveau d'indentation avec 1 raccourci en mode visuel et 2) pour l'expliquer.

Voici le 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*//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>

Comment cela fonctionne:

• let b:commentChar='//' : Cela crée une variable dans vim. le b se réfère ici à la portée, qui dans ce cas est contenue dans la mémoire tampon, sens le fichier actuellement ouvert. Votre commentaire personnages sont des chaînes de caractères et doivent être enveloppés dans des guillemets, les guillemets ne font pas partie de ce qui va être remplacées lorsque le basculement des commentaires.

• autocmd BufNewFile,BufReadPost *... : Autocommands déclencher sur des choses différentes, dans ce cas, ce sont de déclenchement lorsqu'un nouveau fichier ou de la lecture du fichier se termine par une certaine extension. Une fois déclenchée, l'exécution de la commande suivante, qui nous permet de changer le commentChar selon le type de fichier. Il y a d'autres façons de le faire, mais ils sont plus déroutant pour les novices (comme moi).

• function! Docomment() : Les fonctions sont déclarées en commençant par function et se terminant avec endfunction. Les fonctions doivent commencer avec un capital. le ! assure que cette fonction remplace toutes les précédentes fonctions définies comme Docomment() avec cette version de Docomment(). Sans le !, j'ai eu des erreurs, mais ce pourrait être parce que j'ai été de définir de nouvelles fonctions par le biais de la ligne de commandes de vim.

• execute '''<,''>s/^\s*/&'.escape(b:commentChar, '\/').' /e' : Exécuter appelle une commande. Dans ce cas, nous sommes d'exécution substitute, ce qui peut prendre un intervalle (par défaut, c'est la ligne actuelle) comme % pour l'ensemble de la mémoire tampon ou '<,'> pour la section en surbrillance. ^\s* est regex pour correspondre au début d'une ligne suivie d'un nombre quelconque d'espaces, qui est ensuite ajouté à la fin (en raison de &). Le . ici est utilisé pour la concaténation de chaîne, depuis escape() ne peut pas être enveloppé dans les citations. escape() vous permet d'échapper à caractère commentChar qui correspond à la arguments (dans ce cas, \ et /) en ajoutant avec un \. Après cela, nous les avons réunis de nouveau à la fin de notre substitute chaîne, qui a la e drapeau. Cet indicateur nous permet d'échouer en silence, ce qui signifie que si nous ne trouvons pas un match sur une ligne donnée, nous ne criez pas à ce sujet. Dans l'ensemble, cette ligne permet de nous mettre un caractère de commentaire suivi d'un espace juste avant le premier texte, ce qui nous permet de maintenir notre niveau d'indentation.

• execute '''<,''>s/\v(^\s*)'.escape(b:commentChar, '\/').'\v\s*/\1/e' : Ceci est similaire à notre dernier énorme long de commande. Unique à cette question, nous avons \v, qui fait en sorte que nous n'avons pas d'échapper à nos (), et 1, qui se rapporte au groupe que nous avons fait avec notre (). Fondamentalement, nous sommes correspondant à une ligne qui commence avec un nombre quelconque d'espaces et notre commentaire de caractères suivie d'un nombre quelconque d'espaces, et nous ne gardant que la première série d'espaces. Encore une fois, e nous permet silencieuse même si nous n'avons pas un caractère de commentaire sur cette ligne.

• let l:line=getpos("'<")[1] : il définit une variable comme nous l'avons fait avec notre caractère de commentaire, mais l se réfère à l'étendue locale (locale à cette fonction). getpos() obtient la position de l', dans ce cas, le début de notre mise en évidence, et la [1] signifie que nous ne se soucient que le numéro de la ligne, pas d'autres choses comme le numéro de la colonne.

• if match(getline(l:line), '^\s*'.b:commentChar)>-1 : vous savez comment if œuvres. match() vérifie si la première chose que contient la deuxième chose, si nous prenons la ligne que nous avons commencé notre sélection à la, et de vérifier si elle commence avec un espace suivi par notre caractère de commentaire. match() renvoie l'index où cela est vrai, et -1 si aucune correspondance n'a été trouvé. Depuis if évalue différente de zéro tous les numéros pour être vrai, il nous faut comparer notre sortie pour voir si il est supérieur à -1. La comparaison dans vim retourne 0 si la valeur est false et 1 pour true, ce qui est le if veut voir à évaluer correctement.

• vnoremap <silent> <C-r> :<C-u>call Comment()<cr><cr> : vnoremap signifie la carte de la commande suivante en mode visuel, mais ne correspondent pas récursivement (sens de ne pas changer toutes les autres commandes qui peuvent utiliser d'autres méthodes). En gros, si vous êtes un vim novice, utilisez toujours noremap pour vous assurer de ne pas casser des choses. <silent> signifie "je ne veux pas de vos mots, de vos actions" et permet de ne pas imprimer quoi que ce soit à la ligne de commande. <C-r> est la chose que nous sommes de cartographie, qui est ctrl+r dans ce cas (notez que vous pouvez toujours utiliser le C-r normalement, pour "refaire" en mode normal avec cette cartographie). C-u est un peu confus, mais, fondamentalement, il fait en sorte de ne pas perdre la trace de votre visuel mettant en évidence (selon cette réponse il rend votre commande démarrer avec '<,'> qui est ce que nous voulons). call ici juste indique à vim pour exécuter la fonction que nous avons nommé, et <cr> se réfère à frapper le enter bouton. Nous avons pour frapper une fois de réellement appeler la fonction (sinon, nous avons tapé juste call function() sur la ligne de commande, et nous avons à le frapper de nouveau pour obtenir nos substituts d'aller à travers tout le chemin (pas vraiment pourquoi, mais peu importe).

De toute façon, nous espérons que cette aide. Cela va prendre quoi que ce soit mis en évidence avec v, V, ou C-v, vérifiez si la première ligne est commentée, si oui, essayez de commenter toutes les lignes en surbrillance, et si non, ajouter une couche supplémentaire de caractères de commentaire à chaque ligne. C'est mon comportement souhaité; je n'ai pas juste envie de basculer si chaque ligne dans le bloc a été commenté ou non, de sorte qu'il fonctionne parfaitement pour moi, après demander plusieurs questions sur le sujet.

En commençant par les idées de réponses ici, j'ai commencé ma propre fonction de commentaire.
Il permet de basculer commentaires sur et en dehors. Il peut gérer des choses comme //print('blue'); //this thing is blue et enclenche le premier commentaire. En outre, il ajoute des commentaires et un espace unique où le premier non espace est et non pas au début de la ligne.
Aditionally il n'est pas inutilement copier l'url, mais utilise les zooms (:h \zs de l'aide) pour éviter ce travail supplémentaire, lorsque, commentant et en retrait de la ligne.
Espérons que cela aide certains partisans de là-bas. Les Suggestions sont les bienvenues.

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

La plus rapide et la plus intuitive de la méthode de tous est de reconfigurer ) pour pied-vers le bas-commentant les lignes, puis ( pour walk-up-décommentant. Essayez-le et vous ne serez pas revenir en arrière.

Dans Ruby ou Bash, avec 2 tirets:

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

Dans C/C++ ou PHP, avec le 4-espace tiret:

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

Inconvénients sont que vous perdez ( et ) pour phrase-mouvement (mais das pouvez le remplir en y), et vous aurez parfois se rabattre sur sélectionnez-et-remplacer ou CtrlV pour le traitement des longues sections. Mais c'est assez rare.

Et pour le style C, les longs commentaires sont manipulées avec:

set cindent
set formatoptions=tcqr

... Qui se combine bien avec l'aide de V[move]gq pour rétablir le mot de l'habillage.

Vous pouvez utiliser vim-commentaire par tpope (https://github.com/tpope/vim-commentary) vous pouvez l'utiliser comme suit:

Entrer dans le mode visuel en appuyant sur

'v'

Puis appuyez sur

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

Maintenant tout ce que vous avez à faire avec la sélection, c'est d'entrer clés:

'gc'

Cela permettra de commenter tous les sélection, décommenter repead clés:

'gc'

J'aime /* ... */ (C ansi commentaires), donc ici c'est mon truc pour vous. Vous pouvez l'adapter à une utilisation dans différents cas, bien sûr.

---

Commentaire avec /* ... */

Sélectionnez le texte (aller à le commencer, démarrez visual bloc, sautez avec }):

<c-V>}

Tapez la commande à appliquer à la sélection

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

Commande ressemblera à: :'<,'>norm i /* ^[$a */

Voir (i*) pour plus de détails.

---

Décommentez la /* ... */

Sélectionnez le texte (comme avant, ou de l'autre façon que vous aimez):

<c-V>}

Tapez la commande à appliquer à la sélection

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

Commande ressemblera à: :'<,'>norm :s-\s*/\*\s*-^M$bbld$

Voir (ii*) pour plus de détails.

---

Résultat

Effet est des commentaires, ligne par ligne:

Comment block
Comment block
Comment block

Devient (et vice-versa):

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

---

De son mieux pour le sauver, comme certains map ou @reg dans votre .vimrc, parce que c'est beaucoup de type de. Si vous préférez une seule /* et */ à l'ensemble du bloc, utilisez:

Commentaire avec un seul /* */l'ensemble du bloc

L'enregistrer dans un registre d'enregistrement avec, disons, qc, puis, au début d'un paragraphe de commentaire:

v}di/*  */<esc>hhhp

et n'oubliez pas q encore une fois, pour terminer l'enregistrement.

Voir (iii*) pour plus de détails.

---

Décommenter un seul /* */à partir d'un bloc

L'enregistrer dans le registre, disons, @u. Placez votre curseur n'importe où à l'intérieur du bloc, et:

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

Enregistrer le registre par la finition de q commande.

Voir (iv*) pour plus de détails.

---

Résultat

Effet est un commentaire sur plusieurs lignes:

Comment block
Comment block
Comment block

Devient (et vice-versa):

/* Comment block
Comment block
Comment block */

---

Explications

(i*) Il fonctionne en utilisant norm qui s'applique de la même commande plusieurs fois dans chaque ligne sélectionnée. La commande il suffit d'insérer un /*, trouve la fin de la ligne, et finit par l'insertion d'une */

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

(ii*) Il utilise également norm pour répéter la recherche/remplacer sur chaque ligne. Recherche pour spaces /* spaces et de les remplacer par rien. Après cela, trouve la fin de la ligne, en deux mots, juste une lettre, effacer jusqu'à la fin.

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

(iii*) Sélectionne le paragraphe par v}, supprimer, insérer un commentaire d'ouvrir et de fermer, déplacer vers son milieu et collez le supprimé bloc.

v}di/*  */<esc>hhhp

(iv*) n'importe où dans le milieu, trouve en arrière /*, le supprime; trouve l'avant un */, le supprime.

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

Même si cette question a déjà une tonne de réponses j'ai toujours pensé que je donnerais un shoutout à un petit plugin que j'ai écrit: commentify.

Commentify utilise le commentstring réglage de décider comment commenter un bloc de code, de sorte que vous n'avez pas à garder une cartographie des différents types de commentaires dans votre configuration, et prend en charge à la fois la ligne de base des commentaires (par exemple, //) et de bloquer les commentaires (par exemple, /* */).

Il a également des cartes de la même raccourci (par défaut, ctrl+c) pour les commentant et en décommentant le bloc, de sorte que vous n'avez pas à vous souvenir de deux mappings ou d'un ensemble complexe de commandes.

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

Vous pouvez commenter/décommenter une ou plusieurs lignes avec #. Faire plusieurs lignes, sélectionnez les lignes de type cc/cu raccourci, ou saisissez un numéro, puis cc/cu, par exemple, 7cc commentaires 7 lignes à partir du curseur.

J'ai eu l'orignal code de la personne sur Quelle est la façon la plus élégante de commenter /décommenter les blocs de code ruby dans Vim? et apporté quelques petites modifications (changement de touches de raccourci, et ajouter un espace après le #).

@CMS solution est la plus "vim natif" de façon à faire dans/hors lignes. Dans @CMS deuxième étape, après CtrlV, vous pouvez également utiliser r# pour ajouter des commentaires ou x pour les supprimer. Drew Neil Pratique Vim, page 46, explique bien cette technique.

Une autre bonne option est d'utiliser un ex mode de commande. :[plage]normali##⌴. Évidemment, pour enregistrer les frappes de touches avec celui-ci, vous aurez besoin de commentaire+ de 15 lignes.

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

supprimer la sapces entre les personnages et
Utilisez cette commande pour commentaire .C ou CPP fichiers

Pour Commenter Une Ligne (Pour Toutes Les Langues):

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

Nous pouvons l'appeler avec nombre de lignes et dans mode visuel trop, il fonctionne. Comme : commentaire de quatre lignes 4,// et décommenter utilisation 4,/.

Décommenter Une Ligne (Pour Toutes Les Langues):

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

Si Vous voulez ajouter un nouveau symbole[commentaire] puis ajouter une liste et d'y ajouter quelques lignes en fonction. Si vous souhaitez ajouter une langue qui a le symbole de commentaire qui sont déjà définies dans l'une des listes suffit d'ajouter votre nom de la langue dans la liste correspondante (Pour Obtenir de bons nom: Ouvrez votre fichier dans vim et l'utilisation :jeu de pieds pour obtenir le nom de votre langue).

Définition de 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

Définition de 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

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

Le code ci-dessus commentez toutes les lignes qui contiennent "de rechange" et un certain nombre, après que plus il va commentaire de deux lignes de plus à partir de la ligne dans laquelle a été trouvé.
Pour d'autres utilisations visiter : http://vim.wikia.com/wiki/Search_and_replace#Details

Appuyez sur ctrl+v ensuite, utilisez ↑ ou ↓ pour sélectionner le nombre de lignes de commentaire. Appuyez ensuite sur maj+I, appuyez sur #, puis ESC. Ce sera en commentaire le nombre de lignes que vous avez sélectionné.

L'inverse pour décommenter les lignes.