pour ces tâches j'utilise la plupart du temps sélection de blocs .

mettez votre curseur sur le premier caractère # , appuyez sur Ctrl V (ou Ctrl" 1519120920 Q pour gVim), et descendez jusqu'à la dernière ligne commentée et appuyez sur x , qui supprimera tous les caractères # verticalement.

pour commentant un bloc de texte est presque le même:

1. tout d'abord, allez à la première ligne que vous voulez commenter, appuyez sur Ctrl V . Cela mettra l'éditeur en mode VISUAL BLOCK .
2. ensuite, en utilisant la touche Flèche et sélectionnez jusqu'à la dernière ligne
3. Maintenant, appuyez sur Shift je , qui va mettre de l'éditeur dans INSERT mode et appuyez ensuite sur # . Cela ajoutera un hachage à la première ligne.
4. puis appuyez sur Esc (donnez-lui une seconde), et il insérera un caractère # sur toutes les autres lignes sélectionnées.

pour la version dépouillée de vim livrée avec debian/ubuntu par défaut, tapez : s/^/# dans la troisième étape à la place.

pour commenter les blocs dans vim:

• press Esc (pour quitter le mode édition ou autre)
• hit ctrl + v (mode bloc visuel)
• utilisez les flèches haut/bas pour sélectionner les lignes que vous voulez (cela ne mettra pas tout en évidence - C'est OK!)
• Shift + je (le capital, I)
• insérer le texte que vous voulez, i.e. %
• appuyez sur Esc Esc

décommenter les blocs dans vim:

• press Esc (pour quitter le mode édition ou autre)
• hit ctrl + v (mode bloc visuel)
• utilisez la ↑ / ↓ touches fléchées pour sélectionner les lignes à décommenter.

  si vous souhaitez sélectionner plusieurs caractères, Utilisez une ou combinez ces méthodes:

  • utilisez les flèches gauche/droite pour sélectionner plus de texte
  • pour sélectionner des morceaux de texte, utilisez shift + ← / → Flèche
  • vous pouvez appuyer plusieurs fois sur les touches supprimer ci-dessous, comme un bouton Supprimer régulier

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

Parfois je suis shelled dans une boîte à distance où mes plugins et .vimrc ne peut pas m'aider, ou parfois NerdCommenter se trompe (par exemple JavaScript intégré dans HTML).

dans ces cas, une alternative de basse technologie est la commande intégrée norm , qui n'exécute que des commandes vim arbitraires à chaque ligne de votre plage spécifiée. Par exemple:

commentant avec # :

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

ceci insère " # " au début de chaque ligne. Notez que lorsque vous tapez : la gamme sera remplie, donc elle ressemblera vraiment à :'<,'>norm i#

Décommenter # :

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

Cela supprime le premier caractère de chaque ligne. Si j'avais utilisé un commentaire à deux caractères tel que//, j'aurais simplement fait :norm xx pour supprimer les deux caractères.

Si les commentaires sont en retrait dans la question de L'OP, alors vous pouvez ancrer votre Suppression comme ceci:

:norm ^x

qui signifie "aller au premier caractère non espace, puis supprimer un caractère". Notez que contrairement à la sélection par blocs, cette technique fonctionne même si les commentaires ont une indentation inégale!

Note : puisque norm est littéralement juste l'exécution des commandes vim régulières, vous n'êtes pas limité seulement aux commentaires, vous pouvez faire quelques modifications complexes à chaque ligne. Si vous avez besoin du caractère escape dans votre séquence de commande, tapez ctrl-v puis appuyez sur la touche escape.

Note 2 : vous pouvez bien sûr aussi ajouter un mapping si vous utilisez norm beaucoup. Par exemple mettre la ligne suivante dans ~/.vimrc vous permet de taper ctrl-n au lieu de :norm après avoir fait votre sélection visuelle

vnoremap <C-n> :norm

Note 3 : bare-bones vim parfois, la commande norm n'y est pas compilée, alors assurez-vous d'utiliser la version améliorée, c'est-à-dire typiquement /usr / bin/ vim, pas/bin / vi

(merci à @Manbroski et @rakslice pour les améliorations incorporées dans cette réponse)

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 pour découpler une ligne (fonctionne à la fois en mode normal et visuel).

(Je l'ai volé sur un site web il y a de nombreuses années donc je ne peux pas expliquer complètement comment cela fonctionne plus :). Il y a un commentaire où il est expliqué.)

spécifier les lignes à commenter dans vim:

indique les numéros de ligne:

:set number

puis

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

ou ceci:

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

Voici comment je fais:

1. allez au premier caractère sur la première ligne que vous voulez commenter.

2. Hit 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écommenter fonctionne de la même manière, il suffit de taper un espace au lieu du caractère de commentaire.

j'ai trouvé un simple ajout à mon .fichiers vimrc qui fonctionne plutôt bien et peut être étendu facilement. Il vous suffit d'ajouter un nouveau type de fichier à comment_map et à son leader de commentaires.

j'ai ajouté un mapping aux modes Normal et visuel, mais vous pouvez faire un remap à tout ce que vous voulez. Je préfère seulement avoir une fonction de style "bascule". Un ours ayant plusieurs correspondances, etc.

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>

Note:

je n'utilise pas de rappels ou hooks dans les types de fichiers/loading, parce que je trouve qu'ils ralentissent le démarrage de Vim plus que la fonction statique/map de .vimrc mais c'est juste ma préférence. J'ai aussi essayé de rester simple et performant. Si vous utilisez des autocommands, vous devez être sûr de les mettre dans un groupe autocommand ou bien les callbacks sont ajoutés au filetype plusieurs fois par fichier chargé et causent beaucoup de dégradation des performances.

utilisez contrôle-V pour sélectionner les rectangles de texte: allez au premier caractère # , tapez Ctrl + V , déplacez-vous à droite une fois, puis vers le bas, jusqu'à la fin des commentaires. Tapez maintenant x : vous supprimez tous les caractères # suivis d'un espace.

commentaires à bascule

si tout ce que vous avez besoin est commentaires à bascule je préfère aller avec commentaire.vim par tpope .

Installation

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'

nouvelle personnalisation

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

vous pouvez maintenant basculer des commentaires en appuyant sur Leader + / , tout comme Sublime et atome.

Voici une section 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 les commentaires et , rc pour supprimer les commentaires.

j'aime utiliser le plugin tcomment: 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.

avec 30 réponses devant moi, je vais essayer de donner une solution encore plus facile: insérez un # au début de la ligne. Ensuite, descendez une ligne et appuyez sur dot ( . ). Répéter, faire j , . , j , . , etc...Pour décommenter, supprimer un # (vous pouvez frapper x sur la # ), et de faire l'inverse à l'aide de k , . ,etc...

comment découpler les trois lignes suivantes dans vi:

#code code
#code
#code code code

placez le curseur sur le coin supérieur gauche # le symbole et appuyez sur Ctrl" 151990920 V . Cela vous met en mode bloc visuel. Appuyez sur la flèche vers le bas ou J trois fois pour sélectionner les trois lignes. Puis appuyez 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 caractère supérieur gauche, appuyez sur Ctrl" 151990920 V . Cela vous met en mode bloc visuel. Appuyez sur ↓ ou J trois fois pour sélectionner les trois lignes. Puis appuyez sur:

je / / ces

c'est un I majuscule, //, et Escape.

lorsque vous appuyez sur ESC , toutes les lignes sélectionnées recevront le symbole de commentaire que vous avez spécifié.

j'utilise vim 7.4 et cela fonctionne pour moi.

Supposons que nous commencions / décommentons 3 lignes.

pour commenter:

si la ligne n'a pas d'onglet/espace au début:

ctrl + V puis jjj puis shift + I (cappital i) puis // puis esc esc

si la ligne a onglet/espace de au début, vous peut encore faire ce qui précède ou échanger pour c :

ctrl + V puis jjj puis c puis // esc esc



Pour décommenter:

si les lignes n'ont pas d'onglet/espace au début:

ctrl + V puis jjj puis ll (lower cap L) c

si les lignes ont tab/espace au début, puis un espace au-dessus et esc

ctrl + V puis jjj puis ll (lower cap L) puis c puis space esc

j'utilise EnhancedCommentify . Il commente tout ce dont j'avais besoin (langages de programmation, scripts, fichiers de configuration). Je l'utilise avec des fixations en mode visuel. Sélectionnez simplement le texte que vous souhaitez commenter et appuyez sur co/cc/cd.

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

Oui, il y a 33 (surtout répétitives) répond déjà à cette question.

Voici une autre approche pour comment Commenter les lignes dans Vim: motions . L'idée de base est de commenter ou de découpler les lignes en utilisant la même méthode que de tirer un paragraphe en tapant yip ou en supprimant 2 lignes en tapant dj .

Cette approche vous permettra de faire des choses comme:

• ccj pour commenter les 2 lignes, et cuk décommenter;

• cci{ pour commenter un blocage, et cui{ pour le découpler;

• ccip commenter un paragraphe entier, et cuip décommenter.

• ccG pour tout commenter jusqu'à la dernière ligne, et cugg décommenter tout jusqu'à la première ligne.

Tout ce dont vous avez besoin sont 2 fonctions que opérer sur les mouvements , et 2 correspondances pour chaque fonction. D'abord, les mappings:

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>

(voir le manuel concernant l'opérateur g@ et la variable operatorfunc ).)

et maintenant les fonctions:

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

modifier la version expressions ci-dessus pour convenir à votre goût quant à l'endroit où le # devrait être:

si vous connaissez déjà les numéros de ligne, alors n,ms/# // fonctionnerait.

je marque la première et la dernière lignes (ma et mb), et puis :'a,'bs/^# //

j'utilise Tim du Pape vim-commentaire plugin.

j'ai combiné la réponse de Phil et jqno et fait des commentaires untoggle 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>

il y a ce plugin qui change la vie par tpope appelé vim-commentary

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

ce plugin fournit :

• santé mentale
• Correctement en retrait des commentaires
• ne commente pas les lignes vides/inutiles

Utilisation :

• installation via Vundle (ou pathogène je suppose).
• surlignez votre texte et appuyez sur : qui apparaîtra comme :<,'>
• Type commentaire ici :<,'>Commentary et appuyez sur Enter .
• Boom. Votre fait bourgeon.

Voici une doublure de base basée sur la méthode C-v suivie de la méthode I décrite ci-dessus.

cette commande ( :Comment ) ajoute une chaîne choisie au début de chaque ligne sélectionnée.

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

Ajoutez cette ligne à votre .vimrc pour créer une commande qui accepte un seul argument et place l'argument au début de chaque ligne de la sélection courante.

E. g. si le texte suivant est sélectionné:

1
2

et vous lancez ceci: :Comment // , le résultat sera:

//1
//2

en commençant par les idées dans les réponses ici, j'ai commencé ma propre fonction de commentaire. Il bascule les commentaires sur et Hors. Il peut gérer des choses comme //print('blue'); //this thing is blue et juste basculer 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. Aditionnellement, il ne copie pas inutilement les espaces blancs, mais utilise des zooms (:h \zs pour l'aide) pour éviter ce travail supplémentaire, lors des commentaires et de la ligne en retrait. Espérons que cela aide certains les minimalistes. 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>

j'utilise des commentaires.vim de Jasmeet Anand Singh (qui se trouve sur vim.org),

il fonctionne avec 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, et les fichiers normaux""

des observations et de l'onu-lignes de commentaires dans différents fichiers source en mode normal et le mode visuel

Utilisation:

• Ctrl C à commentaire une seule ligne
• Ctrl X à des nations unies-commentaire une seule ligne
• Shift V et sélectionner plusieurs lignes, puis Ctrl C pour commenter les lignes multiples sélectionnées
• Shift V et sélectionner plusieurs lignes, puis Ctrl X pour désactiver les lignes multiples sélectionnées

la méthode la plus rapide et la plus intuitive d'entre eux tous est de remap ) pour walk-down-commentaire de lignes, puis ( pour walk-up-uncommenting. 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

les inconvénients sont que vous perdez ( et ) pour le mouvement de phrase (mais das peut remplir là), et vous tomberez de temps en temps sur Sélectionner-et-remplacer ou Ctrl V pour la manipulation de longues sections. Mais c'est assez rare.

et pour C-style, les longs commentaires sont mieux traités avec:

set cindent
set formatoptions=tcqr

... Qui se combine bien avec l'utilisation de V[move]gq pour refaire la le mot de l'habillage.

ce simple extrait est de mon .vimrc:

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

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

c'est pour //-Commentaires, mais vous pouvez l'adapter facilement pour d'autres caractères. Vous pouvez utiliser autocmd pour définir un leader comme jqno suggéré.

c'est une façon très simple et efficace de travailler avec les gammes et le mode visuel naturellement.

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

entrer en 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 est d'entrer les clés:

'gc'

cela va commenter toute la sélection, pour décommenter les clés de répétition:

'gc'

j'utilise vim-plusieurs curseurs pour cela.

1. pour sélectionner la région, allez au premier caractère de la première ou dernière ligne de la région à commenter en appuyant sur 0 (c'est zéro, pas la lettre "o"). Appuyez ensuite sur V et sélectionnez la région en utilisant J , K ou les flèches haut et bas.
2. alors mettez un curseur virtuel sur chaque ligne de la sélection en appuyant sur Ctrl "151970920 N .
3. puis appuyez sur I pour éditer simultanément chaque ligne de la sélection.

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 en ce cas est contenu dans le tampon, ce qui signifie le fichier actuellement ouvert. Vos caractères de commentaire sont des chaînes de caractères et doivent être enveloppés dans des guillemets, les guillemets ne font pas partie de ce qui sera substitué dans les commentaires de basculement.

• autocmd BufNewFile,BufReadPost *... : les Autocommands déclenchent différentes choses, dans ce cas, elles se déclenchent quand un nouveau fichier ou le fichier Lu se termine par une certaine extension. Une fois déclenché, l'exécuter la commande suivante, qui permet nous pour changer le commentChar en fonction du type de fichier. Il y a d'autres façons de le faire, mais elles sont plus déroutantes pour les novices (comme moi).

• function! Docomment() : les fonctions sont déclarées en commençant par function et se terminant par endfunction . Les fonctions doivent commencer par un capital. le ! garantit que cette fonction remplace toutes les fonctions antérieures définies comme Docomment() avec cette version de Docomment() . Sans l' ! , j'ai eu des erreurs, mais cela pourrait être parce que je définissais de nouvelles fonctions à travers la ligne de commande vim.

• execute '''<,''>s/^\s*/&'.escape(b:commentChar, '\/').' /e' : exécutez les appels une commande. Dans ce cas , nous exécutons substitute , qui peut prendre un intervalle (par défaut c'est la ligne courante) tel que % pour l'ensemble du tampon ou '<,'> pour la section Mise en évidence. ^\s* est regex pour correspondre au début de la ligne suivie par la quantité de whitespace, qui est ensuite ajouté à (due à & ). Le . ici est utilisé pour la concaténation de chaîne, puisque escape() ne peut pas être enveloppé dans des guillemets. escape() vous permet d'échapper au caractère commentChar qui correspond aux arguments (dans ce cas, \ et / ) en les préparant avec un \ . Après cela, nous nous concaténons à nouveau avec la fin de notre chaîne substitute , qui a le drapeau e . Ce drapeau nous laisse échouer silencieusement, ce qui signifie que si nous ne trouvons pas de correspondance sur une ligne donnée, nous ne hurlerons pas à ce sujet. Dans l'ensemble, cette ligne nous permet de mettre un caractère de commentaire suivi d'un espace juste avant le premier texte, ce qui signifie que nous gardons notre niveau d'indentation.

• execute '''<,''>s/\v(^\s*)'.escape(b:commentChar, '\/').'\v\s*//e' : c'est similaire à notre dernière longue commande énorme. Unique à celui - ci , nous avons \v , qui fait en sorte que nous n'avons pas à échapper à notre () , et 1 , qui se réfère au groupe 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 laisse échouer silencieusement si nous n'avons pas un caractère de commentaire sur cette ligne.

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

• if match(getline(l:line), '^\s*'.b:commentChar)>-1 : vous savez comment fonctionne if . match() vérifie si la première chose contient la seconde chose, donc nous prenons la ligne sur laquelle nous avons commencé notre mise en évidence, et vérifions si elle commence avec des espaces suivi de notre personnage de commentaire. match() renvoie l'index où cela est vrai, et -1 si aucune correspondance n'a été trouvé. Puisque if évalue tous les nombres non nuls pour être vrai, nous devons comparer notre production pour voir si elle est supérieure à -1. La comparaison dans vim renvoie 0 si faux et 1 si vrai, ce qui est ce que if veut voir pour évaluer correctement.

• vnoremap <silent> <C-r> :<C-u>call Comment()<cr><cr> : vnoremap carte des moyens la carte suivante commande en mode visuel, mais ne la mappez pas de façon récursive (c'est-à-dire Ne modifiez aucune autre commande qui pourrait être utilisée d'une autre manière). Fondamentalement, si vous êtes un novice vim, toujours utiliser noremap pour s'assurer que vous ne cassez pas les choses. <silent> signifie "Je ne veux pas vos mots, juste vos actions" et lui dit de ne rien imprimer sur la ligne de commande. <C-r> est la chose que nous cartographions, qui est ctrl+r dans ce cas (notez que vous pouvez toujours utiliser C-r Normalement pour "redo" en mode normal avec ce cartographie.) C-u est un peu déroutant, mais fondamentalement, il s'assure que vous ne perdez pas la trace de votre mise en évidence visuelle (selon cette réponse il fait votre commande commencer par '<,'> qui est ce que nous voulons). call dit juste à vim d'exécuter la fonction que nous avons nommée, et <cr> fait référence au fait d'appuyer sur le bouton enter . Nous devons appuyer une fois pour appeler la fonction (sinon nous avons tapé call function() sur la ligne de commande, et nous devons frapper à nouveau pour obtenir nos substituts de passer par tout le chemin (pas vraiment sûr pourquoi, mais peu importe).

de toute façon, j'espère que ça aidera. Cela prendra tout ce qui est surligné avec v , V , ou C-v , vérifiez si la première ligne est commentée, si oui, essayez de décommenter toutes les lignes surlignées, et si non, ajouter une couche supplémentaire de caractères de commentaire à chaque ligne. C'est mon comportement désiré; Je ne le voulais pas seulement pour changer si chaque ligne dans le bloc a été commentée ou non, il fonctionne donc parfaitement pour moi après poser multiple questions sur le sujet.