He escuchado mucho sobre Vim , tanto pros como contras. Realmente parece que deberías ser (como desarrollador) más rápido con Vim que con cualquier otro editor. Estoy usando Vim para hacer algunas cosas básicas y, en el mejor de los casos, soy 10 veces menos productivo con Vim.

Las dos únicas cosas que debe importarle cuando habla de velocidad (puede que no le importe lo suficiente, pero debería) son:

1. El uso alternativo de las manos izquierda y derecha es la forma más rápida de usar el teclado.
2. Nunca tocar el mouse es la segunda forma de ser lo más rápido posible. Le toma años mover su mano, agarrar el mouse, moverlo y traerlo de regreso al teclado (y a menudo tiene que mirar el teclado para asegurarse de que regresó su mano correctamente al lugar correcto)

Aquí hay dos ejemplos que demuestran por qué soy mucho menos productivo con Vim.

Copiar / Cortar y pegar. Lo hago todo el tiempo. Con todos los editores contemporáneos, presiona Shift con la mano izquierda y mueve el cursor con la mano derecha para seleccionar texto. Luego Ctrl+ Ccopias, mueve el cursor y Ctrl+ Vpega.

Con Vim es horrible:

• yy copiar una línea (¡casi nunca quieres la línea completa!)
• [number xx]yypara copiar xxlíneas en el búfer. Pero nunca sabes exactamente si has seleccionado lo que querías. A menudo tengo que hacer [number xx]ddentonces upara deshacer!

¿Otro ejemplo? Buscar y reemplazar.

• En PSPad : Ctrl+ fluego escriba lo que desea buscar, luego presione Enter.
• En Vim:, /escriba lo que desea buscar, luego, si hay algunos caracteres especiales \antes de cada carácter especial, presione Enter.

Y todo con Vim es así: parece que no sé cómo manejarlo de la manera correcta.

NB: ya he leído la hoja de trucos de Vim :)

Mi pregunta es:

¿Cuál es la forma en que usa Vim que lo hace más productivo que con un editor contemporáneo?

Tu problema con Vim es que no entiendes vi .

Menciona cortar con yyy se queja de que casi nunca quiere cortar líneas enteras. De hecho, los programadores, que editan código fuente, muy a menudo quieren trabajar en líneas enteras, rangos de líneas y bloques de código. Sin embargo, yyes solo una de las muchas formas de tirar texto al búfer de copia anónimo (o "registrarse" como se llama en vi ).

El "Zen" de vi es que estás hablando un idioma. La inicial yes un verbo. La declaración yyes sinónimo de y_. Se yduplica para que sea más fácil escribir, ya que es una operación tan común.

Esto también se puede expresar como dd P(eliminar la línea actual y pegar una copia en su lugar; dejando una copia en el registro anónimo como efecto secundario). Las yy los d"verbos" toman cualquier movimiento como su "sujeto". Por yWlo tanto, es "tirar de aquí (el cursor) al final de la palabra actual / siguiente (grande)" y y'aes "tirar de aquí a la línea que contiene la marca llamada ' a '".

Si solo comprende los movimientos básicos del cursor hacia arriba, hacia abajo, hacia la izquierda y hacia la derecha, vi no será más productivo que una copia del "bloc de notas" para usted. (De acuerdo, aún tendrá resaltado de sintaxis y la capacidad de manejar archivos más grandes que un piddling ~ 45KB más o menos; pero trabaje conmigo aquí).

vi tiene 26 "marcas" y 26 "registros". Una marca se establece en cualquier ubicación del cursor usando el mcomando. Cada marca se designa con una letra minúscula. Por lo tanto, maestablece la marca ' a ' en la ubicación actual y mzestablece la marca ' z '. Puede moverse a la línea que contiene una marca utilizando el 'comando (comillas simples). Así se 'amueve al principio de la línea que contiene la marca ' a '. Puede moverse a la ubicación precisa de cualquier marca utilizando el `comando (backquote). Por `zlo tanto, se moverá directamente a la ubicación exacta de la marca ' z '.

Debido a que estos son "movimientos", también pueden usarse como temas para otras "declaraciones".

Entonces, una forma de cortar una selección arbitraria de texto sería soltar una marca (generalmente uso ' a ' como mi "primera" marca, ' z ' como mi siguiente marca, ' b ' como otra y ' e ' como otro más (no recuerdo haber usado interactivamente más de cuatro marcas en 15 años de uso de vi ; una crea las propias convenciones sobre cómo las marcas y los registros son utilizados por las macros que no perturban el contexto interactivo de uno). al otro extremo de nuestro texto deseado; podemos comenzar en cualquier extremo, no importa. Luego podemos simplemente usar d`apara cortar o y`acopiar. Por lo tanto, todo el proceso tiene una sobrecarga de 5 teclas (seis si comenzamos en "insertar "modo y necesitabaEscfuera del modo de comando). Una vez que hemos cortado o copiado a continuación, pegar en una copia es una sola tecla: p.

Digo que esta es una forma de cortar o copiar texto. Sin embargo, es solo uno de muchos. Con frecuencia podemos describir de manera más sucinta el rango de texto sin mover el cursor y soltar una marca. Por ejemplo, si estoy en un párrafo de texto, puedo usar {y} movimientos al principio o al final del párrafo, respectivamente. Entonces, para mover un párrafo de texto, lo corto usando { d}(3 pulsaciones de teclas). (Si ya estoy en la primera o última línea del párrafo, entonces simplemente puedo usar d}o d{respectivamente.

La noción de "párrafo" por defecto es algo que generalmente es intuitivamente razonable. Por lo tanto, a menudo funciona tanto para el código como para la prosa.

Con frecuencia conocemos algún patrón (expresión regular) que marca un extremo u otro del texto en el que estamos interesados. Buscar hacia adelante o hacia atrás son movimientos en vi . Por lo tanto, también pueden usarse como "sujetos" en nuestras "declaraciones". Así que puedo usar d/foopara cortar de la línea actual a la siguiente línea que contiene la cadena "foo" y y?barcopiar de la línea actual a la línea más reciente (anterior) que contiene "barra". Si no quiero líneas enteras, todavía puedo usar los movimientos de búsqueda (como declaraciones propias), soltar mis marcas y usar los `xcomandos como se describió anteriormente.

Además de "verbos" y "sujetos", vi también tiene "objetos" (en el sentido gramatical del término). Hasta ahora solo he descrito el uso del registro anónimo. Sin embargo, puedo usar cualquiera de los 26 registros "con nombre" prefijando la referencia "objeto" con "(el modificador de comillas dobles). Por lo tanto, si lo uso "add, estoy cortando la línea actual en el registro ' a ' y si lo uso "by/foo, estoy sacando una copia del texto de aquí a la siguiente línea que contiene "foo" en el " pega una copia de" b registro b '. Para pegar de un registro simplemente el prefijo pasta con la misma secuencia de modificador: "appega una copia de la ' un ' registro'"bP ' a antes de la línea actual.

Esta noción de "prefijos" también agrega los análogos de los "adjetivos" y "adverbios" gramaticales a nuestro lenguaje de manipulación de texto ". La mayoría de los comandos (verbos) y el movimiento (verbos u objetos, dependiendo del contexto) también pueden tomar prefijos numéricos. 3Jsignifica "unir las siguientes tres líneas" y d5}significa "eliminar de la línea actual hasta el final del quinto párrafo desde aquí".

Todo esto es nivel intermedio vi . Nada de esto es específico de Vim y hay trucos mucho más avanzados en vi si estás listo para aprenderlos. Si fuera a dominar solo estos conceptos intermedios, probablemente encontraría que rara vez necesita escribir macros porque el lenguaje de manipulación de texto es lo suficientemente conciso y expresivo para hacer la mayoría de las cosas con la suficiente facilidad usando el lenguaje "nativo" del editor.

Una muestra de trucos más avanzados:

Hay una serie de :comandos, sobre todo la :% s/foo/bar/gtécnica de sustitución global. (Eso no es avanzado pero otros :comandos pueden serlo). El :conjunto completo de comandos fue heredado históricamente por las encarnaciones anteriores de vi como ed (editor de líneas) y más tarde las utilidades ex (editor de líneas extendidas). De hecho, vi se llama así porque es la interfaz visual para ex .

:los comandos normalmente operan sobre líneas de texto. ed y ex se escribieron en una época en la que las pantallas de terminal eran poco comunes y muchos terminales eran dispositivos de "teletipo" (TTY). Por lo tanto, era común trabajar a partir de copias impresas del texto, utilizando comandos a través de una interfaz extremadamente concisa (las velocidades de conexión comunes eran 110 baudios, o, aproximadamente, 11 caracteres por segundo, lo que es más lento que un mecanógrafo rápido; los retrasos eran comunes en sesiones interactivas multiusuario; además, a menudo hubo cierta motivación para conservar el papel).

Entonces, la sintaxis de la mayoría de los :comandos incluye una dirección o rango de direcciones (número de línea) seguido de un comando. Naturalmente, uno podría usar números de línea literales: :127,215 s/foo/barpara cambiar la primera aparición de "foo" en "barra" en cada línea entre 127 y 215. También podría usar algunas abreviaturas como .o $para las líneas actuales y últimas respectivamente. También se podrían usar prefijos relativos +y -referirse a las compensaciones después o antes de la línea de curado, respectivamente. Por :.,$jlo tanto: significa "desde la línea actual hasta la última línea, únalas todas en una sola línea". :%es sinónimo de :1,$(todas las líneas).

Los comandos :... gy :... vtienen alguna explicación, ya que son increíblemente poderosos. :... ges un prefijo para "globalmente" aplicar un comando posterior a todas las líneas que coinciden con un patrón (expresión regular) mientras que :... vaplica dicho comando a todas las líneas que NO coinciden con el patrón dado ("v" de "conVerse"). Al igual que con otros comandos ex , estos pueden tener el prefijo direccionamiento / referencias de rango. Por :.,+21g/foo/dlo tanto, significa "eliminar cualquier línea que contenga la cadena" foo "desde la actual hasta las siguientes 21 líneas" mientras que :.,$v/bar/dsignifica "desde aquí hasta el final del archivo, eliminar cualquier línea que NO contenga la cadena" barra ".

Es interesante que el comando grep común de Unix se haya inspirado realmente en este comando ex (y lleva el nombre de la forma en que se documentó). El comando ex:g/re/p (grep) fue la forma en que documentaron cómo "globalmente" "imprimir" líneas que contienen una "expresión regular" (re). Cuando se usaron ed y ex , el :pcomando fue uno de los primeros que alguien aprendió y, a menudo, el primero que se usó al editar cualquier archivo. Fue así como imprimiste el contenido actual (generalmente solo una página llena a la vez usando :.,+25po algo así).

Tenga en cuenta que :% g/.../do (su contraparte reVerse / conVerse: :% v/.../dson los patrones de uso más comunes. Sin embargo, hay otros excomandos que vale la pena recordar:

Podemos usar mpara mover líneas y junir líneas. Por ejemplo, si tiene una lista y desea separar todas las cosas que coinciden (o, por el contrario, NO coinciden con algún patrón) sin eliminarlas, puede usar algo como: :% g/foo/m$... y todas las líneas "foo" se habrán movido a El final del archivo. (Tenga en cuenta el otro consejo sobre el uso del final de su archivo como un espacio de memoria virtual). Esto habrá preservado el orden relativo de todas las líneas "foo" mientras las ha extraído del resto de la lista. (Esto sería equivalente a hacer algo como: 1G!GGmap!Ggrep foo<ENTER>1G:1,'a g/foo'/d(copie el archivo en su propia cola, filtre la cola grepy elimine todas las cosas de la cabeza).

Para unir líneas, generalmente puedo encontrar un patrón para todas las líneas que deben unirse a su predecesor (todas las líneas que comienzan con "^" en lugar de "^ *" en alguna lista de viñetas, por ejemplo). Para ese caso, usaría: :% g/^ /-1j(para cada línea coincidente, sube una línea y únete a ellas). (Por cierto: para listas de viñetas tratando de buscar las líneas de bala y unirse a la siguiente no funciona para un par de razones ... que puede unirse a una línea de bala a otro, y no va a unirse a cualquier línea de bala en todo de sus continuaciones; solo funcionará en parejas en los partidos).

Casi no hace falta mencionar que puede usar nuestro viejo amigo s(sustituto) con los comandos gy v(global / converse-global). Por lo general, no necesita hacerlo. Sin embargo, considere algún caso en el que desee realizar una sustitución solo en líneas que coincidan con otro patrón. A menudo puede usar un patrón complicado con capturas y usar referencias posteriores para preservar las partes de las líneas que NO desea cambiar. Sin embargo, a menudo será más fácil separar la coincidencia de la sustitución: :% g/foo/s/bar/zzz/g- para cada línea que contenga "foo", sustituya todas las "barras" por "zzz". (Algo como:% s/\(.*foo.*\)bar\(.*\)/\1zzz\2/gsolo funcionaría para los casos de instancias de "barra" que fueron PREDEDADAS por "foo" en la misma línea; ya es bastante desgarbado, y habría que destrozarlo más para detectar todos los casos en que "bar" precedió a "foo")

El punto es que no son más que simples p, sy dlíneas en el exconjunto de comandos.

Las :direcciones también pueden referirse a marcas. Por lo tanto, puede usar: :'a,'bg/foo/jpara unir cualquier línea que contenga la cadena foo a su línea posterior, si se encuentra entre las líneas entre las marcas ' a ' y ' b '. (Sí, todos los exejemplos de comandos anteriores se pueden limitar a subconjuntos de las líneas del archivo con el prefijo de este tipo de expresiones de direccionamiento).

Eso es bastante oscuro (solo he usado algo así unas pocas veces en los últimos 15 años). Sin embargo, admitiré libremente que a menudo he hecho cosas de forma iterativa e interactiva que probablemente podrían haberse hecho de manera más eficiente si me hubiera tomado el tiempo para pensar en el encantamiento correcto.

Otro comando vi o ex muy útil es :rleer el contenido de otro archivo. Por lo tanto: :r fooinserta el contenido del archivo llamado "foo" en la línea actual.

Más poderoso es el :r!comando. Esto lee los resultados de un comando. Es lo mismo que suspender la sesión vi , ejecutar un comando, redirigir su salida a un archivo temporal, reanudar su sesión vi y leer el contenido de la temp. archivo.

Aún más potentes son los comandos !(bang) y :... !( ex bang). Estos también ejecutan comandos externos y leen los resultados en el texto actual. Sin embargo, ¡también filtran selecciones de nuestro texto a través del comando! Esto podemos ordenar todas las líneas en nuestro archivo usando 1G!Gsort( Ges el comando vi "goto"; el valor predeterminado es ir a la última línea del archivo, pero puede ir precedido de un número de línea, como 1, la primera línea). Esto es equivalente a la variante ex:1,$!sort . Los escritores a menudo usan !las utilidades fmt o fold de Unix para reformatear o "envolver palabras" selecciones de texto. Una macro muy común es{!}fmt(formatear el párrafo actual). Los programadores a veces lo usan para ejecutar su código, o solo partes de él, a través de sangría u otras herramientas de reformateo de código.

El uso de los comandos :r!y !significa que cualquier utilidad o filtro externo puede tratarse como una extensión de nuestro editor. Ocasionalmente los he usado con scripts que extrajeron datos de una base de datos, o con comandos wget o lynx que extrajeron datos de un sitio web, o comandos ssh que extrajeron datos de sistemas remotos.

Otro comando ex útil es :so(abreviatura de :source). Esto lee el contenido de un archivo como una serie de comandos. Al iniciar vi normalmente, de manera implícita, realiza una :sourcede ~/.exinitrcarchivo (y Vim normalmente lo hace en este ~/.vimrc, como es natural). El uso de esto es que puede cambiar su perfil de editor sobre la marcha simplemente buscando un nuevo conjunto de macros, abreviaturas y configuraciones de editor. Si eres astuto, incluso puedes usar esto como un truco para almacenar secuencias de comandos de edición ex para aplicar a archivos a pedido.

Por ejemplo, tengo un archivo de siete líneas (36 caracteres) que ejecuta un archivo a través de wc e inserta un comentario de estilo C en la parte superior del archivo que contiene los datos de conteo de palabras. Puedo aplicar esa "macro" a un archivo usando un comando como:vim +'so mymacro.ex' ./mytarget

(La +opción de línea de comando para vi y Vim se usa normalmente para iniciar la sesión de edición en un número de línea dado. Sin embargo, es un hecho poco conocido que uno puede seguir +cualquier comando / expresión ex válido , como un comando "fuente" como Lo he hecho aquí; para un ejemplo simple, tengo scripts que invocan: vi +'/foo/d|wq!' ~/.ssh/known_hostspara eliminar una entrada de mi archivo de hosts conocidos de SSH de forma no interactiva mientras estoy volviendo a generar imágenes de un conjunto de servidores).

Por lo general, es mucho más fácil escribir tales "macros" usando Perl, AWK, sed (que, de hecho, es como grep, una utilidad inspirada en el comando ed ).

El @comando es probablemente el comando vi más oscuro . Al enseñar ocasionalmente cursos avanzados de administración de sistemas durante casi una década, he conocido a muy pocas personas que lo hayan usado. @ejecuta el contenido de un registro como si fuera un comando vi o ex .
Ejemplo: a menudo uso: :r!locate ...para encontrar algún archivo en mi sistema y leer su nombre en mi documento. A partir de ahí, elimino cualquier golpe extraño, dejando solo la ruta completa al archivo que me interesa. En lugar de Tabpasar laboriosamente a través de cada componente de la ruta (o peor, si estoy atascado en una máquina sin soporte para completar Tab) en su copia de vi ) solo uso:

1. 0i:r(para convertir la línea actual en un comando válido : r ),
2. "cdd (para eliminar la línea en el registro "c") y
3. @c ejecutar ese comando

Eso es solo 10 pulsaciones de teclas (y la expresión "cdd @ces efectivamente una macro de dedo para mí, por lo que puedo escribirla casi tan rápido como cualquier palabra común de seis letras).

Un pensamiento aleccionador

¡Solo he arañado a la superficie el poder de vi y nada de lo que he descrito aquí es parte de las "mejoras" por las cuales se nombra vim ! Todo lo que he descrito aquí debería funcionar en cualquier copia antigua de vi de hace 20 o 30 años.

Hay personas que han usado considerablemente más poder de vi que yo.

Estás hablando de seleccionar y copiar texto, creo que deberías echarle un vistazo al modo visual de Vim .

En el modo visual, puede seleccionar texto usando los comandos de Vim, luego puede hacer lo que quiera con la selección.

Considere los siguientes escenarios comunes:

Debe seleccionar el siguiente paréntesis coincidente.

Podrías hacerlo:

• v% si el cursor está en el paréntesis inicial / final
• vib si el cursor está dentro del bloque de paréntesis

Desea seleccionar texto entre comillas:

• vi " para comillas dobles
• vi ' para comillas simples

Desea seleccionar un bloque de llaves (muy común en los lenguajes de estilo C):

• viB
• vi{

Desea seleccionar el archivo completo:

• ggVG

La selección del bloque visual es otra característica realmente útil, le permite seleccionar un área rectangular de texto, solo tiene que presionar Ctrl- Vpara iniciarlo, y luego seleccionar el bloque de texto que desee y realizar cualquier tipo de operación como tirar, eliminar, pegar, editar, etc. Es genial editar texto orientado a columnas .

Algunos consejos de productividad:

Movimientos inteligentes

• *y #busque la palabra debajo del cursor hacia adelante / atrás.
• w a la siguiente palabra
• W a la siguiente palabra separada por espacios
• b/ eal comienzo / final de la palabra actual. ( B/ solo Epara espacios separados)
• gg/ Gsaltar al inicio / final del archivo.
• % saltar a la coincidencia {..} o (..), etc.
• {/ }saltar al siguiente párrafo.
• '. volver a la última línea editada.
• g; volver a la última posición editada

Comandos de edición rápida

• I insertar al comienzo.
• A agregar al final.
• o/ Oabrir una nueva línea después / antes de la actual.
• v/ V/ Ctrl+Vmodo visual (para seleccionar texto!)
• Shift+R reemplazar texto
• C cambiar la parte restante de la línea.

Combinando comandos

La mayoría de los comandos aceptan una cantidad y dirección, por ejemplo:

• cW = cambiar hasta el final de la palabra
• 3cW = cambiar 3 palabras
• BcW = al comienzo de la palabra completa, cambie la palabra completa
• ciW = cambiar la palabra interna.
• ci" = cambio interno entre ".."
• ci( = cambiar texto entre (..)
• ci< = cambiar texto entre <..> (necesita set matchpairs+=<:> en vimrc)
• 4dd = eliminar 4 líneas
• 3x = eliminar 3 caracteres.
• 3s = sustituir 3 caracteres.

Comandos útiles del programador

• rreemplazar un carácter (por ejemplo, rdreemplaza el carácter actual cond ).
• ~ Cambia el caso.
• J une dos líneas
• Ctrl + A / Ctrl + X incrementa / disminuye un número.
• . repetir el último comando (una macro simple)
• == sangrado de línea fija
• > bloque de sangría (en modo visual)
• < bloque no sangrado (en modo visual)

Grabación macro

• prensa q[ key ] para comenzar a grabar.
• Luego golpea q para detener la grabación.
• La macro se puede jugar con @[ key ].

Mediante el uso de comandos y movimientos muy específicos, VIM puede reproducir esas acciones exactas para las siguientes líneas. (p. ej., A para agregar al final, b/e para mover el cursor al principio o al final de una palabra, respectivamente)

Ejemplo de configuraciones bien construidas

# reset to vim-defaults
if &compatible          # only if not set before:
  set nocompatible      # use vim-defaults instead of vi-defaults (easier, more user friendly)
endif

# display settings
set background=dark     # enable for dark terminals
set nowrap              # dont wrap lines
set scrolloff=2         # 2 lines above/below cursor when scrolling
set number              # show line numbers
set showmatch           # show matching bracket (briefly jump)
set showmode            # show mode in status bar (insert/replace/...)
set showcmd             # show typed command in status bar
set ruler               # show cursor position in status bar
set title               # show file in titlebar
set wildmenu            # completion with menu
set wildignore=*.o,*.obj,*.bak,*.exe,*.py[co],*.swp,*~,*.pyc,.svn
set laststatus=2        # use 2 lines for the status bar
set matchtime=2         # show matching bracket for 0.2 seconds
set matchpairs+=<:>     # specially for html

# editor settings
set esckeys             # map missed escape sequences (enables keypad keys)
set ignorecase          # case insensitive searching
set smartcase           # but become case sensitive if you type uppercase characters
set smartindent         # smart auto indenting
set smarttab            # smart tab handling for indenting
set magic               # change the way backslashes are used in search patterns
set bs=indent,eol,start # Allow backspacing over everything in insert mode

set tabstop=4           # number of spaces a tab counts for
set shiftwidth=4        # spaces for autoindents
#set expandtab           # turn a tabs into spaces

set fileformat=unix     # file mode is unix
#set fileformats=unix,dos    # only detect unix file format, displays that ^M with dos files

# system settings
set lazyredraw          # no redraws in macros
set confirm             # get a dialog when :q, :w, or :wq fails
set nobackup            # no backup~ files.
set viminfo='20,\"500   # remember copy registers after quitting in the .viminfo file -- 20 jump links, regs up to 500 lines'
set hidden              # remember undo after quitting
set history=50          # keep 50 lines of command history
set mouse=v             # use mouse in visual mode (not normal,insert,command,help mode


# color settings (if terminal/gui supports it)
if &t_Co > 2 || has("gui_running")
  syntax on          # enable colors
  set hlsearch       # highlight search (very useful!)
  set incsearch      # search incremently (search while typing)
endif

# paste mode toggle (needed when using autoindent/smartindent)
map <F10> :set paste<CR>
map <F11> :set nopaste<CR>
imap <F10> <C-O>:set paste<CR>
imap <F11> <nop>
set pastetoggle=<F11>

# Use of the filetype plugins, auto completion and indentation support
filetype plugin indent on

# file type specific settings
if has("autocmd")
  # For debugging
  #set verbose=9

  # if bash is sh.
  let bash_is_sh=1

  # change to directory of current file automatically
  autocmd BufEnter * lcd %:p:h

  # Put these in an autocmd group, so that we can delete them easily.
  augroup mysettings
    au FileType xslt,xml,css,html,xhtml,javascript,sh,config,c,cpp,docbook set smartindent shiftwidth=2 softtabstop=2 expandtab
    au FileType tex set wrap shiftwidth=2 softtabstop=2 expandtab

    # Confirm to PEP8
    au FileType python set tabstop=4 softtabstop=4 expandtab shiftwidth=4 cinwords=if,elif,else,for,while,try,except,finally,def,class
  augroup END

  augroup perl
    # reset (disable previous 'augroup perl' settings)
    au!  

    au BufReadPre,BufNewFile
    \ *.pl,*.pm
    \ set formatoptions=croq smartindent shiftwidth=2 softtabstop=2 cindent cinkeys='0{,0},!^F,o,O,e' " tags=./tags,tags,~/devel/tags,~/devel/C
    # formatoption:
    #   t - wrap text using textwidth
    #   c - wrap comments using textwidth (and auto insert comment leader)
    #   r - auto insert comment leader when pressing <return> in insert mode
    #   o - auto insert comment leader when pressing 'o' or 'O'.
    #   q - allow formatting of comments with "gq"
    #   a - auto formatting for paragraphs
    #   n - auto wrap numbered lists
    #   
  augroup END


  # Always jump to the last known cursor position. 
  # Don't do it when the position is invalid or when inside
  # an event handler (happens when dropping a file on gvim). 
  autocmd BufReadPost * 
    \ if line("'\"") > 0 && line("'\"") <= line("$") | 
    \   exe "normal g`\"" | 
    \ endif 

endif # has("autocmd")

La configuración puede almacenarse en todo el ~/.vimrcsistema /etc/vimrc.localy luego leerse desde el /etc/vimrcarchivo usando:

source /etc/vimrc.local

(tendrá que reemplazar el #carácter de comentario con "para que funcione en VIM, quería dar un resaltado de sintaxis adecuado aquí).

Los comandos que he enumerado aquí son bastante básicos, y los principales que uso hasta ahora. Ya me hacen más productivo, sin tener que saber todas las cosas elegantes.

El mecanismo Control+ Res muy útil :-) En el modo de inserción o en el modo de comando (es decir, en la :línea al escribir comandos), continúe con un registro numerado o con nombre:

• a - z los registros nombrados
• " el registro sin nombre, que contiene el texto de la última eliminación o extracción
  
• % el nombre del archivo actual
  
• # el nombre de archivo alternativo
  
• * el contenido del portapapeles (X11: selección primaria)
  
• + el contenido del portapapeles
  
• / el último patrón de búsqueda
  
• : la última línea de comando
  
• . el último texto insertado
  
• - la última eliminación pequeña (menos de una línea)
  
• =5*5 inserte 25 en el texto (mini calculadora)

Ver :help i_CTRL-Ry :help c_CTRL-Rpara más detalles, y husmear cerca para obtener más bondad CTRL-R.

Vim Plugins

Aquí hay muchas buenas respuestas, y una sorprendente sobre el zen de vi. Una cosa que no veo mencionada es que vim es extremadamente extensible a través de complementos. Hay scripts y complementos para que haga todo tipo de locuras que el autor original nunca consideró. Aquí hay algunos ejemplos de complementos vim increíblemente útiles:

rails.vim

Rails.vim es un complemento escrito por tpope. Es una herramienta increíble para las personas que desarrollan rieles. Hace cosas mágicas sensibles al contexto que le permiten saltar fácilmente de un método en un controlador a la vista asociada, a un modelo y hasta pruebas unitarias para ese modelo. Ha ahorrado docenas, si no cientos de horas, como desarrollador de rieles.

gist.vim

Este complemento le permite seleccionar una región de texto en modo visual y escribir un comando rápido para publicarlo en gist.github.com . Esto permite un fácil acceso a Pastebin, que es increíblemente útil si estás colaborando con alguien a través de IRC o IM.

space.vim

Este complemento proporciona una funcionalidad especial a la barra espaciadora. Convierte la barra espaciadora en algo análogo al período, pero en lugar de repetir acciones, repite movimientos. Esto puede ser muy útil para moverse rápidamente a través de un archivo de la manera que usted defina sobre la marcha.

surround.vim

Este complemento le brinda la capacidad de trabajar con texto delimitado de alguna manera. Le da objetos que denotan cosas dentro de parens, cosas dentro de comillas, etc. Puede ser útil para manipular texto delimitado.

supertab.vim

Este script trae una funcionalidad de finalización de pestañas elegante a vim El material de autocompletar ya está allí en el núcleo de vim, pero esto lo lleva a una pestaña rápida en lugar de múltiples accesos directos diferentes. Muy práctico e increíblemente divertido de usar. Si bien no es la inteligencia de VS, es un gran paso y ofrece una gran cantidad de la funcionalidad que le gustaría esperar de una herramienta de finalización de pestañas.

syntastic.vim

Esta herramienta trae comandos externos de verificación de sintaxis a vim. No lo he usado personalmente, pero he escuchado grandes cosas al respecto y el concepto es difícil de superar. Verificar la sintaxis sin tener que hacerlo manualmente es un gran ahorro de tiempo y puede ayudarlo a detectar errores sintácticos a medida que los presenta, en lugar de cuando finalmente se detiene para probar.

fugitivo.vim

Acceso directo a git desde el interior de vim. Nuevamente, no he usado este complemento, pero puedo ver la utilidad. Desafortunadamente, estoy en una cultura donde svn se considera "nuevo", por lo que es probable que no vea a git en el trabajo por bastante tiempo.

nerdtree.vim

Un navegador de árbol para vim. Empecé a usar esto recientemente, y es realmente útil. Le permite colocar una vista de árbol en una división vertical y abrir archivos fácilmente. Esto es ideal para un proyecto con muchos archivos fuente entre los que saltas con frecuencia.

FuzzyFinderTextmate.vim

Este es un complemento no mantenido, pero sigue siendo increíblemente útil. Proporciona la capacidad de abrir archivos usando una sintaxis descriptiva "difusa". Significa que en un árbol escaso de archivos solo necesita escribir suficientes caracteres para desambiguar los archivos que le interesan del resto de la muesca.

Conclusión

Hay muchas herramientas increíbles disponibles para vim. Estoy seguro de que solo he arañado la superficie aquí, y vale la pena buscar herramientas aplicables a su dominio. La combinación del poderoso conjunto de herramientas tradicionales de vi, las mejoras de vim y los complementos que extienden vim aún más, es una de las formas más poderosas para editar texto jamás concebido. Vim es fácilmente tan poderoso como emacs, eclipse, visual studio y textmate.

Gracias

Gracias a duwanis por sus configuraciones vim de las cuales aprendí mucho y tomé prestados la mayoría de los complementos listados aquí.

. Repita el último comando de cambio de texto

Ahorro mucho tiempo con este.

El modo visual se mencionó anteriormente, pero el modo visual de bloque me ha ahorrado mucho tiempo al editar columnas de tamaño fijo en un archivo de texto. (Accedido con Ctrl-V).

soldado americano

Vaya a la última ubicación editada (muy útil si realizó alguna búsqueda y luego desea volver a editar)

^ P y ^ N

Complete el texto anterior (^ P) o siguiente (^ N).

^ O y ^ I

Ir a la ubicación anterior ( ^O- "O"para la anterior) o a la siguiente ( ^I- "I"cerca de "O"). Cuando realiza búsquedas, edita archivos, etc., puede navegar a través de estos "saltos" hacia adelante y hacia atrás.

Recientemente descubrí este sitio: http://vimcasts.org/

Es bastante nuevo y realmente muy bueno. El tipo que está ejecutando el sitio cambió de textmate a vim y presenta elenco muy bueno y conciso sobre temas específicos de vim. ¡Echale un vistazo!

CTRL+A incrementa el número en el que estás parado.

Todo en modo Normal:

f <char> para pasar a la siguiente instancia de un personaje en particular en la línea actual, y ; repetir.

F <char> para pasar a la instancia anterior de un personaje en particular en la línea actual y ; repetir.

Si se usa de manera inteligente, los dos anteriores pueden hacer que te muevas rápidamente en una línea.

* en una palabra para buscar la siguiente instancia.

# en una palabra para buscar la instancia anterior.

Sesión

a. guardar la sesión

: mks nombre de sesión

si. forzar guardar sesión

: mks! nombre de sesión

C. sesión de carga

gvim o vim -S nombre de sesión

Sumar y restar

a. Sumar y restar

CTRL-A; Agregue [cuenta] al número o carácter alfabético en o después del cursor. {no en Vi

CTRL-X; Restar [cuenta] del número o carácter alfabético en o después del cursor. {no en Vi}

si. Desasignación de teclas de ventana

En la ventana, Ctrl-A ya está mapeado para la selección de todo el archivo que debe desasignar en el archivo rc. marque la parte de mapeo CTRL-A de mswin.vim como comentario o agregue su archivo rc con unmap

C. Con macro

El comando CTRL-A es muy útil en una macro. Ejemplo: utilice los siguientes pasos para hacer una lista numerada.

1. Cree la primera entrada de la lista, asegúrese de que comience con un número.
2. qa - comienza a grabar en el búfer 'a'
3. Y: tira de la entrada
4. p - ponga una copia de la entrada debajo de la primera
5. CTRL-A - incrementa el número
6. q - detener la grabación
7. @a - repite los tiempos de tirar, poner e incrementar

La semana pasada en el trabajo, nuestro proyecto heredó mucho código Python de otro proyecto. Desafortunadamente, el código no se ajustaba a nuestra arquitectura existente: todo se hizo con variables y funciones globales, que no funcionarían en un entorno de subprocesos múltiples.

Teníamos ~ 80 archivos que debían modificarse para orientarlos a objetos: todas las funciones se movían a clases, los parámetros cambiaban, se agregaban declaraciones de importación, etc. Teníamos una lista de aproximadamente 20 tipos de arreglos que debían hacerse en cada archivo. Yo estimaría que hacerlo a mano, una persona podría hacer de 2 a 4 por día.

Así que hice el primero a mano y luego escribí un script vim para automatizar los cambios. La mayor parte era una lista de comandos vim, por ejemplo

" delete an un-needed function "
g/someFunction(/ d

" add wibble parameter to function foo "
%s/foo(/foo( wibble,/

" convert all function calls bar(thing) into method calls thing.bar() "
g/bar(/ normal nmaf(ldi(`aPa.

El último merece un poco de explicación:

g/bar(/  executes the following command on every line that contains "bar("
normal   execute the following text as if it was typed in in normal mode
n        goes to the next match of "bar(" (since the :g command leaves the cursor position at the start of the line)
ma       saves the cursor position in mark a
f(       moves forward to the next opening bracket
l        moves right one character, so the cursor is now inside the brackets
di(      delete all the text inside the brackets
`a       go back to the position saved as mark a (i.e. the first character of "bar")
P        paste the deleted text before the current cursor position
a.       go into insert mode and add a "." 

Para un par de transformaciones más complejas, como la generación de todas las declaraciones de importación, incrusté algo de Python en el script vim.

Después de algunas horas de trabajo, tenía un script que haría al menos el 95% de la conversión. Acabo de abrir un archivo en vim, luego ejecuto :source fixit.vimy el archivo se transforma en un abrir y cerrar de ojos.

Todavía tenemos el trabajo de cambiar el 5% restante que no valía la pena automatizar y probar los resultados, pero al pasar un día escribiendo este script, calculo que hemos ahorrado semanas de trabajo.

Por supuesto, habría sido posible automatizar esto con un lenguaje de script como Python o Ruby, pero habría tardado mucho más en escribir y sería menos flexible; el último ejemplo habría sido difícil ya que la expresión regular por sí sola no sería capaz de manejar paréntesis anidados, p. ej. para convertir bar(foo(xxx))a foo(xxx).bar(). Vim fue perfecto para la tarea.

¡Utiliza el explorador de archivos integrado! El comando es :Explorey le permite navegar a través de su código fuente muy, muy rápido. Tengo estos mapas en mi .vimrc:

map <silent> <F8>   :Explore<CR>
map <silent> <S-F8> :sp +Explore<CR>

El explorador también le permite realizar modificaciones en los archivos. Publicaré algunas de mis teclas favoritas, presionar <F1>le dará la lista completa:

• - : Lo más útil: Cambiar al directorio superior ( cd ..)
• mf : marcar un archivo
• D : elimine los archivos marcados o el archivo en el que está el cursor, si no hay nada marcado.
• R : Cambie el nombre del archivo en el que está el cursor.
• d : crear un nuevo directorio en el directorio actual
• % : Crea un nuevo archivo en el directorio actual

Soy miembro de la American Cryptogram Association. La revista bimestral incluye más de 100 criptogramas de varios tipos. Aproximadamente 15 de estos son "criptaritmos", varios tipos de problemas aritméticos con letras sustituidas por los dígitos. Dos o tres de estos son sudokus, excepto con letras en lugar de números. Cuando se completa la cuadrícula, las nueve letras distintas deletrearán una palabra o palabras, en alguna línea, diagonal, espiral, etc., en algún lugar de la cuadrícula.

En lugar de trabajar con lápiz o escribir los problemas a mano, descargo los problemas del área de miembros de su sitio web.

Cuando trabajo con estos sudokus, uso vi, simplemente porque estoy usando las instalaciones que tiene vi que pocos otros editores tienen. Principalmente al convertir la cuadrícula con letras en una cuadrícula numerada, porque me resulta más fácil de resolver, y luego la cuadrícula numerada completa de nuevo en la cuadrícula con letras para encontrar la palabra o palabras de solución.

El problema está formateado como nueve grupos de nueve letras, con -s representando los espacios en blanco, escritos en dos líneas. El primer paso es formatearlos en nueve líneas de nueve caracteres cada una. No hay nada especial en esto, solo inserta ocho saltos de línea en los lugares apropiados.

El resultado se verá así:

T-O-----C
-E-----S-
--AT--N-L
---NASO--
---E-T---
--SPCL---
E-T--OS--
-A-----P-
S-----C-T

Entonces, el primer paso para convertir esto en números es hacer una lista de las letras distintas. Primero, hago una copia del bloque. Coloco el cursor en la parte superior del bloque y luego escribo :y}}p. :me pone en modo comando, ytira del siguiente comando de movimiento. Como }es un movimiento al final del siguiente párrafo, y}tira del párrafo. }luego mueve el cursor al final del párrafo y ppega lo que habíamos arrancado justo después del cursor. Entonces y}}pcrea una copia del siguiente párrafo y termina con el cursor entre las dos copias.

A continuación, debo convertir una de esas copias en una lista de letras distintas. Ese comando es un poco más complejo:

:!}tr -cd A-Z | sed 's/\(.\)/\1\n/g' | sort -u | tr -d '\n'

:nuevamente me pone en modo comando. !indica que el contenido del próximo tirón debe canalizarse a través de una línea de comando. }tira del siguiente párrafo, y la línea de comando luego usa el trcomando para eliminar todo excepto las letras mayúsculas, el sedcomando para imprimir cada letra en una sola línea y el sortcomando para ordenar esas líneas, eliminar duplicados y luego treliminar las nuevas líneas, dejando las nueve letras distintas en una sola línea, reemplazando las nueve líneas que habían formado el párrafo originalmente. En este caso, las letras son: ACELNOPST.

El siguiente paso es hacer otra copia de la cuadrícula. Y luego utilizar las cartas que hemos identificado simplemente para reemplazar cada una de esas cartas con un dígito del 1 al 9. Eso es simple: :!}tr ACELNOPST 0-9. El resultado es:

8-5-----1
-2-----7-
--08--4-3
---4075--
---2-8---
--7613---
2-8--57--
-0-----6-
7-----1-8

Esto puede resolverse de la manera habitual o ingresarse en cualquier solucionador de sudoku que prefiera. La solución completa se puede volver a convertir en letras con :!}tr 1-9 ACELNOPST.

Hay poder en vi que es igualado por muy pocos. El mayor problema es que solo unos pocos libros de tutoriales vi, sitios web, archivos de ayuda, etc., hacen más que apenas tocar la superficie de lo que es posible.

Manipulaciones de texto a granel!

Ya sea a través de macros:

• Comience con la grabación: qq
• Hacer cosas
• Para de grabar: q
• Repita: @q(la primera vez), @@después de eso.
• Repite 20 veces: 20@@

O a través de expresiones regulares:

• Reemplazar cosas: :%s/[fo]+/bar/g

(Pero ten cuidado: si haces lo último, tendrás 2 problemas :).)

Hace poco descubrí q:. Abre la "ventana de comandos" y muestra sus comandos ex-mode (modo comando) más recientes. Puede moverse como de costumbre dentro de la ventana y presionar <CR>ejecuta el comando. Puedes editar, etc. también. No tiene precio cuando está jugando con algún comando complejo o expresión regular y no desea volver a escribir todo el asunto, o si lo complejo que desea hacer es devolver 3 comandos. Es casi como bash set -o vi, pero para vim en sí (¡je!).

Vea :help q:más partes interesantes para ir y venir.

Acabo de descubrir el omnicompletion de Vim el otro día, y aunque admitiré que estoy un poco confuso en lo que hace, he tenido resultados sorprendentemente buenos simplemente combinando Ctrl+ x Ctrl+ uo Ctrl+ n/ Ctrl+ pen modo de inserción. No es del todo IntelliSense , pero todavía lo estoy aprendiendo.

¡Pruébalo! :help ins-completion

Estos no son atajos, pero están relacionados:

1. Haga de mayúsculas un ESC adicional (o Ctrl)
2. asigna el líder a "," (coma), con este comando: let mapleader = ","

Aumentan mi productividad.

Otro útil "atajo" vi que uso con frecuencia es 'xp'. Esto cambiará el carácter debajo del cursor con el siguiente carácter.

<Ctrl> + W, V para dividir la pantalla verticalmente
<Ctrl> + W, W para cambiar entre las ventanas

! python% [args] para ejecutar el script que estoy editando en esta ventana

ZF en modo visual para doblar líneas arbitrarias

Modo visual

Como han dicho otras personas, el modo visual es la respuesta a su problema de copiar / cortar y pegar. Vim te da 'v', 'V' y Cv. Minúscula 'v' en vim es esencialmente la misma que la tecla shift en el bloc de notas. Lo bueno es que no tienes que mantenerlo presionado. Puede usar cualquier técnica de movimiento para navegar de manera eficiente al punto inicial (o final) de su selección. Luego presione 'v', y use técnicas de movimiento eficientes nuevamente para navegar al otro extremo de su selección. Entonces 'd' o 'y' le permite cortar o copiar esa selección.

La ventaja que tiene el modo visual de vim sobre la descripción de Jim Dennis de cortar / copiar / pegar en vi es que no tiene que obtener la ubicación correcta. A veces es más eficiente usar un movimiento rápido para llegar a la vecindad general de donde quieres ir y luego refinarlo con otros movimientos que pensar en un comando de movimiento único más complejo que te lleve exactamente a donde quieres ir.

La desventaja de usar el modo visual ampliamente de esta manera es que puede convertirse en una muleta que usa todo el tiempo, lo que le impide aprender nuevos comandos vi (m) que le permitirán hacer las cosas de manera más eficiente. Sin embargo, si eres muy proactivo para aprender nuevos aspectos de vi (m), entonces esto probablemente no te afectará mucho.

También volveré a enfatizar que la línea visual y los modos de bloqueo visual le brindan variaciones sobre este mismo tema que pueden ser muy poderosas ... especialmente el modo de bloque visual.

Sobre el uso eficiente del teclado

También estoy en desacuerdo con su afirmación de que alternar las manos es la forma más rápida de usar el teclado. Tiene un elemento de verdad en él. Hablando de manera muy general, el uso repetido de la misma cosa es lento. El ejemplo más significativo de este principio es que las pulsaciones de teclas consecutivas escritas con el mismo dedo son muy lentas. Su afirmación probablemente se deriva de la tendencia natural a usar la transformación s / finger / hand / en este patrón. Hasta cierto punto es correcto, pero en el extremo extremadamente alto del espectro de eficiencia es incorrecto.

Solo pregúntale a cualquier pianista. Pregúnteles si es más rápido tocar una sucesión de algunas notas alternando manos o usando dedos consecutivos de una sola mano en secuencia. La forma más rápida de escribir 4 pulsaciones de teclas no es alternar manos, sino escribirlas con 4 dedos de la misma mano en orden ascendente o descendente (llame a esto una "carrera"). Esto debería ser evidente una vez que haya considerado esta posibilidad.

El problema más difícil es la optimización para esto. Es bastante fácil de optimizar para la distancia absoluta en el teclado. Vim hace eso. Es mucho más difícil de optimizar en el nivel de "ejecución", pero vi (m) con su edición modal le brinda una mejor oportunidad de poder hacerlo que cualquier enfoque no modal (ejem, emacs).

En Emacs

Para que los fanáticos de emacs ignoren completamente mi publicación completa debido a ese último comentario entre paréntesis, creo que debo describir la raíz de la diferencia entre las religiones emacs y vim. Nunca he hablado en las guerras de los editores y probablemente no lo volveré a hacer, pero nunca escuché a nadie describir las diferencias de esta manera, así que aquí va. La diferencia es la siguiente compensación:

Vim le brinda una eficiencia de edición de texto sin procesar sin igual Emacs le brinda una capacidad sin igual para personalizar y programar el editor

Los fanáticos ciegos de vim afirmarán que vim tiene un lenguaje de script. Pero es un lenguaje oscuro y ad-hoc diseñado para servir al editor. Emacs tiene Lisp! Basta de charla. Si no aprecia la importancia de esas dos últimas oraciones o desea aprender lo suficiente sobre programación funcional y Lisp para desarrollar esa apreciación, entonces debe usar vim.

Los fanáticos de emacs afirmarán que emacs tiene el modo viper, por lo que es un superconjunto de vim. Pero el modo víbora no es estándar. Tengo entendido que el modo viper no es utilizado por la mayoría de los usuarios de emacs. Como no es el valor predeterminado, la mayoría de los usuarios de emacs probablemente no desarrollen una verdadera apreciación de los beneficios del paradigma modal.

En mi opinión, estas diferencias son ortogonales. Creo que los beneficios de vim y emacs como los he declarado son válidos. Esto significa que el último editor aún no existe. Probablemente sea cierto que emacs sería la plataforma más fácil en la que basar el editor final. Pero la edición modal no está arraigada en la mentalidad de emacs. La comunidad emacs podría moverse de esa manera en el futuro, pero eso no parece muy probable.

Entonces, si desea una eficiencia de edición sin procesar, use vim. Si desea el mejor entorno para crear secuencias de comandos y programar su editor, use emacs. Si desea alguno de los dos con énfasis en la capacidad de programación, use emacs con modo viper (o programe su propio modo). Si quieres lo mejor de ambos mundos, no tienes suerte por ahora.

Pase 30 minutos haciendo el tutorial de vim (ejecute vimtutor en lugar de vim en la terminal). Aprenderá los movimientos básicos y algunas pulsaciones de teclas, esto lo hará al menos tan productivo con vim como con el editor de texto que utilizó anteriormente. Después de eso, bueno, lea la respuesta de Jim Dennis nuevamente :)

¿Cuál es la forma en que usa Vim que lo hace más productivo que con un editor contemporáneo?

Ser capaz de ejecutar ediciones complejas y repetitivas con muy pocas pulsaciones de teclas (a menudo utilizando macros ). ¡Eche un vistazo a VimGolf para presenciar el poder de Vim!

Después de más de diez años de uso casi diario, es difícil imaginar usar cualquier otro editor.

Use \cen cualquier lugar de una búsqueda para ignorar mayúsculas y minúsculas (anulando su configuración de ignorar caso o caso inteligente). Por ejemplo, /\cfooo /foo\ccoincidirá foo, Foo, fOO, FOO, etc.

Use \Cen cualquier lugar de una búsqueda para forzar la coincidencia de mayúsculas y minúsculas. Por ejemplo, /\Cfooo /foo\Csolo coincidirá con foo.

Me sorprendió encontrar que nadie mencionara el tmovimiento. Con frecuencia lo uso con listas de parámetros en forma de dt,oyt,

Extraño, nadie ha mencionado las etiquetas. Descargue "etiquetas exuberantes" y colóquelo delante de la versión preinstalada que ya tiene en su ruta de búsqueda. Cd a la raíz de lo que sea que estés trabajando; por ejemplo la distribución del kernel de Android. Escriba "ctags -R". para crear un índice de archivos de origen en cualquier lugar debajo de ese directorio en un archivo llamado "etiquetas". Esto contiene todas las etiquetas, nomatter el idioma ni en qué parte del directorio, en un archivo, por lo que el trabajo en varios idiomas es fácil.

Luego abra vim en esa carpeta y lea: help ctags para algunos comandos. Algunas que uso a menudo:

• Coloque el cursor en una llamada al método y escriba CTRL-] para ir a la definición del método.

• Escriba: ta name para ir a la definición de nombre.

Sangría automática:

gg(ir al inicio del documento)
=(tiempo de sangría)
shift-g(ir al final del documento)

Necesitará 'sangría de plugin de tipo de archivo' en su .vimrcarchivo, y probablemente la configuración apropiada de 'shiftwidth' y 'expandtab'.

Preguntaste sobre atajos productivos, pero creo que tu verdadera pregunta es: ¿Vale la pena vim? La respuesta a esta pregunta de stackoverflow es -> "Sí"

Debes haber notado dos cosas. Vim es poderoso, y vim es difícil de aprender. Gran parte de su poder radica en su capacidad de expansión y una combinación interminable de comandos. No te sientas abrumado. Ve lento. Un comando, un complemento a la vez. No te excedas.

Toda esa inversión que pones en vim pagará mil veces. Vas a estar dentro de un editor de texto por muchas, muchas horas antes de morir. Vim será tu compañero.

Múltiples buffers, y en particular saltos rápidos entre ellos para comparar dos archivos con :bpy :bn(correctamente reasignados a un solo Shift+ po Shift+ n)

vimdiff modo (se divide en dos buffers verticales, con colores para mostrar las diferencias)

Copia de área con Ctrl+v

Y, por último, la finalización de tabulación de los identificadores (busque "mosh_tab_or_complete"). Eso es un cambio de vida.

De acuerdo con el cartel superior: el : r! El comando es muy útil.

Muy a menudo lo uso para "pegar" cosas:

:r!cat
**Ctrl-V to paste from the OS clipboard**
^D

De esta manera no tengo que jugar :set paste.