¿Qué es una forma rápida de comentar/descomponer líneas en Vim?

comments

Question

Tengo un archivo de código Ruby abierto en vi, hay líneas comentadas con # :

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

Digamos que quiero descomentar todas las líneas en la primera def ... end sección def ... end . ¿Qué es una forma eficiente de hacer eso en Vim?

En general, estoy buscando una manera fácil y fluida de comentar y descomponer líneas. Aquí estoy tratando con el código Ruby, pero podría ser JavaScript ( // ) o Haml ( -# ).

Answer 1

Alternar comentarios

Si todo lo que necesita es alternar comentarios , prefiero ir con commentary.vim by tpope .

Instalación

Patógeno:

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

vim-plug:

Plug ''tpope/vim-commentary''

Vundle:

Plugin ''tpope/vim-commentary''

Personalización adicional

Agregue esto a su archivo .vimrc: noremap <leader>/ :Commentary<cr>

Ahora puede alternar comentarios presionando Leader + / , al igual que Sublime y Atom.

Answer 2

Para comentar los bloques en vim:

• presiona Esc (para salir de edición u otro modo)
• pulsa ctrl + v (modo de bloque visual)
• use las teclas de flecha arriba / abajo para seleccionar las líneas que desea (no resaltará todo, ¡está bien!)
• Mayús + i (mayúscula I)
• inserta el texto que quieras, es decir %
• presiona Esc Esc

Para descomentar bloques en vim:

• presiona Esc (para salir de edición u otro modo)
• pulsa ctrl + v (modo de bloque visual)
• use las teclas de flecha ↑ / ↓ para seleccionar las líneas que desea eliminar.

  Si desea seleccionar varios caracteres, use uno o combine estos métodos:

  • use las teclas de flecha izquierda / derecha para seleccionar más texto
  • para seleccionar trozos de texto use la tecla de flecha Mayús + ← / →
  • puede presionar repetidamente las teclas de eliminar a continuación, como un botón de eliminación normal
• presiona do x para borrar caracteres, repetidamente si es necesario

Answer 3

A veces me conecto a una caja remota donde mis complementos y .vimrc no pueden ayudarme, o a veces NerdCommenter se equivoca (por ejemplo, JavaScript incrustado en HTML).

En estos casos, una alternativa de baja tecnología es el comando norm incorporado, que simplemente ejecuta cualquier comando vim arbitrario en cada línea en su rango especificado. Por ejemplo:

Comentando con # :

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

Esto inserta "#" al comienzo de cada línea. Tenga en cuenta que cuando escribe: el rango se completará, por lo que realmente se verá como :''<,''>norm i#

Sin comentarios # :

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

Esto borra el primer carácter de cada línea. Si hubiera usado un comentario de 2 caracteres como // entonces simplemente haría :norm xx para eliminar ambos caracteres.

Si los comentarios están sangrados como en la pregunta del OP, entonces puede anclar su eliminación de la siguiente manera:

:norm ^x

lo que significa "ir al primer carácter sin espacio, luego eliminar un carácter". Tenga en cuenta que, a diferencia de la selección de bloques, esta técnica funciona incluso si los comentarios tienen sangría irregular.

Nota : dado que la norm es literalmente ejecutar comandos vim regulares, no está limitado solo a los comentarios, podría hacer una edición compleja en cada línea. Si necesita el carácter de escape como parte de la secuencia de comandos, escriba ctrl-v y luego presione la tecla de escape.

Nota 2 : Por supuesto, también podría agregar un mapeo si se encuentra usando mucho la norm . Por ejemplo, poner la siguiente línea en ~ / .vimrc le permite escribir ctrl-n lugar de :norm después de realizar su selección visual

vnoremap <C-n> :norm

Nota 3 : vim de Bare-bones a veces no tiene el comando norm compilado, así que asegúrese de usar la versión reforzada, es decir, típicamente / usr / bin / vim, no / bin / vi

(Gracias a @Manbroski y @rakslice por las mejoras incorporadas en esta respuesta)

Answer 4

Aquí hay un resumen básico basado en el Cv seguido del método I descrito anteriormente.

Este comando ( :Comment ) agrega una cadena elegida al principio de cualquier línea seleccionada.

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

Agregue esta línea a su .vimrc para crear un comando que acepte un solo argumento y coloque el argumento al comienzo de cada línea en la selección actual.

Por ejemplo, si se selecciona el siguiente texto:

1
2

y ejecuta esto:: :Comment // , el resultado será:

//1
//2

Answer 5

Aquí hay una sección de mi .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 modo normal y en modo visual, esto me permite presionar , ic para insertar comentarios y , rc para eliminar comentarios.

Answer 6

Así es como lo hago:

1. Ir al primer carácter en la primera línea que desea comentar.

2. Presione Ctrl + q en GVIM o Ctrl + v en VIM, luego baje para seleccionar el primer carácter en las líneas para comentar.

3. Luego presiona c , y agrega el caracter de comentario.

La desactivación funciona de la misma manera, solo escriba un espacio en lugar del carácter de comentario.

Answer 7

Combiné la respuesta de Phil y jqno e hice comentarios con espacios:

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>

Answer 8

Comenzando con las ideas de las respuestas aquí, comencé mi propia función de comentarios. Activa y desactiva los comentarios. Puede manejar cosas como //print(''blue''); //this thing is blue //print(''blue''); //this thing is blue y solo alterna el primer comentario. Además, agrega comentarios y un solo espacio justo donde se encuentra el primer espacio no en blanco y no al comienzo de la línea. Además, no copia innecesariamente los espacios en blanco, pero utiliza zoom (: h / zs para obtener ayuda) para evitar este trabajo adicional, al comentar y la línea con sangría. Espero que ayude a algunos minimalistas por ahí. Las sugerencias son bienvenidas.

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

Answer 9

Con 30 respuestas por delante, intentaré dar una solución aún más fácil: inserte un # al principio de la línea. Luego baja una línea y presiona punto ( . ). Para repetir, haz j , j , etc ... Para descomentar, elimine un # (puede presionar x sobre el # ), y haga lo contrario usando k , etc ...

Answer 10

El método más rápido y el más intuitivo de todos ellos es volver a correlacionar para comentar las líneas y comentarlas, y luego ( para no comentar las cosas. Inténtelo y no volverá).

En Ruby o Bash , con sangrías de 2 espacios:

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

En C / C ++ o PHP , con sangrías de 4 espacios:

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

Las desventajas son que usted pierde ( y ) movimiento de la oración (pero das puede rellenar allí), y ocasionalmente puede retroceder en seleccionar y reemplazar o Ctrl V para manejar secciones largas. Pero eso es bastante raro.

Y para el estilo C, los comentarios largos se manejan mejor con:

set cindent
set formatoptions=tcqr

... Lo que combina bien con el uso de V[move]gq para rehacer el V[move]gq de palabras.

Answer 11

Este fragmento simple es de mi .vimrc:

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

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

Es para // - Comentarios, pero puedes adaptarlo fácilmente para otros personajes. Podría usar autocmd para establecer un líder como jqno sugirió.

Esta es una forma muy simple y eficiente de trabajar con rangos y modo visual de forma natural.

Answer 12

Hay un plugin que cambia la vida de tpope llamado vim-commentary

commentary.vim

Este plugin proporciona :

• Cordura
• Comentarios debidamente sangrados
• No comenta líneas vacías / innecesarias

Uso :

• Instalar a través de Vundle (o Pathogen supongo).
• Resalte su texto y presione : que se mostrará como :<,''>
• Escriba Comentario aquí :<,''>Commentary y presione Entrar .
• Auge. Tu brote hecho

Answer 13

Marque la primera y la última línea (ma y mb), y luego hago: ''a,'' bs / ^ # //

Answer 14

Me gusta usar el complemento tcomment: http://www.vim.org/scripts/script.php?script_id=1173

He asignado gc y gcc para comentar una línea o un bloque de código resaltado. Detecta el tipo de archivo y funciona muy bien.

Answer 15

Para esas tareas utilizo la mayor parte de la selección de bloque de tiempo.

Coloque el cursor en el primer carácter # , presione Ctrl V (o Ctrl Q para gVim), baje hasta la última línea comentada y presione x , que eliminará todos los # caracteres verticalmente.

Para comentar un bloque de texto es casi lo mismo:

1. Primero, vaya a la primera línea que desea comentar, presione Ctrl V. Esto pondrá al editor en el modo VISUAL BLOCK .
2. Luego usa la tecla de flecha y selecciona hasta la última línea
3. Ahora presione Mayús I , lo que pondrá al editor en modo INSERT y luego presione # . Esto agregará un hash a la primera línea.
4. Luego presiona Esc (dale un segundo), e insertará un carácter # en todas las demás líneas seleccionadas.

Para la versión reducida de vim incluida con debian / ubuntu por defecto, escriba : s/^/# en el tercer paso.

Aquí hay dos grabaciones de pantalla pequeña para referencia visual.

Comentario:

Descomentar

Answer 16

Puede usar vim-commentary por tpope ( commentary.vim ) puede usarlo de la siguiente manera:

Ingrese al modo visual presionando

''v''

Entonces presione

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

Ahora todo lo que tienes que hacer con la selección es ingresar las teclas:

''gc''

Esto comentará toda la selección, para descomprimir las claves de repetición:

''gc''

Answer 17

Sí, hay 33 respuestas (en su mayoría repetitivas) a esta pregunta.

Aquí hay otro enfoque de cómo comentar líneas en Vim: movimientos . La idea básica es comentar o eliminar comentarios de las líneas utilizando el mismo método que para eliminar un párrafo escribiendo yip o eliminando 2 líneas escribiendo dj .

Este enfoque le permitirá hacer cosas como:

• ccj para comentar las siguientes 2 líneas y cuk para descomentarlas;

• cci{ para comentar un bloqueo, y cui{ para descomentarlo;

• ccip en ccip para comentar todo un párrafo y cuip .

• ccG para comentar todo hasta la última línea, y cugg para descomentar todo hasta la primera línea.

Todo lo que necesita son 2 funciones que operan sobre movimientos y 2 asignaciones para cada función. Primero, los mapeos:

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>

(Consulte el manual sobre el operador g@ y la variable operatorfunc ).

Y ahora las funciones:

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

Modifique las expresiones regulares de arriba para que se ajusten a su gusto en cuanto a dónde debe estar el # :

Answer 18

Se me ha ocurrido una adición simple a mi archivo .vimrc que funciona bastante bien y se puede extender fácilmente. Simplemente agregue un nuevo tipo de archivo a comment_map y su líder de comentarios.

Agregué un mapeo a los modos normal y visual, pero puedes volver a mapear lo que quieras. Prefiero solo tener una función de estilo ''alternar''. Uno lleva tener múltiples asignaciones, 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>

Nota:

No uso devoluciones de llamada ni enlaces en los tipos de archivo / carga, porque encuentro que retrasan más el inicio de Vim que la función / mapa estática .vimrc , pero eso es solo mi preferencia. También he tratado de mantenerlo simple y performante. Si utiliza autocomandos, debe asegurarse de colocarlos en un grupo de autocomandos o, de lo contrario, las devoluciones de llamada se agregarán al tipo de archivo varias veces por archivo cargado y causarán una gran degradación del rendimiento.

Answer 19

Si ya conoce los números de línea, entonces n,ms/# // funcionaría.

Answer 20

Tengo lo siguiente en mi .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>

Ahora puede escribir ,cc para comentar una línea y ,cu para descomentar una línea (funciona tanto en modo normal como visual).

(Lo robé de un sitio web hace muchos años, así que ya no puedo explicar cómo funciona :). Hay un comment donde se explica.)

Answer 21

Use Control-V para seleccionar rectángulos de texto: vaya al primer carácter # , escriba Ctrl + V , muévase a la derecha y luego hacia abajo, hasta el final de los comentarios. Ahora escribe x : estás eliminando todos los # caracteres seguidos de un espacio.

Answer 22

Uso comments.vim de Jasmeet Singh Anand (que se encuentra en vim.org),

Funciona con 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, y archivos normales

Comenta y elimina líneas de comentarios en diferentes archivos de origen en modo normal y visual

Uso:

• Ctrl C para comentar una sola línea
• Ctrl X para des-comentar una sola línea
• Shift V y seleccione varias líneas, luego Ctrl C para comentar las múltiples líneas seleccionadas
• Shift V y seleccione varias líneas, luego Ctrl X para anular el comentario de las múltiples líneas seleccionadas

Answer 23

Yo uso EnhancedCommentify . Comenta todo lo que necesitaba (lenguajes de programación, scripts, archivos de configuración). Lo uso con los enlaces de modo visual. Simplemente seleccione el texto que desea comentar y presione co / cc / cd.

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

Answer 24

Yo uso vim-multiple-cursors para esto.

1. Para seleccionar la región, vaya al primer carácter de la primera o última línea de la región que desea comentar presionando 0 (es cero, no la letra "o"). Luego presione V y seleccione la región usando J , K o las teclas de flecha arriba y abajo.
2. Luego, coloque un cursor virtual en cada línea de la selección presionando Ctrl N.
3. Luego presione I para editar simultáneamente cada línea de la selección.

Answer 25

Yo uso el script NERD Commenter . Le permite comentar, quitar comentarios o alternar fácilmente comentarios en su código.

Como se menciona en los comments :

para cualquiera que esté confundido por el uso, el líder predeterminado es "/", por lo que 10 / cc comentará diez líneas y 10 / cu descomentará esas diez líneas

Answer 26

Yo uso el plugin commentary.vim Tim Pope.

Answer 27

Yo uso vim 7.4 y esto funciona para mí.
Suponiendo que estamos comentando / sin comentar 3 líneas.

Comentar:

Si la línea no tiene tabulador / espacio al principio:
ctrl + V luego jjj luego shift + I (cappital i) luego // luego esc esc
Si la línea tiene una pestaña / espacio al principio, aún puede hacer lo anterior o cambiar por c :
ctrl + V luego jjj luego c luego // luego esc esc

Descomentar:

Si las líneas no tienen tabulador / espacio al principio:
ctrl + V luego jjj luego ll (lower cap L) luego c

Si las líneas tienen una pestaña / espacio al principio, entonces espacia una sobre y esc
ctrl + V luego jjj luego ll (lower cap L) luego c luego space luego esc

Answer 28

Cómo descomentar las siguientes tres líneas en vi:

#code code
#code
#code code code

Coloque el cursor sobre el símbolo # esquina superior izquierda y presione Ctrl V. Esto te pone en modo de bloqueo visual. Presione la flecha hacia abajo o J tres veces para seleccionar las tres líneas. Luego presiona D. Todos los comentarios desaparecen. Para deshacer, pulsa U.

Cómo comentar las siguientes tres líneas en vi:

code code
code
code code code

Coloque el cursor sobre el carácter superior izquierdo, presione Ctrl V. Esto te pone en modo de bloqueo visual. Presione ↓ o J tres veces para seleccionar las tres líneas. Entonces presione:

I / / Esc

Esa es una capital I, //, y Escape.

Cuando presione ESC , todas las líneas seleccionadas obtendrán el símbolo de comentario que especificó.

Answer 29

Especifique qué líneas comentar en vim:

Revelar los números de línea:

:set number

entonces

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

o esto:

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

Answer 30

Esta respuesta está aquí a 1) muestra el código correcto para pegar en una .vimrcde conseguir vim 7.4+hacer el bloque de comentar / descomentar manteniendo nivel de sangría con 1 acceso directo en el modo visual y 2) para explicarlo.

Aquí está el código:

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>

Cómo funciona:

• let b:commentChar=''//'': Esto crea una variable en vim. la bque aquí se refiere al ámbito de aplicación, que en este caso está contenida en la memoria intermedia, es decir, el archivo abierto actualmente. Los caracteres de sus comentarios son cadenas y deben estar entre comillas, las citas no forman parte de lo que se sustituirá cuando se alternen los comentarios.

• autocmd BufNewFile,BufReadPost *...: Los autocomandos se activan en diferentes cosas, en este caso, estos se activan cuando un nuevo archivo o el archivo de lectura finaliza con una cierta extensión. Una vez activado, ejecuta el siguiente comando, que nos permite cambiar el tipo commentCharde archivo dependiendo del tipo de archivo. Hay otras formas de hacer esto, pero son más confusas para los novatos (como yo).

• function! Docomment(): Las funciones se declaran comenzando con functiony terminando con endfunction. Las funciones deben comenzar con un capital. el !asegura que esta función sobrescribe cualquier función previa definida como Docomment()con esta versión de Docomment(). Sin el !, tuve errores, pero eso podría deberse a que estaba definiendo nuevas funciones a través de la línea de comandos vim.

• execute ''''''<,''''>s/^/s*/&''.escape(b:commentChar, ''//'').'' /e'': Ejecutar llama a un comando. En este caso, estamos ejecutando substitute, lo que puede tomar un rango (por defecto, esta es la línea actual), como %para todo el búfer o ''<,''>para la sección resaltada. ^/s*es regex para coincidir con el inicio de una línea seguida por cualquier cantidad de espacios en blanco, que luego se anexa a (debido a &). El .Aquí se utiliza para la concatenación de cadenas, ya escape()que no se puede ajustar entre comillas. escape()le permite escapar del carácter commentCharque coincida con los argumentos (en este caso, /y /) al anteponerlos con a /. Después de esto, concatenamos de nuevo con el final de nuestra substitutecadena, que tiene la ebandera. Esta bandera nos permite fallar en silencio, lo que significa que si no encontramos una coincidencia en una línea determinada, no lo gritaremos. En general, esta línea nos permite poner un carácter de comentario seguido de un espacio justo antes del primer texto, lo que significa que mantenemos nuestro nivel de sangría.

• execute ''''''<,''''>s//v(^/s*)''.escape(b:commentChar, ''//'').''/v/s*//1/e'': Esto es similar a nuestro último gran comando largo. Único a este, tenemos /v, lo que garantiza que no tenemos que escapar de nuestro ()y 1, que se refiere al grupo que formamos con nuestro (). Básicamente, estamos combinando una línea que comienza con cualquier cantidad de espacios en blanco y luego nuestro carácter de comentario seguido por cualquier cantidad de espacios en blanco, y solo mantenemos el primer conjunto de espacios en blanco. Nuevamente, enos deja fallar en silencio si no tenemos un carácter de comentario en esa línea.

• let l:line=getpos("''<")[1]: esto establece una variable como lo hicimos con nuestro carácter de comentario, pero se lrefiere al ámbito local (local a esta función). getpos()obtiene la posición de, en este caso, el inicio de nuestro resaltado, y los [1]medios que solo nos preocupan por el número de línea, no otras cosas como el número de columna.

• if match(getline(l:line), ''^/s*''.b:commentChar)>-1: ya sabes como iffunciona match()comprueba si lo primero contiene lo segundo, así que tomamos la línea en la que comenzamos a resaltar y comprobamos si comienza con espacios en blanco seguidos de nuestro carácter de comentario. match()devuelve el índice donde esto es cierto, y -1si no se encontraron coincidencias. Dado que se ifevalúa que todos los números distintos de cero sean verdaderos, tenemos que comparar nuestra salida para ver si es mayor que -1. La comparación en vimdevuelve 0 si es falso y 1 si es verdadero, que es lo que ifquiere ver para evaluar correctamente.

• vnoremap <silent> <Cr> :<Cu>call Comment()<cr><cr>: vnoremapsignifica asignar el siguiente comando en modo visual, pero no asignarlo de forma recursiva (es decir, no cambiar ningún otro comando que pueda usarse de otra manera). Básicamente, si eres un principiante de vim, usa siempre noremappara asegurarte de no romper las cosas. <silent>significa "No quiero sus palabras, solo sus acciones" y le dice que no imprima nada en la línea de comandos. <Cr>es lo que estamos mapeando, que es ctrl + r en este caso (tenga en cuenta que todavía puede usar Cr normalmente para "rehacer" en modo normal con este mapeo). Cues un poco confuso, pero básicamente se asegura de que no pierdas de vista tu resaltado visual (de acuerdo con esta respuesta hace que tu comando comience con ''<,''>lo que queremos).callaquí solo le dice a vim que ejecute la función que nombramos, y se <cr>refiere a enterpresionar el botón. Tenemos que pulsarlo una vez para llamar a la función (de lo contrario, simplemente hemos tecleado call function()en la línea de comandos, y tenemos que pulsarlo nuevamente para que nuestros sustitutos lleguen hasta el final (no estamos seguros de por qué, pero sí)

De todos modos, espero que esto ayude. Esto tomará cualquier cosa resaltada con v, Vo Cv, compruebe si la primera línea está comentada, si es así, intente descomentar todas las líneas resaltadas, y si no, agregue una capa adicional de caracteres de comentario a cada línea. Este es mi comportamiento deseado; No solo quería que se alternara entre comentar o no cada línea del bloque, así que me funciona perfectamente después de asking multiple preguntas sobre el tema.