Busindre

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== Configuración mínima y teclas importantes del editor Vim =====

**Tips / Trucos de Vim**: [[http://vim.wikia.com/wiki/Vim_Tips_Wiki]]\\
**Buen manual de VIm en español**: [[https://victorhck.gitbook.io/aprende-vim/]]

**Editar comando con vim antes de ejecutarlo**: Pulsar "Ctrl+x e" cuando queramos continuar escribiendo el comando desde vim. Cuando salgamos del editor (no es necesario guardar) el comando se ejecutará.

**Recomendación**: Vim suele venir en muchas distribuciones en su versión mínima, es recomendable instalar gim-gtk / gvim para tener la versión completa la cual suele venir compilada con más opciones. Un ejemplo sería la opción de compilación "+clipboard", la cual permite copiar al portapapeles del sistema desde una terminal con Vim.

**Configuración mínima para Vim**: Se usará el configuración predeterminada de Vim que se encuentra en /usr/share/vim/vim80/defaults.vim y se le agregarán algunas nuevas opciones al final del archivo de uso genérico que pueden resultar interesantes.  

<code bash>cat /usr/share/vim/vim80/defaults.vim > $HOME/.vimrc</code>

Ahora si se desean se pueden agregar las siguientes opciones al fichero .vimrc (La comilla se utiliza para comentar en .vimrc).
<code>
let g:netrw_liststyle=3     " Al 'editar' directorios muestra un menú más atractivo que el predeterminado.
set ic                      " Búsquedas no sensibles a mayúsculas.
set nu                      " Indica el número de linea a la izquierda.
set hlsearch                " Resalta las letras al hacer búsquedas incrementales.
set ignorecase              " Ignora mayúsculas / minúsculas.
set smartcase               " Si la búsqueda usa alguna mayúscula será case sensitive.
setlocal cm=blowfish2       " Establece de forma predeterminada blowfish2 como algoritmo de cifrado.
set mouse-=a                " Desactiva el uso del ratón, permitiendo usar el ratón normalmente sobre la terminal.
set pastetoggle=<F2>        " En el modo "Insert", al pulsar "F2" se podrá copiar texto sin sufrir el típico tabulado / indentado automático: http://vim.wikia.com/wiki/Toggle_auto-indenting_for_code_paste
set laststatus=2            " Muestra siempre la barra de estado de vim, mostrando el nombre del fichero, estado, modo actual (si se está ingresando nuevo contenido o no), etc.

" Resaltado de lineas y columna elegante que puede activarse dentro del modo comando pulsando la tecla "<Leader>" "\" y antes de que pase un segundo "c".


hi CursorLine   cterm=NONE ctermbg=235
hi CursorColumn cterm=NONE ctermbg=235
nnoremap <Leader>c :set cursorline! cursorcolumn!<CR>  
</code>

NOTA: Para desactivar opciones establecidas con "set: XX", simplemente utilizar "set: noXX". Por ejemplo "set :spell" para activar corrección ortográfica y "set: nospell" para desactivarla.

Suspender Vim y volver a shell temporalmente / restaurar Vim: Control-Z / fg (en la terminal, [[fore_background_desvincular_procesos_de_la_shell|leer]].)

**Backups con Vim**.

Vim puede hacer copias de seguridad automáticas de una manera muy configurable. Aquí se presenta una a modo de ejemplo que es suficientemente competente y simple, permitiendo tener todos nuestros ficheros seguros y los backups centralizados en .$HOME/.vim. En determinadas ocasiones si el tamaño del directorio crece demasiado, puede ser recomendable crear un cronjob que limpie el directorio o exporte de manera comprimida backups a otras ubicaciones. Nuestra configuración propuesta tiene las siguientes características.

Se guardará mediante la opción de swap cada 4segundos (predeterminado) los cambios sobre cualquier archivo para solventar caídas del sistema.

Se genera una copia con fecha y ruta cada vez que guardemos y salgamos del editor.

Todos los cambios realizados en la vida del fichero son también guardados. Esto permite abrir en cualquier momento un archivo y devolverlo a base de "deshacer" a su estado original.

<code>" Backups.
set backup        " Activa el uso de backups.
set undofile      " Guarda también los cambios /acciones realizadas sobre el fichero.
set writebackup   " Genera un Backup al guardar cambios y le agrega la  fecha (siguiente opción).
au BufWritePre * let &bex = '__' . strftime("%F.%H:%M")     " Al salir guardando se genera un fichero con la fecha como sufijo, ej: %home%julia%playlist.m3u__2013-08-15.01\:47 .

" Directorio de Backups: # mkdir $HOME/.vim/Backups/.swp $HOME/.vim/Backups/.undo $HOME/.vim/Backups/.backup && chmod 700 $HOME/.vim/backups
" Si no son creados los directorio usará /tmp. NOTA: Prestar atención a los permisos de los directorios por motivos de seguridad.
set backupdir=$HOME/.vim/Backups/.backup//,/tmp//
set directory=$HOME/.vim/Backups/.swp//,/tmp//
set undodir=$HOME/.vim/Backups/.undo//,/tmp//
</code>


**Búferes en Vim / editar varios documentos**.

En Vim se pueden editar múltiples ficheros usando buffers, pestañas y ventanas (splits). Los búferes son como proxies de fichero, se recomienda por motivos de diseño usar pestañas únicamente cuando se editan ficheros relacionados. Las pestañas en Vim fueron concebidas para dividir espacios de trabajo. Por ejemplo tener en pestañas archivos que forman parte del mismo proyecto en el que se está trabajando.

La forma ideal de trabajar con múltiples ficheros en Vim que no tengan relación entre sí debe ser por medio de buffers y/o splits.


<code>
:e fichero    # Abre el fichero en un búfer, el mismo nombre de archivo será el del búfer.
:ls           # Muestra los búferes, útil en combinación con ":b".
:b n          # Se redirige al búfer número "n". Con "#" se pasa al búfer anterior en uso. Se puede especificar en vez de un número el nombre del archivo (autocompletado disponible).

:enew         # Crea un buffer nuevo en la misma ventana.
:new          # Divide la terminal horizontalmente con un nuevo búfer.
:vnew         # Divide la terminal verticalmente con un nuevo búfer.
:tabnew       # Crea un búfer en una pestaña.</code>

NOTA: Cuando se ejecuta :ls, es factible volver a escribir dos puntos y elegir otro buffer con el listado mostrado mediante :ls. Veamos el ejemplo cambiando el buffer perteneciente al fichero README.txt
<code>
:ls
  1 %a + "calcurse2.txt"                línea 6
  2  a=  "borrar_historial.sh"          línea 0
  3 #a + "compyler/README.txt"          línea 1
:b3</code>

Ejecutar comandos vim en todos los buffers.
<code bash># Buscar y remplazar en todos los buffers. 
# "update" guarda el cambio solo si se produce. "w" guarda todos los bufers, independientemente de si el comando provocó un cambio.
:bufdo %s/pattern/replace/g | update
:bufdo %s/pattern/replace/ge | w</code>

**Ventanas (splits) en Vim**.

Muy útil cuando se necesita comparar dos archivos o bien trabajar en una parte del búfer actual mientras se mantiene otro zona dle fichero como referencia en pantalla en otra ventana (split).

<code bash>
:sp fichero           Divide la ventana horizontalmente y abre el fichero indicado.
:vsp fichero          Divide la ventana verticalmente y abre el fichero indicado.

Ctrl+ws                            Divide la ventana en dos de forma horizontal (:sp).
Ctrl+wv                            Divide la ventana en dos verticalmente (:vsp)
Ctrl+ww  /  Ctrl+w+"Tecla cursor"  Desplazarse entre ventanas (splits / vimdiff / etc).
Ctrl+wq                            Cierra la ventana.      

Ctrl+w+10> / Ctrl+w+10<            Modificación en 10 puntos el tamaño de ventanas verticales.
Ctrl+w+10+ / Ctrl+w+10-            Modificación en 10 puntos el tamaño de ventanas horizontales.

Ctrl+w=                            Iguala el tamaño de todas las ventanas.
Ctrl+w|                            Aumenta todo lo posible la ventana horizontalmente.
Ctrl+w_                            Aumenta todo lo posible la ventana verticalmente.


# Efecto Zoom en ventanas con Vim.
# Poner una ventana en primer plano sin perder las ventanas: El truco es abrir una pestaña con dicho buffer, hacer lo que sea con ella y luego cerrarla para volver a la particion de ventanas anterior.

:tabedit %     Arranca el buffer en una pestaña nueva.
:tabclose      Cierra la ventana.

Ctrl+wo        Deja la ventana en primer plano y elimina el resto de ventanas.</code>

Puede ser de ayuda en algunos casos usar el ratón para cambiar de ventana, para eso se puede usar la opción que activa el mouse por ejemplo en el modo normal (no de inserción).
<code bash>:set mouse=n</code>

**Pestañas en Vim**.

Como se comentó anteriormente en la sección de los buffers, las pestañas en Vim fueron concebidas para dividir espacios de trabajo. Por ejemplo tener en pestañas archivos que forman parte del mismo proyecto en el que se está trabajando.

<code bash>
:tabnew          # Abre una pestaña.
:tabnew fichero  # Abre o crea un fichero en una pestaña.
vim -p *.sh      # Abre todos los ficheros .sh en pestañas, se puede crear un alias vim = vim -p.

Ctrl+PageUp / Ctrl+PageDown           # Moverse entre pestañas (opción 1).
Ctrl+Alt+PageUp / Ctrl+Alt+PageDown   # Moverse entre pestañas (opción 2).

:tabn      Siguiente pestaña.
:tabp      Pestaña previa.
:tabfirst  Primera pestaña.
:tablast   Última pestaña.</code>
  
Puede ser de ayuda en algunos casos usar el ratón para cambiar de pestaña, para eso se puede usar la opción que activa el mouse por ejemplo en el modo normal (no de inserción).
<code bash>:set mouse=n</code>

NOTA: Recordar que en Vim el tabulador permite autocompletado / listar posibles comandos y sus parámetros.

**Vim y grep**: Abrir en pestañas de Vim todos los ficheros que contengan un determinado patrón.
<code bash>IFS=$'\n' ; vim $(grep -l ..); unset IFS</code>
NOTA: Vim tiene también comandos propios como :vimgrep que no serán tratados aquí.


**Teclas útiles en el modo comando de Vim**.
<code text>
Teclas para moverse /desplazarse ágilmente en Vim: http://vim.wikia.com/wiki/Moving_around

h    Izquierda.
l    Derecha.
j    Abajo. (gj para párrafos formados por una sola linea).
k    Arriba. (gj para párrafos formados por una sola linea).

^    Dirige el cursor a principio de linea.
i    Dirige el cursor a principio de linea y se pone en modo inserción.
$    Dirige el cursor al final de linea.
A    Dirige el cursor al final de linea y se pone en modo inserción.
{    Dirige el cursor un párrafo arriba.
}    Dirige el cursor un párrafo abajo.

Ctrl+f   Equivale a Avpag.
Ctrl+b   Equivale a Repag.
Ctrl+u   Equivale a la mitad de un AvPag y permite dejar el cursor hasta arriba del documento.
Ctrl+d   Equivale a la mitad de un AvPag y permite dejar el cursor hasta abajo del documento.

o    Se pone en modo de inserción en la linea siguiente al cursor.
ma   Marca la linea en la que estamos con "a" como identificador. Útil al trabajar con ficheros grandes.
'a   Nos dirige a la linea marcada como a.

G      Se dirige al final del documento.
gg     Se dirige al principio del documento.
34gg   Se dirige a la linea 34 del documento.

?  Buscar hacía arriba de nuestra posición. Permite regex, ejemplo ?&variable=.*&
/  Busca texto hacia abajo (puede volver al principio si llega al final del documento). Permite regex, ejemplo ?&variable=.*&
:%s/pattern//gn  Busca igualmente un texto pero además indica el número de ocurrencias y en cuantas lineas (ej. 25 matches on 23 lines).

#  Sobre una palabra permite usarlo como termino de búsqueda automáticamente. Ctrl+o Vuelve el cursor a la anterior posición.
%  Sobre una llave, paréntesis o corchete encuentra su correspondiente cierre.

>>  Tabula a la derecha donde está el cursor.
5>> Tabula a la derecha 5 lineas tomando como referencia el cursor.
<<  Tabula a la izquierda derecha donde está el cursor.
5<< Tabula a la izquierda 5 lineas tomando cono referencia el cursor.

ciw  Sustituir una palabra: Elimina la palabra (debe estar limitada por espacios, puntos u otros caracteres) y se coloca en modo inserción.
cw   Sustituir una palabra a partir del cursor
cc   Sustituye una linea: Elimina la linea y se pone al principio de la linea en modo inserción.
c$ / C  Sustituir desde el cursor hasta el final linea: Se coloca donde está el cursor en modo inserción.
c   En modo visualización o bloque visual permite sustituir simplemente pulsando c una vez seleccionado el texto. Muy útil para cambiar el texto de columnas con bloque visual (Ctrl +v > c > nuevo texto > Esc).


######## Copiar / Cortar / Pegar en Vim.

# Copiar y cortar desde vim en escritorio y pegar en un entorno remoto mediante SSH es factible sin necesidad de ratón teniendo "+clipboard".
# Copiar y cortar desde vim en un entorno remoto (SSH) y pegar en la instancia de vim local de escritorio sin ratón no es posible de manera nativa.

# Portapapeles + (X11 clipboard - (Ctrl+c / Ctrl+v))
# Portapapeles * (X11 Lo seleccionado con el ratón - Se pega con botón central del ratón o Shift+insert)
# NOTA: Vim suele venir en muchas distribuciones en su versión mínima, se suele instalar gim-gtk / gvim para tener la versión completa, la cual viene simplemente compilada con más opciones activadas, entre ellas soporte para el portapapeles: "vim --version | grep clipboard" debe mostrar +clipboard.

yy     Copia la linea (8yy copia la linea actual más otras 7).
"+yy   Copia en el portapapeles X11 (es necesario +clipboard).
"*yy   Copia en el "portapapeles" donde se almacena lo seleccionado con el ratón (es necesario +clipboard).
"_y    Copia en "_ (Esto permite pegar algo diferente a lo copiado con y/yy usando "_p p "_P). También se puede usar "_yy para lineas.

# NOTA: Para copiar también puede usarse el ratón o combinación de teclas de la terminal en uso para copiar una vez se seleccione en vim por medio del modo Visual (o ratón).Para pegar habría que saber en qué clipboard almacena la terminal en uso lo copiado.

# Si se quiere seleccionar un texto muy largo desde el ratón que requiera scrolling es necesario usar ":set mouse=a" para que el scrolling funcione. Una vez se termine se puede desactivar mediante ":set mouse="

# NOTA: AL usar +clipboard, el uso del modo visual o bloque visual de Vim, introduce el contenido en el clipboard secundario.


dd     Corta la linea (8dd corta la linea actual más otras 7).
"_d    Corta la linea y permite ser pegado posteriormente mediante "_p o "_P. También se puede usar "_dd para lineas.
gg"+yG Copia todo el fichero al portapapeles (clipboard).
:%y+   Copia todo el fichero al portapapeles (clipboard), como el anterior pero en modo ejecución (:).

## Pegar en el mismo host (no SSH).

P      Pega a la izquierda del puntero. (Cuidado con copiar el salto de linea y luego pegar, esta tecla no inserta lineas en blanco intermedias como dicen algunos manuales).
p      Pega a la derecha del puntero. (Cuidado con copiar el salto de linea y luego pegar, esta tecla no inserta lineas en blanco intermedias como dicen algunos manuales).
"+p    Pega lo almacenado en el clipboard (Ctrl+v).
"*p    Pega lo almacenado en la selección realizada (Botón derecho del ratón / Shift+insert).
"_p    Pega lo que haya sido copiado mediante "_y (Esto permite pegar algo diferente a lo copiado con y/yy o cortado d/dd). Lógicamente "_P también está soportado.

NOTA: En lo relativo a copiar, cortar y pegar hay que saber que si se copia algo y luego se copia, borra o se corta otra cadena de texto, el texto copiado anteriormente no estará disponible. Por eso el uso de las opciones que usan el "black hole register" ("_) fueron explicadas.

## Pegar desde el clipboard en instancias de vim remotas (ej SSH): Lo más sencillo sería evitar las funciones de clipboard de vim.

Ctrl + Shift + v    Depende de la terminal en uso, en caso de usar terminator se refiere al clipboard principal/X11.
Shift + Insert      De estar en uso los dos clipbord, suele pegar lo que está en el secundario, lo seleccionado con el ratón.
Alt + Shif + Boton central del ratón / rueda de scrolling.      Usa el clipboard secundario.

########

:r fichero            Pega el contenido de un fichero en el documento.
:r!ls                 Ejecuta comandos y escribe en el fichero su salida. 
:e fichero            Abre el fichero / sin indicar fichero refresca el contenido.
Ctrl+o+o              Carga el ultimo fichero editado y en la ultima posición donde se encontraba el cursor.

Ctrl-x+l   Autocompleta lineas.
Ctrl-x+k   Autocompleta por diccionario previamente cargado (:set dictionary+=/home/XX/.vim/words.txt).
Ctrl-x+n   Autocompleta por palabras del propio documento.
Ctrl-x+f   Autocompleta por nombres de ficheros del sistema.
Ctrl+x+f   Completa rutas del sistema de ficheros según se escribe en el modo inserción.

g + Ctrl+g   Muestra información del fichero y la linea donde se encuentra el cursor: Col 1 of 87; Line 16 of 154; Word 37 of 377; Byte 366 of 4669

:u       Deshacer acción.
Ctrl+r   Rehacer lo deshecho.

:earlier 15s     Volver al estado de hace 15 segundos.
:earlier 20m     Volver al estado de hace 20 minutos
:earlier 1h      Volver al estado de hace 1 hora.

Ctrl+o   Carga los anteriores documentos donde hayamos estado previamente / Devuelve el cursor a la posición anterior cuando se está buscando texto.

:w       Guardar.
:wq      Salir guardando.
:q       Salir sin guardar.

:X                         Cifra el fichero (Recomendado usar Blowfish2 en .vimrc).
:setlocal cm=blowfish2     Permite utilizar el cifrado Blowfish2.
:setlocal cm?              Muestra el valor actual de una opción, en este caso el algoritmo de cifrado del fichero (:set mouse?, :set background?, ...)

V  /  Esc+v    Modo Visual: Cuando no se puede hacer uso del ratón, en este modo se puede seleccionar múltiples lineas para su borrado (d) / copiado (i). 

vim "+COMANDO" Arrancar Vim especificando determinadas opciones (vim "+syntax off").

+ Anteponiendo antes de copiar (y) o cortar (d) algo le indica que debe guardarlo en el portapapeles principal del SO (botón central del ratón).

:his         Muestra el historial de comandos ("Crtl + f" muestra un menú para seleccionar comandos del historial y pueden ser editados antes de lanzarlos).
:%s/pala     Si se empieza a  escribir algún comando, pulsando las teclas cursor se puede autocompletar con la información del historial, ejemplo ":%s/palabra1/palabra2/g". Si no se escribe nada y se pulsa la tecla cursor arriba Vim irá recorriendo el historial de manera descendente.
@:           Repite el último comando.

NOTA: La tecla cursor arriba permite siempre ver el historial, no solo de comandos ejecutados con ":", si no también búsquedas (/). Recordar que en Vim el tabulador completa / lista posibles comandos disponibles, incluso parámetros.


set cursorline    Resaltado de linea.
set cursorcolumn  Resaltado de columna.
\c                En el modo comando permite cambiar entre resaltado horizontal y vertical. No debe pasar más de un segundo desde que pulsamos "\" antes de pulsar la tecla "c" (Debe estar definido en el fichero de configuración).
</code>

**vimdiff** / **vim -d** Permite obtener las diferencias entre X ficheros de una manera amigable.
<code>
]c   Se dirige a la siguiente diferencia.
[c   Se dirige a la diferencia anterior.

:diffput   Los cambios / diferencias sobre los que se encuentra el cursor se trasladan al otro fichero.
:diffget   Los cambios / diferencias sobre los que se encuentra el cursor son sobrescritos por el contenido del otro fichero.

:diffoff      Desactiva el modo diff. 
:diffthis     Activa el modo diff, útil cuando no se usó vimdiff desde un principio.
:diffupdate   Escanea de nuevo los ficheros en busca de diferencias.

Ctrl +ww / Ctrl+w+cursor   Permite moverse entre ventanas (Mirar en la sección anterior más opciones con ventanas).
</code>

**Ejecutar múltiples comandos / Sustitución con múltiples patrones en  Vim**.

Ejecutar varios comandos en Vim es muy útil, puede servir para por ejemplo sustituir múltiples patrones de texto. Con el símbolo "|" se pueden concatenar comandos, de manera que se ejecute un comando tras otro mientras no den error (funciona como un "AND" lógico).

<code bash>%s/htm/html/g | %s/JPEG/jpg/g</code>

Si alguno de los comandos es posible que falle, por ejemplo al no encontrar la cadena "htm" para sustituirla, se puede agregar una "e" para que no de error y se ejecute el siguiente comando.
<code bash>%s/htm/html/ge | %s/JPEG/jpg/g</code>

NOTA: La agregación de la letra "e" es válida para ":substitute", de usar otros comandos se debe consultar la documentación para averiguar qué "flag" permite no mostrar errores y así continuar con la ejecución de comandos.

**Corrección ortográfica (spell) en Vim**: Es posible que se deba instalar el diccionario (ej. vim-spell-de).
<code>:set spell spelllang=es    Establece la corrección de texto para español subrayando las palabras erróneas.
z=                         Muestra un menú para elegir la palabra correcta.
zg                         Inserta la palabra en el diccionario.
zug                        Elimina la palabra del diccionario.
:set unspell               Desactiva la corrección ortográfica.</code>

**Remplazar / Sustituir texto en Vim**.
<code># Remplaza en todo el documento todas las coincidencias de la cadena "palabra" por la cadena "remplazo".
:%s/palabra/remplazo/g
# Remplaza en la linea donde esté el cursor todas las coincidencias de la cadena "palabra" por la cadena "remplazo".
:s/palabra/remplazo/g
# Remplaza enntre las lienas 3 y 5 todas las coincidencias de la cadena "palabra" por la cadena "remplazo".
:3,5s/palabra/remplazo/g
</code>

Usar la sustitución dentro del modo / bloque visual en Vim (Sin % al principio y indicando %V).
<code>:'<,'>s/\%Vpalabra/remplazo/g</code>

**Eliminar lineas en base a resultados de búsqueda en Vim**.
<code>:g/busqueda/d
# Elimina todas las lineas que no tengan la cadena de busqueda. Recordar que se pueden usar expresiones regulares.
:g!/busqueda/d
</code>

**Eliminar palabras en base a resultados de búsqueda en Vim**: Se pude utilizar simplemente la sustitución
<code>
:%s/patrón//g   # Ejemplo: ":%s/&variable2=.*//g" dejaría la cadena http://XXX/?variable1&variable2=YYY&variable3=jjj en "http://XXX/?variable1"
                      # Si se quire ahorrar tiempo es posible usar simplemente ":%s/&variable2=.*"
                      
# NOTA: Si no se utilizar % la operación se realiza sobre la linea donde se encuentra le cursor. Sin la "g" del final solo lo hará con la primer coincidencia.

# Si se quiere realizar de una en una también se puede buscar la palabra, entrar en el modo inserción, borrarla, pulsar escape y con la tecla n y el punto ir borrando las demás ocurrencias:

/palabra_buscada
i
Borramos la palabra.
Pulsamos Esc
n.
</code>

**Eliminar lineas en base a patrones**: Se usará ":g" y ":v", veamos algunos ejemplos.
<code>
:g/cadena/d   Borra todas las lineas que tengan la palabra cadena.
:g/^\s*$/d    Borro todas las lineas en blanco o que tengan únicamente espacios en blanco.

:g!/^\s*"/d       Elimina todas las lineas menos las vacías y las que unicamente tengan espacios en blanco
:v!/^\s*"/d       Lo mismo que la regla anterior, es equivalente a :g!/^\s*"/d
:v/caca\|pedo/d   Elimina todas las lineas, menos las que contengan las palabras caca y pedo. Es equivalente a :g"/caca\|pedo/d</code>

**Ejecutar comandos Unix desde Vim y sacarle partido**.
<code>:!comando   Muestra la salida estándar del comando en Vim (ej. ":!php -l" para comprobar sintaxis de PHP).
:read !comando    Escribe la salida de comando en la posición actual.

Esc+v > Seleccionar lineas > :sort   Ordena alfabéticamente las lineas (útil para ficheros de configuración o CSS).</code>

Indentar bloques o todo el documento se puede hacer combinando comandos.
<code>
=           Indenta la linea.
gg=G        Indenta todo el documento.</code>

**Comentar / Descomentar bloque de código**. (Usando el modo visual para bloques).
<code> # Comentar código / Agregar prefijos a bloques de lineas.
Pulsar Ctrl + V, se selecciona el texto deseado hacia abajo o hacia arriba, pulsamos "I", se comenta escribiendo el carácter que corresponda y se pulsa ESC para que repita esa acción sobre todo lo marcado anteriormente.</code>

<code># Descomentar / Borrar texto en columnas / Cortar y pegar en columnas.
Pulsamos Ctrl + V para seleccionar en forma de columna los caracteres que se quieren borrar / cortar y se pulsa "dd". Si se quiere pegar posteriormente se usaría como siempre la p.</code>

**Pegar gran cantidad de lineas de texto en Vim de manera rápida**.

Al pegar un contenido de cientos de miles o millones de lineas, Vim y la gran mayoría de editores de texto pueden tardar minutos en terminar la operación de pegado. En estos casos se puede desactivar la funcionalidad "noswapfile" de Vim para acelerar el proceso en gran medida. Una vez se termine de pegar todo el texto se recomienda activar la funcionalidad de nuevo (por defecto activa). Esta es necesaria a la hora de recuperar ficheros cuando no se guardaron los cambios y Vim fue cerrado abruptamente.

Abrir un fichero directamente sin funcionalidad de fichero swap para una operación de pegado pesada.
<code bash>vim -n fichero</code>

En el modo comando de Vim también se puede desactivar el uso del fichero .swp.
<code bash>:set noswapfile
# Pegar
:set swapfile

# :help swap-file # Para obtener información 
</code>

Otra posibilidad siempre accesible desde entornos Unix sería usar el comando "cat". Con este comando se puede pegar una gran cantidad de lineas de texto en un fichero sin demasiada demora.

<code>cat > fichero
# Pegamos el texto.
# Se pulsa Cntrl + D</code>

**Repetir acciones** (.): Ejemplo insertando un comentario a principio de linea.
<code>Esc > I > (comentamos con #, // o el que corresponda) > Esc " Ahora en la linea donde se pulse "." será comentada.</code>

**Comentar / Descomentar bloques de lineas en Vim**.
<code>Esc > Ctrl + v > seleccionar las lineas > I (comentamos con #, // o el que corresponda) > Esc</code>
<code>Esc > Ctrl + v > seleccionar los caracteres de comentario > d</code>

**Comentar / Descomentar bloque de código usando un atajo de teclado** (Compatible con modo visual).

Comentar las lineas de código deseadas pulsando dentro del modo comando "##". Para descomentar las lineas simplemente pulsar ++. Si NO se detecta mediante la extensión que es un fichero PHP, C, go, java, javascript o CSS, se usará la almohadilla para comentar lineas. El atajo de teclado es compatible con el modo visual para comentar grandes bloques de código.

Editar el fichero .vimrc y agregar el siguiente mapeo de teclas.
<code>""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
map ## :s/^/# /<CR>:noh<RETURN>
autocmd BufNewFile,BufRead *.c,*.cpp,*.h,*.php,*.go,*.css,*.class,*.java,*.js  map ## :s/^/\/\/ /<CR>:noh<RETURN>
                                                                                                                       
map ++ :s/^# //<CR>:noh<RETURN>
autocmd BufNewFile,BufRead *.c,*.cpp,*.h,*.php,*.go,*.css,*.class,*.java,*.js  map ++ :s/^\/\/ //<CR>:noh<RETURN>
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""</code>

**vimdiff**: Edita / Visualiza en modo diff (dos o más fichero).
<code>Ctrl+ww  /  Ctrl+w+"Tecla cursor"  Desplazarse entre ventanas (splits / vimdiff / etc).

[c   Se dirige a la diferencia anterior.
]c   Se dirige a la diferencia posterior.

:diffupdate    Actualiza el proceso de diferenciado.

zo / cursor derecho sobre la marca     Despliega el código que carece de diferencias.
zc / cursor izquierdo sobre la marca   Repliega el código que carece de diferencias.</code>

**Cambiar tema / esquema de colores de resaltado de sintaxis** (http://vimcolors.com/).
<code># Para instalar nuevas composiciones se deben copiar los ficheros .vim (ej. /usr/share/vim/vim80/colors/ ).
:colorscheme [TAB]</code>


**Editar ficheros que estás siendo editados otros usuarios**.

Cuando un fichero está siendo editado, se genera un fichero ".swp" que contiene todos los nuevos cambios que se realizados desde la última vez que se guardo el fichero. Si abrimos el fichero desde otra terminal, nos avisará de que está siendo ya editado y que ha recibido cambios que actualmente no han sido guardados.

Este aviso va acompañado de un menú que ofrece, entre otras opciones, recuperar el estado actual del fichero, es decir, con los cambios que todavía no han sido guardados, para eso se debe pulsarla tecla "r".

El archivo de intercambio ".test.swp" ya existe!
[A]brir para lectura únicamente, (E)ditar de todas formas, (R)ecuperar, (S)alir, A(b)ortar</code>

<code>:recover      Si una vez dentro de Vim queremos cargar los cambios no guardados (suelen encontrarse en un fichero oculto con extensión .swp).</code>

Con el parámetro "-r" Vim permite abrir directamente el fichero swp y carga los cambios realizados.
<code>vim -r .fichero.swp</code>

NOTA: Como ya se comento previamente en la guía, si hay que pegar muchas lineas en Vim, es recomendable desactivar la opción de swap para acelerar el proceso y no demorar demasiado.

**Vim en "modo fácil"**: En este modo Vim se encuentra siempre en modo insertar y tiene un remapeo de teclas para que el comportamiento sea como cualquier otro editor. Con Ctrl+l permite ir al modo comando, necesario por ejemplo para guardar o salir si no se está utilizando la versión gráfica de gvim, que es realmente a donde está orientado el uso de este modo de Vim).
<code bash>vim -y   # Arrancara gvim si se encuentra instalado, si no, en terminal.</code>

**Crear** / **Ejecutar macros en Vim** (asociar trabajos / combinaciones de comandos a teclas): Muy útil para transformar ficheros de manera rápida.

<code>
q+letra     Empieza a grabar la macro y se le identifica con letra.
V > G > =   Se ejecutan los comandos / inserciones que se deseen (ej. Indentar todo el documento).
q           termina la macro y la guarda, quedando disponible en Vim indefinidamente.

@+letra   Ejecuta el macro grabada como letra.
@@        Ejecuta el ultima macro (ej. Repetir tres veces la macro: 3@@).

:reg a    Muestra el macro guardada como "a", si no se especifica una letra muestra todas los macros almacenados.
qaq       Borrar el macro "a".( Alternativa :let @a = '').
</code>

**Guardar cambios sobre ficheros propiedad de root como usuario normal en Vim**.
<code>Si el directorio contiene permisos suficiente, el usuario puede borrar un fichero que no es de su propiedad y por lo tanto puede volver a crearlo con él como propietario.
Que un fichero esté protegido contra escritura no significa que no pueda ser eliminado. Para ello se debe forzar el guardado del documento con "!"

:w!

Si la carpeta donde está el fichero no tiene como propietario al usuario, se puede usar el comando "sudo" de la siguiente forma. (Ver enlaces de interés al final del post).

:w !sudo tee %

NOTA: Esto no actualiza, sobrescribe el fichero como root y lo guarda.</code>

El símbolo "+" al ejecutar Vim en la linea de comandos permite lanzar instrucciones del modo comando.
<code bash>
vim cacas6 +wq              # Crear el fichero cacas6 y sale guardando (:wq). 
vim +X cacas7               # Genera el fichero cacas7 con cifrado desde el principio. (:X)
vim "+set paste" "+start"   # Arranca vim en modo inserción y con la opción paste activa.</code>

**Abrir ficheros con Vim (sin GUI) desde el escritorio**.

Comando personal "tvim" (/usr/bin/tvim) para arrancar Vim en una terminal gráfica (terminator) en modo inserción y con la opción de pegar activa. Se puede arrancar desde el escritorio con algún lanzador (ej Alt+ F2), útil cuando se quiere obtener rápidamente una terminal para operar sobre algún texto guardado en el portapapeles. También se puede configurar para abrir un documento de texto desde el navegador o desde el gestor de ficheros / escritorio. Si se seleccionan varios documentos de manera gráfica, tvim abrirá cada uno en una terminal diferente.
<code bash>
#!/bin/bash
if [ $# -eq 0 ]                                                                           
then 
        /usr/bin/terminator -x "IFS=$'\n'; vim '+set paste' '+start'; unset IFS"
else    
        /usr/bin/terminator -x "IFS=$'\n'; vim '+set paste' '+start' \"$@\"; unset IFS"
fi      
</code>

NOTA: Si se obtiene en temrinator el error "Imposible encontrar una terminal" / "Unable to find a shell" Usar el siguiente código en vez del anterior.
<code bash>
#!/bin/bash
if [ $# -eq 0 ]                                                                           
then 
        /usr/bin/terminator -x bash -c "IFS=$'\n'; vim '+set paste' '+start'; unset IFS"
else    
        /usr/bin/terminator -x bash -c "IFS=$'\n'; vim '+set paste' '+start' \"$@\"; unset IFS"
fi      
</code>

NOTA: El uso de IFS es necesario para no tener problema con nombres de fichero / directorio que contengan espacios. Para el ejemplo se ha usado "terminator", pero casi cualquier terminal tiene opciones de ejecución de comandos.

**Crear diccionarios de texto para Vim **. (Ordenar alfabéticamente y borrar lineas duplicadas)

En Vim Se pueden usar diccionarios para autocompletado de palabras al escribir (Ctrl+x Ctrl+k). Una opción es crear diccionario a partir de los ficheros dic del paquete spell, que son diccionarios especiales utilizados para la corrección ortográfica. De esta forma se obtienen buenos diccionarios para realizar autocompletado al escribir texto normal.

Abrir el fichero /usr/share/hunspell/es_ES.dic, quitamos unos sufijos especiales y posibles duplicados para la autocorrección con el siguiente comando.
<code>:sort u</code>
Se guarda el archivo donde se quiera y para activarlo simplemente utilizamos "dictionary".
<code>:set dictionary+=/home/XX/es_ES.dic,/home/XX/en_EN.dic</code>

**Editar ficheros binarios usando código hexadecimal**.
<code>:%!xxd      Pasa el código binario a hexadecimal.
:%!xxd -r   Pasa de hexadecimal de nuevo a binario (Se debe guardar el fichero lógicamente así una vez editado).</code>
NOTA: Al mostrarse el formato hexadecimal, a la derecha se muestran una columna con los caracteres que representan dichos códigos hexadecimales. Hay que recordar que la única parte editale realmente es la hexadecimal, no la de texto que es muestra a la derecha. Si se edita el texto y vuelve a pasarse a binario, el cambio desaparecerá automáticamente.

**Codificación del texto** (ISO-8859-1, UTF-8, cp850, etc)

<code bash>
# Conocer la codificación del fichero con la que vim lo está visualizando.
:set fileencoding
# También es posible ejecutar comandos externos, por ejemplo chardetect.
:!chardetect %

# Corregir la codificación actual en caso de que Vim no esté usando la correcta.
:e ++enc=<encoding>

# Convertir entre codificaciones.
# Opción 1.
:wq ++enc=utf-8 % # Convierte a UTF-8 el texto actualmente visualizado.
:wq ++enc=utf-8 fichero.txt # Convierte a UTF-8 el texto.

# NOTA: Esto modifica la codificación y sale del fichero. Si no se desea salir del archivo, es recomendable ejecutar ":e ++enc=utf-8".
# Si no se realiza ese paso y se guarda posteriormente otra vez, al haber abierto Vim primeramente ese fichero con su codificación original, al guardar de nuevo la restablecerá. Perdiendo asi la codificación UTF-8 guardada previamente.
# En caso de no guardar de nuevo el fichero este paso no sería necesario.

# Opción 2.
:set fileencoding=utf-8   # Establecemos que la codificación que vim debe estar usando es UTF-8.
:set encoding             # Establece que la codificación del fichero sea la estblecida mediante fileencoding.
:w                        # Guarda el fichero.

# Esto funciona ya que cuando "fileencoding" y "encoding" difieren, Vim intentará convertir el contenido del archivo de la codificación existente (':set encoding') a la codificación de destino (':set fileencoding'). 

8g8   # Este comando identifica cualquier secuencia de caracteres UTF-8 inválida en el archivo actual. 

# NOTA: Por ejemplo, si el archivo está codificado como UTF-8, pero contiene un byte o conjunto de bytes que no representan un carácter UTF-8 válido, este comando posicionará el cursor sobre esa ubicación en el archivo. 
# Generalmente, Vim representará esta secuencia de caracteres inválida como el valor hexadecimal del byte o los bytes encerrados entre paréntesis angulares, como "<93>".
</code>

**Caracteres no imprimibles**.
<code bash>
# Los digraph son códigos que hacen referencia a caracetres que no pueden ser representados en ASCII. 
# Por ejemplo serían digraphs un retorno de carro o un símbolo de marca registrada.

:as   # "Muestra el code point" del caracter donde se encuentre el cursor: Su valor decimal, hexadecimal, octal y "digraph". 
ga    # Lo mismo que el anterior. Ejemplo de salida: <®> 174, Hex 00ae, Oct 256, Digr Rg

:digraphs   # Muestra la lista de caracteres.
Ctrl+K XX   # XX es el código del digraph a insertar. ® Ctrl+K Rg
Ctrl+V XX   # XX Es el código hexadecimal a insertar. ® Ctrl+V 174
</code>

**Formatos de archivo (DOS / UNIX / MAC)**: CRLF / LF / CR.

Vim trabaja con los formatos de fichero Windows, Unix y Mac, cada uno de ellos se diferencia del otro simplemente en la manera de definir el fin de linea. ([[codigos_de_control_crlf_lf_cr_eol |leer]]). Es posible que los ficheros que han pasado por muchas manos, a veces se nos presenten con diferentes formatos de fin de linea dentro de un mismo fichero.

  - **CRLF** (Windows) =  End of Line (EOL) =  0x0D 0x0A = **\r\n**
  - **LF** (Unix / Mac >= OS-10) = 0x0A (10 decimal). = **\n** = nl
  - **CR** (Macintosh < OS-9) = 0x0D (13 decimal) = **\r** = cr

Lo primero ha tener en cuenta es conocer el formato de linea, si es que no se tienen varios, para ello se puede usar el comando file, con "cat -A" se pueden visualizar ciertos caracteres
<code>
ASCII text                                   # Unix.
ASCII text, with CR line terminators         # Mac
ASCII text, with CRLF line terminators       # Windows
ASCII text, with CRLF, LF line terminators   # Mix de tipos de formato.
ASCII text, with CRLF, CR line terminators   # Mix de tipos de formato.
</code>

Una vez se conoce el problema, con Vim siempre se va a poder solucionar.
<code bash>
# Documentación de VIM: https://vim.fandom.com/wiki/File_format

vim -b fichero    # El entrar en modo binario dentro de un formato DOS, permite visualizar retornos de carro "^M". No entrar en modo binario si se quiere transformar el formato.

# Desde vim se pueden visualizar los retornos de carro usando el siguiente comando
:e ++ff=unix

# Usar cat -A fichero para visualizar caracteres de fin de linea.

vim +":set list" fichero  # Muestra los finales de linea, tabulación, etc. Muy útil para encontrar múltiples espacios en blanco.
</code>

Lo primero para resolver un problema con diferentes formatos de fin de linea en un fichero, es visualizar el documento desde uno de los formatos.
<code>
:e ++ff=dos    # Si se tienen caracteres CRLF (^M$) y se debe usar unix hay que visualizar primeramente como DOS.
:e ++ff=mac    # Si se tienen caracteres LF ($) y se debe usar DOS hay que visualizar como UNIX.
:e ++ff=unix   # Si se tienen caracteres CR (^M) y se debe usar unix hay que visualizar como MAC.
</code>

NOTA: A veces, al copiar por medio de vim un fichero, simplemente copiando y pegando texto, nos damos cuenta de que el archivo resultante no es exactamente el mismo que el original, sus checksum (md5, sha, etc) no coinciden. Esto suele deberse al tema de las codificaciones, si el fichero que abrimos contiene "^M", vim no lo mostrará y al copiar el texto a otro fichero, este caracter de nueva linea no será incluido y por lo tanto el checksum no puede ser el mismo.

Cambiar el formato de fin de linea (Se debe estar dentro de la visualización correcta previamente).
<code bash> 
set ff=unix    # Cambia los finales de linea usados en el formato actualmente visualizado por los de tipo Unix.
:w ++ff=unix   # Lo mismo que le anterior pero guardando directamente.

set ff=dos     # Cambia los finales de linea usados en el formato actualmente visualizado por los de tipo Windows/DOS.
:w ++ff=dos    # Lo mismo que le anterior pero guardando directamente.

set ff=mac     # Cambia los finales de linea usados en el formato actualmente visualizado por los de tipo Windows/DOS.
:w ++ff=mac    # Lo mismo que le anterior pero guardando directamente.
</code>

El fichero se mostrará de diferente manera dependiendo del formato en uso, veamos qué hacer si se tiene los tres tipos de fin de linea en un solo fichero y queremos que se utilice únicamente unix.
<code>
:e ++ff=mac   # Se visualiza interpretando los finales de linea como un MAC.
set ff=unix   # Se modifican los finales de linea  del formato MAC a UNIX.
:e ++ff=dos   # Se visualiza interpretando los finales de linea como un Windows.
set ff=unix   # Se modifican los finales de linea  del formato DOS/Windows a UNIX.
:w            # Guardamos.
# :e ++ff=unix   # Visualizar el fichero en formato UNIX.</code>

Como transformar codificación de múltiples ficheros con Vim a tipo unix.
<code bash>for file in $(ls *cpp)
do 
  vi +':w ++ff=unix' +':q' ${file}
done</code>

Como escribir códigos ascii en Vim: Dentro del modo inserción.
<code>
Ctrl + v + valor decimal.
Ctrl + v + x + valor hexadecimal.
Ctrl + v + u + valor hexadecimal de 4 carcateres (Unicode). 
Ctrl + v + U + valor hexadecimal de 8 carcateres (Unicode). 

# Ejemplos introduciendo los tres diferentes tipos de fin de linea.

Ctrl + v + 13       # Inserta un retorno de carro estilo MAC usando su valor decimal.
Ctrl + v + x + 0d   # Inserta un retorno de carro estilo MAC usando su valor hexadecimal</code>

=== Utilizar VIM para reproducir canales de una playlist ===

Para los amantes de la terminal puede ser socorrido navegar con VIM por un fichero lleno de enlaces al estilo playlists y poder reproducir dichos enlaces mediante una tecla. Agregando esta configuración al fichero ".vimrc", al situarse con el cursor sobre una linea que contenga únicamente un enlace (típico fichero playlist) y pulsar la tecla F6, el contenido del enlace será reproducido.

<code bash>
# Mplayer (usando cache).
nmap <F6> :exec '!mplayer -cache 4096 -cache-min 99 '.getline('.')

# VLC.
nmap <F6> :exec '!vlc '.getline('.')
</code>


=== Enlaces de interés ===

  * **Vim keystrokes (Combinaciones de teclas)**: [[http://vimgolf.com/]]
  * **Poster de VIM**:{{:vim_poster.png?linkonly|Descargar}}.
  * **Videotutoriales en castellano sobre VIM**: [[https://www.youtube.com/watch?v=cpL32a_GP3k|Parte 1]] / [[https://www.youtube.com/watch?v=XvCD78eA46E|Parte 2]].
  * **Ejecutar comandos en Vim que interactúen con el contenido de su búfer en uso**: [[acceder_al_buffer_de_vim_y_ejecutar_comandos_bash|Link]]
  * **Vim Tips Wiki**: [[http://vim.wikia.com/wiki/Vim_Tips_Wiki]]