Primeros pasos
Modos y movimiento básico
Vim es modal — los distintos modos cumplen funciones distintas. Esc vuelve al modo Normal desde cualquier otro modo. Las teclas hjkl mantienen tus manos en la fila base. w/b mueven por palabra, 0/$ van a los límites de la línea, gg/G saltan al inicio/fin del archivo, :N salta a la línea N.
# Vim Modes
# Normal mode (Esc) - default, for navigation
# Insert mode (i) - for typing text
# Visual mode (v) - for selecting text
# Command mode (:) - for Ex commands
# Basic movement (Normal mode)
h # left
j # down
k # up
l # right
w # next word start
b # previous word start
0 # beginning of line
$ # end of line
gg # first line
G # last line
:42 # go to line 42Salir y guardar
ZZ y ZQ son las formas más rápidas de salir — no requieren llegar a los dos puntos. :x solo escribe si el archivo cambió (conserva el mtime), a diferencia de :wq que siempre escribe. :w! ignora los flags de solo lectura si los permisos del sistema de archivos lo permiten. Usa :qa! para salir de múltiples buffers modificados.
:w # write (save) file
:w! # force write (override read-only)
:q # quit
:q! # force quit (discard changes)
:wq # write and quit
:x # write only if changed, then quit
ZZ # same as :x (write if changed, quit)
ZQ # quit without saving (like :q!)
:w newfile.txt # save as new file
:sav newfile.txt # save as new file and switch to it
:wa # write all buffers
:xa # write all changed buffers and exit
:qa! # force quit all (discard everything)Sistema de ayuda
La ayuda de Vim es completa e hipervinculada. Ctrl-] sigue una etiqueta (enlace) y Ctrl-T vuelve atrás. Notación de la ayuda: i_CTRL-N significa Ctrl-N en modo insert, 'number' (con comillas) es una opción. :helpgrep busca en la totalidad de los archivos de ayuda a la vez — usa :cn/:cp para navegar las coincidencias. K invoca man para la palabra bajo el cursor (configurable con 'keywordprg').
:help # main help
:help subject # help on subject (e.g. :help insert)
:help i_CTRL-N # help on Ctrl-N in insert mode
:help 'number' # help on the 'number' option (quotes)
:helpgrep pattern # search all help files for pattern
:cn / :cp # next/prev helpgrep match
K # man page for word under cursor (Normal mode)
Ctrl-] # jump to tag under cursor (follow link)
Ctrl-T # jump back from tag (pop tag stack)
:helptags ~/.vim/doc # regenerate help tags for a doc directoryMovimiento por palabras y caracteres
Los movimientos en minúscula (w/b/e) tratan la puntuación como separadores de palabras — útil para código. Los movimientos en mayúscula (W/B/E) solo tratan los espacios como separadores — útil para prosa. e/E mueven al final de la palabra siguiente; ge/gE al final de la palabra anterior (poco usados pero prácticos).
# Word motions (punctuation-aware)
w # next word start
b # previous word start
e # end of next word
ge # end of previous word
# WORD motions (whitespace-only delimiters, uppercase)
W # next WORD start
B # previous WORD start
E # end of next WORD
gE # end of previous WORD
# Word boundaries:
# word: sequence of word-characters OR sequence of punctuation
# WORD: anything separated by whitespace
# Examples (cursor on 'a' in "foo.bar baz"):
# w -> 'bar' (punctuation splits words)
# W -> 'baz' (only whitespace splits WORDS)Movimiento por líneas
0 y $ van al inicio/fin absoluto de la línea (incluidos los espacios). ^ y g_ saltan los espacios del principio/fin — normalmente lo que quieres. Con 'wrap' activado, g0/g$ operan sobre líneas de pantalla mientras 0/$ operan sobre líneas lógicas. | salta a un número de columna concreto.
0 # first column (absolute start)
^ # first non-blank character
$ # end of line (last character)
g_ # last non-blank character
g0 # start of screen line (with wrap)
g$ # end of screen line (with wrap)
gm # middle of screen line
gM # middle of text line
| # column N (e.g. 10| = column 10)
+ # first non-blank of next line
- # first non-blank of previous line
_ # first non-blank of current line [count down]Movimiento por archivo y pantalla
H/M/L saltan dentro de la pantalla visible. Ctrl-d/u desplazan media página (menos desorientador que la página completa de Ctrl-f/b). zz/zt/zb llevan la línea actual al centro/arriba/abajo de la pantalla sin mover el cursor — sumamente útil para conservar el contexto mientras editas. N% salta a un porcentaje del archivo.
gg # go to first line
G # go to last line
Ngg / NG # go to line N (e.g. 50gg or 50G)
:N # go to line N (Ex command)
H # top of screen (High)
M # middle of screen
L # bottom of screen (Low)
N% # jump to N% of the file
Ctrl-f # scroll forward (full page)
Ctrl-b # scroll backward (full page)
Ctrl-d # scroll down (half page)
Ctrl-u # scroll up (half page)
zz # scroll current line to middle
zt # scroll current line to top
zb # scroll current line to bottomInsertar texto
Inserción básica (i, I)
i/I insertan antes del cursor / al inicio de la línea. a/A insertan después del cursor / al final de la línea. gi vuelve a la última posición de inserción (marca '^) — práctico cuando sales con Esc para hacer algo y quieres seguir escribiendo. gI va a la columna 1 absoluta, ignorando los espacios iniciales.
i # insert before cursor
I # insert at first non-blank (same as ^i)
gi # insert at last insert position (also sets mark)
gI # insert at column 1 (same as 0i)
a # insert after cursor
A # insert at end of line (same as $a)
# Examples:
# foo|bar + i -> foo|bar (cursor stays, type before)
# foo|bar + I -> |foobar (cursor at first non-blank)
# foo|bar + A -> foobar| (cursor at end)
# gi returns to where you last left insert mode —
# very useful after escaping to run a Normal-mode command.Abrir líneas nuevas (o, O)
o y O abren una línea nueva debajo/encima del cursor y entran en modo insert. Son la forma más rápida de añadir una línea — sin necesidad de colocar el cursor al final. La indentación se copia automáticamente de las líneas cercanas (controlada por 'autoindent').
o # open new line BELOW cursor, enter insert
O # open new line ABOVE cursor, enter insert
# Before (cursor on middle line):
# line one
# li|ne two
# line three
# After 'o':
# line one
# line two
# | <- new blank line, insert mode
# line three
# After 'O':
# line one
# | <- new blank line, insert mode
# line two
# line threeComandos de cambio (c, C, s, S)
c{motion} borra el objetivo del movimiento y entra en modo insert — el comando de edición más flexible. C es c$ (cambiar hasta el final de la línea), S es cc (cambiar la línea entera). s borra un carácter y entra en insert; combínalo con conteos como 3s. ciw/caw usan text objects (ver sección dedicada).
cw / ce # change to end of word
cb # change backward to word start
c$ / C # change to end of line
cc / S # change entire line
c0 # change to beginning of line
c^ # change to first non-blank
ct, # change up to (but not including) next ','
cfx # change up to and including next 'x'
ciw # change inner word (no surrounding whitespace)
caw # change a word (with surrounding whitespace)
cap # change around paragraph
s # substitute: delete char under cursor, insert
S # substitute: delete entire line, insert (like cc)Modo replace (r, R, gr)
r reemplaza un único carácter y vuelve al modo Normal de inmediato (sin cambio de modo). R entra en modo Replace, donde al escribir se sobrescriben caracteres — Backspace los restaura, a diferencia del modo Insert que simplemente borra. Usa gr/gR (virtual replace) al trabajar con tabulaciones — preserva la alineación de las tabulaciones en lugar de desplazar el texto.
r{x} # replace single char under cursor with x
gr{x} # virtual replace (doesn't shift tabs)
R # enter Replace mode (overwrite until Esc)
gR # virtual Replace mode (tabs stay aligned)
3r{x} # replace 3 chars with x (single char only)
# In Replace mode, typing overwrites existing text
# but Backspace restores the original characters.
# Tabs are preserved with virtual replace (gr/gR).
# Examples:
# abc|def + rx -> abc|xef (cursor advances)
# abc|def + R -> enter Replace mode
# type 'XYZ' -> abcXYZ|f
# Backspace -> abcXY|def (original restored)Inserciones especiales
:r !cmd inserta la salida de un comando de shell en el buffer — genial para pegar salidas de comandos, fechas, listados de archivos. En modo insert, Ctrl-r seguido del nombre de un registro inserta ese registro; Ctrl-r = evalúa una expresión de Vimscript e inserta el resultado. Ctrl-k inserta un digraph (carácter especial) escribiendo dos caracteres ASCII.
:r file.txt # insert contents of file below cursor
:r !command # insert output of shell command
:0r !date # insert date at top of file
:r !ls -la # insert directory listing
# Insert with special registers
Ctrl-r = # expression register: evaluate, insert result
Ctrl-r " # insert unnamed register
Ctrl-r % # insert current filename
# Insert from current file path
:i! !pwd # insert pwd output (no autoindent)
# Non-ASCII / digraphs (in insert mode)
Ctrl-k {ch1}{ch2} # digraph: e.g. Ctrl-k e' produces é
:digraphs # list available digraphsAtajos del modo insert
Ctrl-h/w/u funcionan como Backspace/borrar-palabra/borrar-línea dentro del modo insert. Ctrl-t/Ctrl-d ajustan la indentación sin salir del modo insert — inestimables para código. Ctrl-n/Ctrl-p completan por palabra clave desde buffers y tags. Ctrl-o ejecuta un único comando Normal y vuelve a insert (p. ej. Ctrl-o zz para recentrar). Ctrl-g u rompe la cadena de undo para que una inserción larga se pueda deshacer por partes.
# In insert mode:
Ctrl-h # delete char before cursor (Backspace)
Ctrl-w # delete word before cursor
Ctrl-u # delete to start of line
Ctrl-t # indent current line (one shiftwidth)
Ctrl-d # dedent current line (one shiftwidth)
Ctrl-n # keyword completion (forward)
Ctrl-p # keyword completion (backward)
Ctrl-o # execute one Normal command, return to insert
Ctrl-r {reg} # insert register contents
Ctrl-a # insert text typed in last insert mode
Ctrl-@ # insert last text + Esc (like Ctrl-a then Esc)
Ctrl-g u # break undo sequence (start new undo block)
Ctrl-] # trigger abbreviation without insertingComandos de edición (borrar/yank/pegar)
Comandos de borrado
d{motion} es el operador universal de borrado — combínalo con cualquier movimiento. dd borra la línea entera. x es un atajo de dl (borrar carácter). El texto borrado va al registro sin nombre (y al registro 1). Usa d con text objects (ciw, dib) para ediciones potentes. J une la línea siguiente a la actual con un espacio.
x # delete char under cursor (also 'dl')
X # delete char before cursor (also 'dh')
dd # delete current line
dw # delete to next word start
de # delete to end of word
d$ / D # delete to end of line
d0 # delete to beginning of line
d^ # delete to first non-blank
dgg # delete from cursor to first line
dG # delete from cursor to last line
J # join next line (removes leading whitespace, inserts space)
gJ # join next line without inserting space
3dd # delete 3 lines
dW # delete WORD (whitespace-separated)Yank (copiar)
y{motion} copia texto sin borrarlo. yy copia la línea. A diferencia de d (que tiene x como atajo), y no tiene atajo de un solo carácter — debes usar un movimiento. Yank siempre actualiza el registro 0, útil para distinguirlo de los borrados. Usa text objects: ya( copia alrededor de los paréntesis, yi" copia dentro de las comillas.
y # yank {motion} (no character shortcut)
yy / Y # yank current line
yw # yank to next word start
ye # yank to end of word
y$ # yank to end of line
y0 # yank to beginning of line
yG # yank to end of file
ygg # yank to beginning of file
5yy # yank 5 lines
ya( # yank around parentheses
yi" # yank inside double quotes
yt, # yank up to (not including) next comma
# Yanked text goes to:
# " (unnamed register)
# 0 (yank register, only updated by y)Put (pegar)
p pega después del cursor (o debajo de la línea para datos por líneas); P pega antes. gp/gP mueven el cursor al final del texto pegado — útil al encadenar operaciones. ]p/[p reindenta las líneas pegadas para que encajen con el entorno. El registro del portapapeles (+) se comparte con el portapapeles del sistema si 'clipboard' está bien configurado.
p # paste after cursor (linewise: line below)
P # paste before cursor (linewise: line above)
gp # paste after, leave cursor on last pasted char
gP # paste before, leave cursor on last pasted char
]p # paste after, reindent to match
[p # paste before, reindent to match
"+p # paste from system clipboard
"*p # paste from primary selection (X11)
# Linewise vs charwise:
# yy + p -> pasted as a new line below
# y$ + p -> pasted after cursor on same line
# Counts: 3p pastes the register 3 times.Cambiar mayúsculas y minúsculas
~ alterna un único carácter y avanza. g~/gu/gU son operadores que funcionan con movimientos o text objects. En modo visual, U/u/~ actúan sobre la selección. Usa gUiw para pasar a mayúsculas la palabra actual, gUU para la línea entera. No son destructivos — solo cambia el caso.
~ # toggle case of char under cursor (advances)
3~ # toggle case of next 3 chars
g~{motion} # toggle case of motion
gu{motion} # lowercase motion
gU{motion} # uppercase motion
g~~ # toggle case of current line
guu # lowercase current line
gUU # uppercase current line
g~~gg # toggle case to first line
# Visual mode:
# U # uppercase selection
# u # lowercase selection
# ~ # toggle case of selection
# Examples:
# hello + gUw -> HELLO
# HELLO + guw -> hello
# hello + g~w -> HELLOUnir y partir líneas
J une líneas con un espacio; gJ une sin insertar nada. :join funciona sobre un rango. gq es el operador de formateo — corta las líneas a 'textwidth' (normalmente 80), respetando 'formatoptions'. Usa gqip para reflujo de un párrafo, gqq para una línea. Fija 'textwidth=80' para activar el corte automático.
J # join next line with current (inserts space)
gJ # join next line without inserting space
3J # join next 3 lines into one
:[range]join # join lines in range (also :j)
:[range]join! # join without inserting space
# Splitting a line:
# In insert mode, press Enter (autoindent applies)
# In normal mode: r<Enter> replaces char with newline
# Break a long line at column 80 (with 'textwidth'):
gq{motion} # format motion text to 'textwidth'
gqq # format current line
gqip # format paragraph
gvgq # format visual selection
# Set text width:
:set textwidth=80Repetir y deshacer
. repite el último cambio — la tecla más útil de Vim. u/Ctrl-r son deshacer/rehacer. U deshace cada cambio de la línea actual. :earlier/:later pueden viajar en el tiempo por tiempo o por conteo, incluso entre ramas (Vim mantiene un árbol de undo). Usa :undolist para ver las ramas. @: repite el último comando Ex, & repite la última sustitución.
. # repeat last change (most powerful key in Vim)
u # undo
Ctrl-r # redo
U # undo all changes on current line
:Nu # undo N changes
:earlier 10m # revert to state 10 minutes ago
:later 5 # redo 5 changes
:undolist # show undo tree branches
# Repeat with counts:
5. # repeat last change 5 times
# Repeat Ex commands:
@: # repeat last :command
& # repeat last :s (substitute)
# Repeat macros/marks across files:
:& # repeat last substitute on current lineBúsqueda y sustitución
Búsqueda básica
/ y ? buscan hacia adelante/atrás; n/N repiten. * busca la palabra completa bajo el cursor (con límites de palabra), g* busca cualquier coincidencia de subcadena. :noh limpia el resaltado actual hasta la próxima búsqueda. Fija 'hlsearch' para resaltar todas las coincidencias de forma persistente, 'incsearch' para el emparejamiento incremental mientras escribes.
/pattern # search forward for pattern
?pattern # search backward
n # repeat search (same direction)
N # repeat search (opposite direction)
* # search forward for word under cursor
# # search backward for word under cursor
g* # search forward (loose, matches substring)
g# # search backward (loose)
# Search history:
# Press / then Up/Down to recall previous searches
# Clear search highlighting:
:nohlsearch # or :noh
# Toggle 'hlsearch' permanently:
:set hlsearch!Opciones de búsqueda
'ignorecase' + 'smartcase' es la combinación recomendada: sin distinguir mayúsculas salvo que tu patrón contenga una mayúscula. \c/\C anulan el caso por búsqueda. \v activa el modo 'very magic', donde muchos caracteres pasan a ser especiales sin escapar — una sintaxis de regex más limpia. Los offsets de búsqueda (e, b) sitúan el cursor respecto a la coincidencia.
:set ignorecase # case-insensitive search (ic)
:set smartcase # case-sensitive if pattern has uppercase
:set hlsearch # highlight all matches (hls)
:set incsearch # show match as you type (is)
:set wrapscan # wrap around end of file (ws)
:set gdefault # add 'g' flag to all :s by default
# Per-search case override:
/foo\c # case-insensitive search for foo
/foo\C # case-sensitive search for foo
# Use very-magic mode (less escaping):
/foo\v(.+)@<=(bar) # very magic regex
# Search offsets:
/foo/e # cursor on last char of match
/foo/e+2 # cursor 2 chars past match
/foo/b-1 # cursor 1 char before matchPatrones de búsqueda (regex)
La regex de Vim difiere de PCRE — hace falta barra invertida para +, =, {, (, |. Usa el prefijo \v para el modo 'very magic', donde estos pasan a ser especiales sin escapar (más cercano a PCRE). \< \> marcan límites de palabra. \d/\w/\s son clases de caracteres. Usa \(...\) para grupos de captura y \1/\2 para retroreferencias.
# Standard Vim regex (default magic mode)
. # any char
* # zero or more (preceding atom)
\+ # one or more
\= # zero or one (optional)
\{n,m} # between n and m
^ $ # start/end of line
\< \> # word boundaries
[abc] # char class (a, b, or c)
[^abc] # negated char class
\( \) # group
\1 \2 # backreference
\| # or
# Predefined classes:
\d \D # digit / non-digit
\w \W # word char / non-word
\s \S # whitespace / non-whitespace
# Very magic (\v prefix) — less escaping:
/\v\w+\s+\w+ # word, spaces, word (no backslashes needed)
/\v(%d+) # capture one-or-more digitsComando substitute
:[range]s/pattern/replacement/flags es el comando de sustitución. :% significa el archivo entero. Sin el flag 'g', solo se reemplaza la primera coincidencia por línea; 'g' reemplaza todas. 'c' pide confirmación (y/n/a/q/l). Usa \v para very-magic y simplificar la sintaxis de agrupación. Los grupos de captura se referencian como \1, \2 en el reemplazo.
:[range]s/old/new/[flags]
# Basic:
:s/old/new/ # replace first 'old' on current line
:s/old/new/g # replace all 'old' on current line
:%s/old/new/g # replace all in whole file
:%s/old/new/gc # confirm each replacement
:%s/old/new/gi # case-insensitive
# Range examples:
:5,10s/old/new/g # lines 5-10
:.,$s/old/new/g # current line to end
:'a,'bs/old/new/g # from mark a to mark b
:'<,'>s/old/new/g # visual selection
:1,$s/old/new/g # whole file (same as %)
# Replace with capture groups:
:%s/\(\w\+\),\(\w\+)/\2,\1/ # swap two comma-separated words
:%s/\v(\w+),(\w+)/\2,\1/ # same with very-magicFlags de sustitución y reemplazos especiales
Flags habituales: g (todas), c (confirmar), i (sin distinguir mayúsculas), n (solo contar). & en el reemplazo inserta el texto coincidente. \u/\U/\l/\L modifican el caso del reemplazo. Usa \r para insertar un salto de línea (\n es un byte nulo en el reemplazo). El flag 'n' es genial para contar coincidencias sin cambiar nada.
# Flags:
g # all occurrences on each line (not just first)
c # confirm each substitution
i # ignore case
I # don't ignore case
e # don't error if no match
p # print last substituted line
n # count matches, don't substitute
# Special chars in replacement:
& # the matched text
\0 # the matched text (same as &)
\1..\9 # capture groups
\u # next char uppercase
\U # rest of string uppercase (until \e or \E)
\l \L # lowercase (single / until \e)
\r # split into new line
\n # null byte (use \r for newline)
# Examples:
:%s/foo/&bar/g # foo -> foobar
:%s/\v(\w+)/\U\1/g # uppercase every word
:%s/, /,\r/g # split lines on ', '
:%s/old/new/gn # count matches onlyComando global (:g)
:g ejecuta un comando Ex en cada línea que coincide con un patrón — un potente editor 'global'. :v (o :g!) lo ejecuta en las líneas que no coinciden. Combínalo con cualquier comando Ex: d (borrar), m (mover), t (copiar), s (sustituir), normal (ejecutar comando de modo normal). Útil para operaciones por lotes sobre líneas etiquetadas. El orden importa: :g procesa de arriba hacia abajo por defecto.
:[range]g/pattern/cmd # run cmd on each matching line
:[range]g!/pattern/cmd # run cmd on NON-matching lines
:v/pattern/cmd # same as :g! (inverse)
# Common uses:
:g/^$/d # delete all blank lines
:g/TODO/d # delete all lines with TODO
:g/pattern/p # print all matching lines
:g/pattern/normal @a # run macro a on each matching line
:g/pattern/m0 # move matching lines to top (reverse order)
:g/pattern/t$ # copy matching lines to end
:g/pattern/s/old/new/g # substitute on matching lines only
# Combined with Ex range:
:g/^#/s/foo/bar/g # in lines starting with #, replace foo with bar
# Multiple commands per match:
:g/pattern/d|t0 # delete then copy (chained with |)Modo visual
Tipos de modo visual
v/V/Ctrl-v seleccionan caracteres/líneas/bloque. gv vuelve a seleccionar la última selección visual — práctico para reaplicar una operación. o mueve al otro extremo de la selección (así puedes extenderla en cualquier dirección). En modo por bloques, O mueve a la otra esquina de la misma línea.
v # charwise visual (select characters)
V # linewise visual (select whole lines)
Ctrl-v # blockwise visual (select rectangle)
gv # reselect last visual selection
# In visual mode:
o / O # move cursor to other end of selection (corner for block)
Esc / v # exit visual mode (toggle)
# Quick selections from normal mode:
vap # select around paragraph
vip # select inside paragraph
i" # then press v... actually ciw etc. work directly
# Switching between types:
# v then V -> linewise (extends to whole lines)
# V then v -> charwise
# Ctrl-v -> blockwiseOperaciones visuales
Una vez hecha la selección, d/c/y/x funcionan como se espera. = auto-indenta (genial para reformatear código). >/< indentan/desindentan un shiftwidth. ! pasa la selección por un comando de shell y la reemplaza con la salida. Pulsar : en modo visual rellena automáticamente '<,'> como rango, así que :s/old/new/g corre solo sobre la selección.
# In visual mode, press:
d / x # delete selection
c / s # change selection (delete, enter insert)
y # yank (copy) selection
~ # toggle case of selection
u / U # lowercase / uppercase selection
> # indent selection
< # dedent selection
= # auto-indent selection (reformat)
!cmd # filter through external command
:r !cmd # (after yank) paste command output
# Replace entire selection with a char:
r{x} # replace every char with x
# Print line numbers of selection:
g Ctrl-g # count words/chars/lines in selection
# Search within selection (after selecting, type :):
# '<,'>s/old/new/g -- range auto-filledTrucos de bloque visual
El bloque visual (Ctrl-v) es una de las funciones más potentes de Vim. I y A insertan antes/después del bloque — el texto se replica en cada línea tras Esc. Es la forma más fácil de añadir un prefijo de comentario a varias líneas o de añadir un sufijo. c cambia el bloque entero; r{x} reemplaza cada carácter por x. Las ediciones de bloque solo funcionan limpiamente cuando las líneas son de longitud similar.
# Enter block visual: Ctrl-v
# Select a column rectangle, then:
I # insert BEFORE block (text typed appears in front)
# Type text, then Esc -> inserted on every line of block
A # insert AFTER block (text appears at end of each line)
# Esc propagates the insert to all lines
c # change block (delete, enter insert; Esc propagates)
r{x} # replace every char in block with x
# Common use cases:
# 1. Add a comment to a column of lines:
# Ctrl-v select first column, I, type '# ', Esc
# 2. Add semicolons at end of selected lines:
# Ctrl-v select end column, $A;, Esc
# 3. Delete a column:
# Ctrl-v select, d
# 4. Replace a column with same char:
# Ctrl-v select, r;Modo visual de línea
V selecciona líneas completas. Tras V, las operaciones habituales son d/y/>/</= para manipularlas. :m mueve la selección (p. ej., :'<,'>m0 la lleva al principio). :t la duplica. '< y '> son marcas al inicio/fin de la última selección visual — útiles en scripts. gv reselecciona el último rango visual.
V # enter linewise visual
5V # select 5 lines (current + 4 below)
ggVG # select entire file
:'<,'> # range referring to last visual selection
# After selecting lines (V), useful commands:
d # delete lines
y # yank lines (linewise)
> # indent lines
< # dedent lines
= # auto-indent lines
:m +2 # move selection down 2 lines
:m -3 # move selection up 3 lines
:t . # duplicate lines (copy below selection)
:g/^/m0 # reverse line order (whole file)
# Reselect last visual:
gv # reselect last visual selection
'< # mark: start of last visual
'> # mark: end of last visualVisual con text objects
Los text objects también funcionan en modo visual — extienden la selección actual. vi( selecciona dentro del paréntesis; va( lo incluye. Repetir un text object (vawaw) extiende más. Suele ser más rápido que posicionar el cursor manualmente. Combínalo con operadores: ciw cambia la palabra interior sin importar dónde esté el cursor dentro de ella.
# In visual mode, text objects EXTEND the selection:
# After pressing v (charwise), type:
aw # extend selection to include next 'a word'
iw # extend selection to inner word
ab # around brackets ()
ib # inside brackets ()
aB # around braces {}
iB # inside braces {}
a" # around double-quoted string
i" # inside double-quoted string
ap # around paragraph
ip # inside paragraph
# Repeated text objects extend selection:
# vaw -> select word + trailing space
# vawaw -> extend to next word + space
# Switch between inner and around:
# vi( -> select inside parens
# va( -> extend to include the parensBúsqueda visual y numeración
Pulsar : en modo visual pre-rellena '<,'> como rango — las sustituciones corren solo sobre la selección. Para buscar la selección visual, usa y/ y luego Ctrl-r " Enter (pegar el registro en la búsqueda). g Ctrl-a en bloque visual crea una secuencia creciente — inestimable para generar listas numeradas (1, 2, 3, ...) a partir de una columna de números idénticos.
# Search within visual selection:
# 1. Visually select (v/V/Ctrl-v)
# 2. Press : -> :'<,'> appears
# 3. Type s/old/new/g -> substitute only in selection
# Search for current visual selection (forward):
# In visual mode, type:
# \V then / (very-nomagic, escapes regex chars)
# Or use a plugin (e.g. vim-visual-star-search)
# Manual method:
# y/ then Ctrl-r " Enter -> search for selection
# Increment/decrement numbers (visual block):
# Select a column of numbers (Ctrl-v)
Ctrl-a # increment every number in selection by 1
Ctrl-x # decrement every number in selection by 1
g Ctrl-a # increment with running counter (1,2,3,...)
g Ctrl-x # decrement with running counter
# Example: turn 0,0,0,0 into 1,2,3,4:
# Ctrl-v select column, g Ctrl-aBuffers
Conceptos básicos de buffers
Los buffers son archivos en memoria. :e abre un archivo en un buffer nuevo. :ls lista cada buffer con flags de estado (% = actual, # = alternante, + = modificado, h = oculto). :b N cambia por número; :b name por prefijo único. Ctrl-6 (o :b#) alterna entre el buffer actual y el alternante — sumamente común.
:e file.txt # open file in new buffer (current window)
:enew # new empty buffer
:ls / :buffers # list all buffers
:b N # go to buffer N (by number from :ls)
:b name # go to buffer by name (unique prefix)
:bn # next buffer
:bp # previous buffer
:b# / Ctrl-6 # alternate buffer (last edited)
:ball # open all buffers in horizontal splits
:vertical ball # open all buffers in vertical splits
# Buffer list symbols:
# % current window's buffer
# # alternate buffer
# a active (loaded and visible)
# h hidden (loaded but not visible)
# - not modifiable
# = read-only
# + modifiedNavegación entre buffers
:bn/:bp ciclan por los buffers. Ctrl-6 alterna entre los dos más recientes — la forma más rápida de ir y venir. Con 'hidden' activado, alejarse de un buffer modificado no fuerza el guardado — Vim lo oculta. Usa :ls y luego :b N si olvidas los números de buffer. Plugins como fzf.vim hacen el cambio difuso de buffers mucho más rápido.
:bn / :bnext # next buffer (wraps around)
:bp / :bprev # previous buffer
:bf / :bfirst # first buffer
:bl / :blast # last buffer
:b# # alternate buffer (Ctrl-6)
:N b # go to buffer number N (e.g. 3b)
:b name<tab> # tab-complete buffer name
:ls then :b N # two-step navigation
# Faster navigation (set in vimrc):
:nmap <C-n> :bn<CR>
:nmap <C-p> :bp<CR>
# Jump to a buffer with fuzzy matching (with fzf.vim):
:Buffers # fuzzy-select from buffer list
# Hide current buffer without saving (if 'hidden' is set):
:hide # or :bn with 'set hidden'Operaciones con buffers
:bd quita un buffer de la lista (el archivo se cierra). :bw también elimina marcas y variables locales del buffer. :%bd | e# borra la totalidad salvo el buffer actual — un patrón de limpieza común. :bufdo ejecuta un comando Ex en cada buffer — potente para sustituciones globales, pero vigila los errores (usa ! para ignorarlos, o añade el flag 'e' a :s).
:bd / :bdelete # delete current buffer
:bd N # delete buffer N
:bd name # delete buffer by name
:bw / :bwipeout # wipe buffer (also clears marks, vars)
:N,N bd # delete buffers in range
:%bd # delete all buffers
:%bd | e# # delete all but current
:bn! # force switch (don't save current)
:wall # write all buffers
:bufdo cmd # run cmd in every buffer
:bufdo! cmd # same but ignore errors
# Useful patterns:
:bufdo %s/old/new/ge # substitute in all buffers
:bufdo setlocal nowrap # apply setting to all buffers
# Save and quit current buffer:
:wq # write current and quit (closes window)Buffers ocultos
Con 'set hidden' (muy recomendado), puedes alejarte de buffers modificados sin guardar — Vim los mantiene en memoria. Sin 'hidden', Vim bloquea el cambio hasta que guardes o uses ! para descartar. :ls muestra 'h' para buffers ocultos y '+' si están modificados. Este ajuste es esencial para editar varios archivos con productividad.
:set hidden # allow switching from modified buffers
:set nohidden # force save/abandon when switching
# With 'hidden' set:
# :bn # switch even if current is modified (no save)
# :q # if buffer is modified, prompts to save
# :qa! # quit all without saving
# :wa # write all (hidden + visible)
# Buffer with changes still in memory:
:ls # shows 'h' flag for hidden, '+' for modified
# Recover list of hidden buffers:
:ls h # only hidden buffers
# Save a hidden buffer:
:w # save current (if visible)
:N w # save buffer N
:wall # save all buffers
# Common workflow with hidden:
# :e file1 -> make changes -> :e file2 -> :e file1 (changes preserved)Lista de argumentos
La arglist es una lista aparte de la lista de buffers — es el conjunto de archivos pasados en la línea de comandos o fijados con :args. :n/:prev la recorren. :argdo ejecuta un comando Ex en cada archivo de la arglist — perfecto para procesar por lotes como :argdo %s/foo/bar/ge | update. La arglist suele ser más enfocada que la lista de buffers.
# Open files in arglist:
vim file1.txt file2.txt # initial args
:args file1 file2 file3 # replace arglist
:argadd file4 # add to arglist
:arga *.py # add all Python files
:argdelete file2 # remove from arglist
# Navigate arglist:
:n / :next # next file in arglist
:prev / :Next # previous file
:first # first file
:last # last file
:rewind # rewind to first file
# Process all files:
:argdo %s/old/new/ge # substitute in every arg file
:argdo set ff=unix | w # convert line endings in all
# Show current arglist:
:args # show files (current marked with [ ])Gestión de la lista de buffers
:ls lista los buffers, :ls! incluye los no listados (borrados pero recordados). Usa :sb para abrir un buffer en un split sin cambiar el buffer de la ventana actual. No existe un 'deshacer buffer cerrado recientemente' integrado, pero hay plugins. :bufdo vimgrepadd seguido de :copen te permite buscar en la totalidad de los buffers abiertos vía la lista quickfix.
:ls # list all buffers
:ls! # list including unlisted buffers
:files # alias for :ls
# Move current buffer to a specific position:
:N b N # buffer number N
# Quickly inspect related files:
:b <tab> # tab-complete buffer names
:b #<tab> # buffers matching '#'
# Find buffer containing a pattern:
:vimgrep /pattern/ % # current buffer only
:bufdo vimgrepadd /pattern/ % # all buffers (then :copen)
# Open buffer in a specific window:
:sb N # open buffer N in horizontal split
:vertical sb N # open buffer N in vertical split
:tab split +b N # open buffer N in new tab
# Restore closed buffers:
# (No built-in, but plugins like vim-molten or
# vim-restore-buffers can help)Marcas y saltos
Fijar marcas
Las marcas son posiciones con nombre en los archivos. Las minúsculas (a-z) son locales del buffer; las mayúsculas (A-Z) son marcas de archivo que persisten entre sesiones de Vim. Las marcas numéricas (0-9) se fijan automáticamente — 0 es la posición al cerrar Vim por última vez, 1-9 son archivos cerrados recientemente. :marks las lista, :delm borra.
m{a-zA-Z} # set mark at cursor position
ma # set mark 'a' (lowercase, buffer-local)
mA # set mark 'A' (uppercase, file mark)
m' # set the unnamed mark (jump before/after)
# Lowercase marks (a-z):
# Local to current buffer
# Lost when buffer is unloaded
# Uppercase marks (A-Z):
# File marks — preserved across sessions
# Work even after the file is closed
# Numbered marks (0-9):
# Set automatically by Vim
# 0 = position when Vim was last closed
# 1-9 = positions of last 9 closed files
# View marks:
:marks # list all marks
:marks a b c # specific marks
:delm! a # delete mark 'a' (force)Saltar a marcas
` (acento grave) salta a la posición exacta (línea + columna); ' (apóstrofe) salta al primer carácter no blanco de la línea marcada. `A abre el archivo que contiene la marca A aunque estuviera cerrado. `. salta al último lugar donde cambiaste texto, `[ y `] acotan la última región copiada/borrada, `< y `> acotan la última selección visual.
\`{a-zA-Z} # jump to mark (line AND column)
'{a-zA-Z} # jump to mark (line only, column 1)
\`a # jump to mark 'a' (exact position)
'a # jump to line of mark 'a'
\`A # jump to file mark 'A' (opens file if closed)
\`. # jump to position of last change in this buffer
\`" # jump to position when file was last closed
\`[ # jump to start of last yanked/changed text
\`] # jump to end of last yanked/changed text
\`< # jump to start of last visual selection
\`> # jump to end of last visual selection
\`^ # jump to last insert position (also gi)
# Jump to next/prev mark in alphabetical order:
:[count]next # (no built-in, requires plugin)Lista de saltos
Vim mantiene una jumplist de movimientos significativos del cursor. Ctrl-o/Ctrl-i retroceden/avanzan por ella. 'Significativo' significa saltos (G, gg, búsquedas, saltos a marcas, saltos a tags) — no movimientos regulares como j/k/w. :jumps muestra la lista. La jumplist es por ventana y persiste entre sesiones en viminfo/shada.
Ctrl-o # jump BACK in jumplist (older positions)
Ctrl-i # jump FORWARD in jumplist (newer positions)
Tab # same as Ctrl-i
:ju # show jumplist (:jumps)
# What counts as a jump?
# - Movement commands: G, gg, H, M, L, %
# - Search: /, ?, n, N, *, #
# - Mark jumps: 'x, `x (NOT mm)
# - Buffer switch: Ctrl-6, :b, :e
# - Tag jumps: Ctrl-]
# NOT counted: j, k, w, b, h, l (regular motions)
# Max jumplist size: 100 entries by default
:set jumpoptions=stack # treat jumplist like a stack
# Clear jumplist:
:clearjumps # or :cljLista de cambios
La changelist rastrea posiciones de edición (no de navegación). g; salta a la edición anterior, g, a la siguiente. Útil para retroceder por tus cambios: '¿dónde estaba trabajando?'. :changes muestra la lista. A diferencia de la jumplist, la changelist es por buffer. Combínala con `.` para el último cambio del buffer actual.
g; # go to OLDER position of last change
g, # go to NEWER position of last change
:changes # list changelist
# Each entry shows:
# change number, line, column, text of change
# What counts as a change?
# - Any insertion, deletion, or substitution
# - Records the position BEFORE the change
# Differences from jumplist:
# - Changelist tracks EDITS, not movements
# - Per-buffer (not per-window)
# - Limited to 100 entries
# Combine with marks:
\`. # last change position in current buffer
g; # previous change position
# Common pattern: g;g;g; to walk back through editsMarcas de archivo (A-Z)
Las marcas en mayúscula (A-Z) son marcas de archivo — recuerdan el archivo Y la posición, y persisten entre sesiones de Vim (guardadas en viminfo). Fijar mA en foo.txt te permite volver a esa posición desde cualquier lugar con `A, incluso tras reiniciar Vim. Úsalas como marcadores de archivos/posiciones importantes de un proyecto.
# Setting a file mark:
mA # set mark 'A' at cursor (in current file)
mB # set mark 'B' (in current file)
# Jumping to a file mark:
\`A # if file is open: jump to position
\`A # if file is closed: open it, then jump
'A # jump to first non-blank of mark's line
# File marks persist across Vim sessions:
# Stored in viminfo (or shada in Neovim)
# Restored on next Vim launch
# Use cases:
# 1. Bookmark a function: mA in function definition
# 2. Quick jump between files: `A, `B
# 3. Project navigation: set marks in important files
# Listing file marks:
:marks A-Z # show only file marks
# Deleting:
:delm A # delete file mark A (must be in its file)Marcas especiales integradas
Vim fija marcas especiales automáticamente. `.` es el último cambio, `[ y `] acotan la última región copiada/borrada, `< y `> acotan la última selección visual, `^ es donde terminó por última vez el modo insert (gi salta ahí y vuelve a entrar en insert). `" es la posición al cerrar el archivo por última vez — útil para retomar el trabajo.
\`. # position of last change in current buffer
\`" # position when file was last exited
\`[ # start of last yanked/changed text
\`] # end of last yanked/changed text
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # position where insert mode was last stopped
\`' # position before latest jump (where you came FROM)
# Common uses:
\`[\`] # operate on last yanked range: \`[v\`]U (uppercase it)
\`<\`> # re-select last visual: \`<v\`> or gv
# Re-select last visual selection:
gv # easier than \`<v\`>
# Re-select last pasted text:
\`]v\`[ # or use a mapping: nnoremap gp \`]v\`[
# Return to last insert position:
gi # jump to `^ and enter insert modeText objects
Objetos de palabra y frase
Los text objects te permiten operar sobre unidades semánticas. 'aw' (around word) incluye el espacio final — daw cierra el hueco. 'iw' (inner word) deja el espacio intacto — diw deja un espacio. as/ap son las versiones de frase/párrafo. Repetir un objeto (dawaw) extiende la selección. Más útiles con los operadores d/c/y/v.
# Operators (d/c/y/v) + text object:
aw # 'a word' - word + trailing whitespace
iw # 'inner word' - word only (no whitespace)
aW # 'a WORD' - WORD + trailing whitespace
iW # 'inner WORD' - WORD only
as # 'a sentence' - sentence + trailing space
is # 'inner sentence' - sentence only
ap # 'a paragraph' - paragraph + trailing blank line
ip # 'inner paragraph' - paragraph only
# Examples:
daw # delete word + trailing space (closes gap)
diw # delete word only (leaves whitespace)
cas # change sentence (with trailing space)
yap # yank paragraph (with trailing blank line)
gqip # format (wrap) inner paragraph
# Repeated: dawaw extends to next wordObjetos de corchetes
Los objetos de corchetes funcionan sobre (), [], {}, <>. a (around) incluye los corchetes; i (inner) los excluye. ci( cambia el contenido de los paréntesis sin quitarlos — perfecto para editar argumentos de funciones. Opera sobre el par más interno cuando están anidados. at/it operan sobre etiquetas HTML/XML (p. ej., cit cambia el contenido interior de la etiqueta).
# Brackets (any of ( [ { <):
ab / ib # around / inside ()
aB / iB # around / inside {} (also a{ / i{)
a( / i( # same as ab / ib
a[ / i[ # around / inside []
a{ / i{ # same as aB / iB
a< / i< # around / inside <>
# Examples:
ci( # change text inside ( ... )
daB # delete {...} block including braces
yi[ # yank text inside [...]
vaB # visually select around {...}
# Special: 'tag' objects (HTML/XML):
at / it # around / inside <tag>...</tag>
# Tip: works with mismatched brackets too:
# ci) on (foo bar) changes 'foo bar'
# Nested: ci( in ((a)(b)) changes innermostObjetos de comillas
Los objetos de comillas (a"/i", a'/i', a`/i`) operan sobre strings entrecomillados. El cursor no necesita estar dentro de las comillas — Vim encuentra el par más cercano. ci" cambia el contenido de un string sin quitar las comillas — inestimable para editar literales de string. Incluye las comillas con 'a', exclúyelas con 'i'.
a" # around double-quoted string (includes quotes)
i" # inside double-quoted string (no quotes)
a' # around single-quoted string
i' # inside single-quoted string
a\` # around backtick-quoted string
i\` # inside backtick-quoted string
# Examples:
ci" # change text inside "..."
da" # delete "..." (including quotes)
yi' # yank text inside '...'
va\` # visually select around \`...\`
# Cursor can be ANYWHERE on the line — Vim finds the
# nearest quote pair containing or following the cursor.
# Special: with counts
3a" # around 3 consecutive quoted strings
# Tip: ci" when cursor is on the quote itself works tooObjetos de frase y párrafo
Las frases terminan con . ! ? seguidos de un espacio (o un salto de párrafo). Los párrafos son bloques separados por líneas en blanco. 'a' incluye el espacio final, 'i' lo excluye. Útiles con operadores: gqap reformatea un párrafo, >ip lo indenta, das borra una frase. Los movimientos ( y ) saltan entre frases.
# Sentence: ends with . ! ? followed by whitespace
as / is # around / inner sentence
# Paragraph: blocks of text separated by blank lines
ap / ip # around / inner paragraph
# Examples:
das # delete a sentence
cip # change inside paragraph
vap # select around paragraph (with trailing blank)
# Differences:
# 'a' (around): includes trailing whitespace/blank line
# 'i' (inner): no trailing whitespace
# Use cases:
# gqap # reformat (wrap) the paragraph
# >ap # indent the paragraph
# vip # select inside paragraph
# :'<,'>s/old/new/g # substitute in selected paragraph
# Sentence motion commands (not objects):
( # previous sentence start
) # next sentence startObjetos de etiquetas y URLs (con plugins)
Los at/it integrados operan sobre etiquetas HTML/XML. cit cambia el contenido interior de la etiqueta, dat borra la etiqueta entera incluida la apertura/cierre. Para etiquetas anidadas, it selecciona la más interna y vat se extiende hacia fuera. Los plugins añaden más objetos: vim-textobj-url (au/iu), vim-indent-object (ai/ii para bloques con la misma indentación — excelente para código).
# Built-in tag object (HTML/XML):
at / it # around / inside <tag>...</tag>
# Examples:
cit # change inner tag text: <p>text</p> -> <p>|</p>
dat # delete entire tag: <p>text</p> -> (gone)
vit # visually select inner tag text
yat # yank entire tag including <tag>...</tag>
# For nested tags, 'it' selects the innermost:
# <div><p>text</p></div>
# cit on 'text' changes 'text' only
# vat extends selection outward
# URL objects (require a plugin like vim-textobj-url):
# au / iu # around / inside URL
# Indent objects (require vim-indent-object):
# ai / ii # around / inside same-indent block
# aI / iI # entire indentation level
# Common plugin combos:
# vai # select around indent block (great for code)Uso de text objects (recetas)
Los text objects se combinan con cualquier operador (d/c/y/v/>/</=) para ediciones potentes. ciw cambia una palabra sin que necesites colocar el cursor exactamente. ci"/ci(/ci[ cambian dentro de comillas/corchetes. gqip reformatea párrafos. Dominarlos es la clave para editar a la velocidad del pensamiento en Vim.
# Common editing recipes using text objects:
# Word:
ciw # change word (regardless of cursor position in it)
daw # delete word + space (closes gap)
yiw # yank inner word (no whitespace)
# Quotes:
ci" # change inside "..."
ci'\` # change inside '...' or \`...\`
da" # delete the entire string (with quotes)
# Brackets:
ci( # change inside (...) -- great for args
daB # delete {...} block (function body)
ci[ # change inside [...]
# Sentences & paragraphs:
cas # change a sentence
dap # delete a paragraph
gqip # reformat paragraph
# HTML tags:
cit # change tag content
vat # select tag, then vat again to extend
# Combos with counts:
2daw # delete two words
c2aw # change two wordsRegistros
Conceptos básicos de registros
Los registros son los portapapeles de Vim. "ayy copia una línea al registro a, "ap pega desde a. Hay muchos registros: con nombre (a-z), de adición (A-Z), numerados (1-9) y especiales (sin nombre ", yank 0, portapapeles +, etc.). :reg los lista. En modo insert, Ctrl-r {reg} inserta un registro. Una letra mayúscula AÑADE a un registro.
# Registers store text. 10 named (a-z), 10 append (A-Z),
# 9 numbered (1-9), and several special ones.
"ay # yank into register 'a' (then motion: "ayy, "ayw)
"ap # paste from register 'a'
"ad # delete into register 'a' (e.g. "add)
"Ay # APPEND to register 'a' (uppercase = append)
# View all registers:
:reg # list all registers
:reg a b c # list specific registers
:reg + # show clipboard register
# Use a register with operators:
"aD # delete to end of line into 'a'
"byy # yank line into 'b'
"cp # paste register 'c'
# Insert mode: Ctrl-r + register
Ctrl-r a # insert contents of register 'a'
Ctrl-r = # expression register (compute, insert)
# Search from a register:
/ then Ctrl-r a # search register 'a' contentsRegistros con nombre y numerados
Los registros con nombre (a-z) los controla el usuario; A-Z añade a a-z. Los registros numerados (1-9) rastrean automáticamente los borrados recientes — 1 es el más reciente, cada borrado nuevo los desplaza. El registro 0 contiene solo el último YANK (los borrados no lo sobrescriben) — útil para flujos de copiar-luego-borrar. "- guarda los borrados pequeños (dentro de la línea).
# Named registers (a-z, A-Z):
"ayy # yank line into 'a'
"byiw # yank inner word into 'b'
"Ayy # append yanked line to 'a' (uppercase)
# Numbered registers (1-9) — auto-filled by deletes:
"1 # last delete (largest)
"2 # second-to-last delete
... # shift older with each new delete
"9 # oldest tracked delete
# Small delete register:
"- # stores deletes < 1 line (e.g. dw)
# Yank register (separate from deletes):
"0 # last YANK only (not affected by deletes)
# Examples:
"0p # paste last yank (won't paste a delete)
"1p # paste last delete
". # last inserted text (read-only)
"% # current file name (read-only)Registros especiales
Registros especiales: ". = último texto insertado, "% = archivo actual, "/ = última búsqueda, ": = último comando. "_ es el agujero negro — escribir en él descarta el texto (útil para borrados que no quieres que contaminen otros registros). "+ es el portapapeles del sistema, "* es la selección primaria de X11. "= evalúa una expresión de Vimscript e inserta el resultado.
# Read-only registers:
". # last inserted text
"% # current file name
"# # alternate file name
": # last Ex command
"/ # last search pattern
# Read/write registers:
"0 # last yank (not overwritten by deletes)
"- # last small delete (less than one line)
"_ # black hole register (discard, like /dev/null)
"= # expression register (evaluate Vimscript)
# Clipboard / selection:
"+ # system clipboard (Ctrl-C / Ctrl-V)
"* # primary selection (X11 middle-click)
# Examples:
"_dd # delete line without saving to register
"+y # yank to system clipboard (then Ctrl-V elsewhere)
"*p # paste from X11 primary selection
# Expression register (in insert mode):
Ctrl-r =strftime('%Y-%m-%d')<CR>
# inserts today's date
# Black hole: "_ prevents updating other registers.Macros en registros
Las macros viven en registros — grabar con qa escribe las pulsaciones en el registro a, @a las reproduce. Al ser registros, puedes inspeccionarlos (:reg a), editarlos pegando/modificando/volviendo a copiar, o guardarlos en tu vimrc con :let @a = '...'. Escapa las teclas especiales con \<Esc> en literales de string.
# Macros are stored in registers, just like yanked text.
# Record a macro into register 'a':
qa # start recording into 'a'
... # perform actions
q # stop recording
# Play back the macro:
@a # play macro 'a' once
@@ # play last macro again (the one just played)
5@a # play macro 'a' 5 times
:reg a # view the recorded keystrokes
# Edit a macro:
:let @a = "..." # set register 'a' directly
# Or: paste the register, edit, yank back:
"ap # paste macro keystrokes
# ... edit the text ...
"ayy # yank edited version back into 'a'
# Save a macro to vimrc:
:let @a = "0iHello \<Esc>" # escaped special keys
# Apply macro to a range:
:%normal @a # run macro 'a' on every lineAdición y agujero negro
Las letras de registro en mayúscula AÑADEN: "Ayy añade al registro a (muy útil para acumular texto o macros de varios pasos). El registro agujero negro "_ descarta cualquier cosa que se le escriba — los borrados no actualizan los registros numerados/sin nombre/de yank. Úsalo cuando quieras borrar texto sin machacar tu último yank.
# Append to a register (use UPPERCASE letter):
"ayy # yank line into 'a'
"Ayy # APPEND another line to 'a'
"Ayiw # APPEND a word to 'a'
# After: register 'a' contains both.
# Black hole register "_:
"_d # delete without affecting other registers
"_dd # delete line, doesn't update "1, "0, "-
"_c # change without saving deleted text
"_x # delete char, nothing saved
# Why use black hole?
# - Keep your yank register ("0) intact while deleting
# - Avoid polluting numbered registers
# Example: yank a line, then delete another (without
# losing the yank):
"ayy # yank into 'a'
"_dd # delete line WITHOUT touching 'a' or '0
"ap # paste the original yank
# When clipboard=unnamed, "_d still bypasses clipboard.Portapapeles y selección
"+ es el portapapeles del sistema (Ctrl-C/Ctrl-V en apps gráficas), "* es la selección primaria de X11 (pegar con clic central). Con :set clipboard=unnamedplus, los yank y los pegados van directamente al portapapeles del sistema — sin necesidad del prefijo "+. En Linux puede que necesites xclip/xsel (X11) o wl-clipboard (Wayland) instalados.
# System clipboard register:
"+y # yank to system clipboard
"+p # paste from system clipboard
"+dd # delete line to clipboard
"+P # paste before cursor from clipboard
# X11 primary selection (Linux, middle-click):
"*y # yank to primary selection
"*p # paste from primary selection
# Make the system clipboard the default:
:set clipboard=unnamedplus # use '+ for unnamed register
:set clipboard=unnamed # use '* for unnamed register
# Then yank/paste go to clipboard automatically:
yy # yanks to system clipboard (with above setting)
p # pastes from system clipboard
# Check what's in the clipboard:
:reg + # show clipboard contents
# On Linux, install a clipboard tool if missing:
# xclip or xsel for X11
# wl-clipboard for WaylandMacros
Grabar macros
q{letra} empieza a grabar en un registro; pulsa q otra vez para parar. Las pulsaciones grabadas se reproducen con @{letra}. Al grabar, usa movimientos que funcionen de forma consistente — prefiere 0, ^, $, w, e antes que j/k, que dependen de la columna. Prueba en unas pocas líneas antes de aplicar en masa.
q{a-z} # start recording into register {a-z}
... # perform actions (keystrokes recorded)
q # stop recording
# Example: wrap each word in quotes on a line:
qa # start recording into 'a'
0 # go to first column
i" # insert opening quote
Esc
e # go to end of word
a" # append closing quote
Esc
w # move to next word
q # stop recording
# Now @a will wrap one more word.
# Recording tips:
# - Use 0/^-positioned motions (not j/k)
# - Use commands that work regardless of line length
# - Test on a few lines before applying broadly
# View the recorded macro:
:reg a # see keystrokes in register 'a'Reproducir macros
@a reproduce la macro una vez, @@ repite la última macro, N@a la reproduce N veces. Para aplicar una macro a muchas líneas, selecciónalas en visual y ejecuta :normal @a, o usa :%normal @a para el archivo entero. Las macros se detienen ante un error (p. ej., cuando falla una búsqueda), así que 999@a procesa con seguridad hasta el final del archivo. :g/pattern/normal @a corre solo en las líneas que coinciden.
@a # play macro 'a' once (in current buffer)
@@ # replay the LAST macro played
5@a # play macro 'a' 5 times
100@a # play 'a' up to 100 times (stops on error)
# Play across multiple lines:
# 1. Visually select lines (V)
# 2. :normal @a # play 'a' on each selected line
# Or:
:%normal @a # play on every line in file
:5,20normal @a # play on lines 5-20
:g/pattern/normal @a # play on lines matching pattern
# Recursive macros:
# If macro 'a' contains @a, it'll recurse.
# Add a 'j' at the end to move to next line.
# Common pattern: process all matching lines:
# qa0f:x...jq # record macro moving down 1 line
# :%s/pattern//gn # count matches
# 100@a # play up to 100 timesEditar macros
Como las macros se guardan en registros, puedes editarlas. Pega el registro ("ap), modifica el texto y vuelve a copiarlo ("ay$ o "ayy). O usa :let @a = '...' con las teclas escapadas (\<Esc>, \<CR>). Es mucho más fácil que volver a grabar una macro compleja desde cero cuando cometes un pequeño error.
# Macros are just text in registers — you can edit them.
# Method 1: paste, edit, yank back:
"ap # paste register 'a' into buffer
# ... edit the pasted text (modify keystrokes) ...
0"ay$ # yank the line back into 'a'
# Method 2: set the register directly with :let
:let @a = "0iHello \<Esc>"
# Note: special keys need \<Esc> notation in strings
# Method 3: edit in a scratch buffer:
:edit
"ap # paste macro
# edit
"ayy # yank back to 'a'
:bdelete
# Common edits:
# - Add 'j' at the end to advance to next line
# - Remove a step that you don't need
# - Replace a hard-coded search with a generic one
# Show the macro as keystrokes:
:reg a # view current 'a' contentsMacros recursivas
Las macros recursivas se llaman a sí mismas hasta que dan error — normalmente cuando falla una búsqueda. CRÍTICO: vacía el registro primero (let @a = '') antes de grabar, si no, la primera llamada a @a dentro de la macro reproduce el contenido ANTIGUO. La macro termina sola cuando la búsqueda fallida corta la recursión. Genial para patrones globales de buscar y reemplazar.
# A macro can call itself, enabling recursion.
# Example: change every 'foo' to 'bar' in a column:
# (search-based macro)
# Steps to set up recursive macro 'a':
# 1. Clear register 'a':
:let @a = ''
# 2. Start recording:
qa
# 3. Search for 'foo':
/foo<CR>
# 4. Replace with 'bar' (ciwbar<Esc>):
ciwbar<Esc>
# 5. Call itself:
@a
# 6. Stop recording:
q
# Now @a runs until search fails (no more 'foo').
# The recursion stops automatically on the first error
# (when /foo finds nothing).
# Tip: clear the register first, otherwise the FIRST
# call also replays the old contents of 'a'.
# Run:
@a # processes all 'foo' in fileMacros con conteos
N@a reproduce la macro N veces — pero se detiene ante cualquier error, así que 999@a procesa con seguridad hasta el final del archivo. :bufdo normal @a ejecuta la macro en cada buffer, :argdo en cada archivo de la arglist. :g/pattern/normal @a la ejecuta solo en las líneas que coinciden. Los conteos DENTRO de una macro (p. ej., 5j) se repiten por reproducción, no por macro.
# Apply a count to a macro:
5@a # play macro 'a' 5 times
N@a # play up to N times (stops on error)
# Useful: large count to process until end-of-file
999@a # play 'a' up to 999 times (errors stop it)
# Macros with counts INSIDE:
# If your macro starts with '5j', each play jumps 5 lines
# Combine with visual selection (block):
# Ctrl-v to select, then :normal @a
# plays 'a' on each line in the block
# Process every Nth line:
:let i = 0
:g/^/if i % 3 == 0 | normal @a | endif
# (plays 'a' on every 3rd line)
# Apply with a delay (avoid blocking):
# No built-in, but plugins can defer
# Repeat across buffers:
:bufdo normal @a # play 'a' in every buffer
:argdo normal @a # play 'a' in every arg fileMacros entre archivos y líneas
:[range]normal @a ejecuta una macro en cada línea del rango — la forma más común de aplicar una macro a muchas líneas. Termina tu macro con 'j' para que cada iteración avance a la línea siguiente. :bufdo/:argdo la ejecutan entre buffers/archivos. Añade | update para guardar cada archivo modificado. Usa ! para continuar pese a los errores (p. ej., :bufdo!).
# Apply a macro to every line in a range:
:[range]normal @a
:%normal @a # whole file
:5,20normal @a # lines 5-20
:'<,'>normal @a # visual selection
:g/pattern/normal @a # only matching lines
# Apply across buffers:
:bufdo normal @a # every buffer
:argdo normal @a # every arglist file
# Save modified buffers after macro run:
:argdo normal @a | update # save each that changed
# Best practice: include 'j' (move down) at end of macro
# so it advances to the next line for :normal usage.
# Example macro for processing CSV rows:
# qa 0f,dt,j q # cut field at comma, move down
# :%normal @a # apply to every line
# Abort on error vs. continue:
:bufdo! normal @a # continue even if a buffer errors
# Debug: play macro step-by-step (no built-in, but
# :set lazyredraw off + slow key timing helps).Plegado (folding)
Modalidades de plegado
foldmethod controla cómo se crean los pliegues. 'manual' te permite crear pliegues con zf. 'indent' pliega automáticamente por indentación (genial para código). 'syntax' usa reglas de sintaxis (consciente del lenguaje). 'marker' usa {{{ }}} en el texto del archivo. 'expr' para lógica personalizada. Los pliegues manuales se pierden al cerrar el archivo salvo que los guardes con :mkview.
:set foldmethod=manual # fold by hand (zf)
:set foldmethod=indent # fold by indent level
:set foldmethod=expr # fold by 'foldexpr'
:set foldmethod=syntax # fold by syntax rules
:set foldmethod=marker # fold by {{{ }}} markers
:set foldmethod=diff # fold unchanged text in diff
# Recommended defaults:
:set foldmethod=indent # great for code
:set foldlevel=2 # show first 2 levels
# Per-method notes:
# manual - zf to create, zd to delete
# indent - automatic, based on shiftwidth
# syntax - automatic, requires syntax file support
# marker - persistent (saved in file as {{{ }}})
# expr - custom logic via 'foldexpr'
# Persistent manual folds across sessions:
:mkview # save folds (and other view state)
:loadview # restore them
# Or set:
:set viewoptions=folds # what :mkview savesPlegado manual
En modo manual, zf crea un pliegue (p. ej., zf3j pliega las siguientes 3 líneas). zd borra un pliegue, zD lo borra recursivamente, zE elimina cada pliegue de la ventana. Modo visual + zf pliega la selección. Con foldmethod=marker, pones la marca de apertura {{{ y su pareja de cierre (las mismas llaves en sentido inverso) en comentarios para crear pliegues persistentes guardados en el archivo — útil para compartir la estructura de pliegues en el control de versiones.
# Manual fold commands (foldmethod=manual):
zf{motion} # create fold over motion (e.g. zf3j)
zF # create fold over current line(s)
zd # delete fold at cursor
zD # delete fold recursively (nested)
zE # eliminate ALL folds in window
zj / zk # move to next/prev fold start
[z / ]z # move to fold start/end
# Select then fold (visual):
V zf # visually select lines, then fold
# Create fold for a range:
:5,20fold # fold lines 5-20
# Fold using a marker (manual mode):
# Place markers in the file (with foldmethod=marker):
function Foo() " {{{
echo "hi"
endfunction " }}}
# When foldmethod=marker, the {{{ }}} create persistent
# folds stored in the file text itself.Comandos de abrir/cerrar pliegues
zo/zc abren/cierran un pliegue; za lo alterna. zO/zC/zA actúan recursivamente sobre pliegues anidados. zr/zm ajustan el nivel de plegado globalmente (un nivel por vez). zR lo abre por completo, zM lo cierra por completo — formas rápidas de restablecer. zj/zk saltan entre pliegues, [z/]z saltan al inicio/fin del pliegue actual.
zo # open fold (one level)
zc # close fold (one level)
za # toggle fold (open <-> closed)
zO # open fold recursively (all levels)
zC # close fold recursively (all levels)
zA # toggle fold recursively
zr # reduce fold level by 1 (open one level everywhere)
zm # increase fold level by 1 (close one level everywhere)
zR # open ALL folds (reduce to level 0)
zM # close ALL folds (fold everything)
# Navigation in/around folds:
zj # next fold start (down)
zk # previous fold end (up)
[z # start of current open fold
]z # end of current open fold
# Move with folds intact (don't open):
# Use j/k normally — they may skip closed folds
# Set 'foldopen' to control what opens foldsNavegación y edición con pliegues
j/k pueden saltarse pliegues cerrados según 'foldopen'. zj/zk navegan entre los límites de los pliegues. yy/dd sobre una línea plegada operan sobre TODAS las líneas plegadas como unidad (por líneas). Escribir dentro de un pliegue cerrado lo abre. Configura 'foldopen' para controlar qué movimientos abren pliegues (p. ej., quita 'search' para mantenerlos cerrados al buscar).
# Fold-related motions:
zj # next fold start (move down)
zk # previous fold end (move up)
[z # start of current open fold
]z # end of current open fold
# What opens a fold when triggered?
:set foldopen=block,hor,mark,percent,quickfix,
search,tag,undo
# Defaults open folds on most motions.
# To make j/k NOT open folds:
:set foldopen-=block
# Editing a closed fold:
# Typing inside a closed fold opens it.
# 'o' or 'O' on a fold line opens a new line.
# Search inside closed folds:
# Default behavior depends on 'foldopen'.
# :set foldopen-=search # don't open on search
# Yank/paste on folded lines:
# yy yanks ALL lines in the fold (linewise)
# dd deletes ALL lines in the fold
# Paste over a fold:
# p with a linewise register replaces the folded regionOpciones de plegado
foldlevel controla la profundidad a la que los pliegues siguen abiertos (más alto = más abiertos). foldlevelstart=99 empieza con la totalidad abierta. foldcolumn muestra una barra lateral con indicadores del estado de los pliegues. foldminlines evita pliegues diminutos. Para persistir los pliegues entre sesiones, :mkview en BufWinLeave y :loadview en BufWinEnter — un patrón autocmd habitual.
:set foldmethod=indent # folding method
:set foldlevel=2 # show folds deeper than this
:set foldlevelstart=99 # start with all folds open
:set foldminlines=3 # min lines to form a fold
:set foldcolumn=4 # 4-char column showing fold state
:set foldenable # enable folding (default on)
:set foldclose=all # auto-close folds when cursor leaves
:set foldopen=block,hor,mark,percent,quickfix,search,tag,undo
:set foldtext=foldtext() # text to show on a closed fold
:set fillchars=fold:\ , # chars for fold display
# Common combo for code:
:set foldmethod=indent
:set foldlevelstart=10
:set foldnestmax=10 # max nesting depth
# Custom fold text:
:set foldtext=MyFoldText()
function MyFoldText()
return '+++ ' . (v:foldend - v:foldstart + 1) . ' lines +++'
endfunction
# Persistent folds across sessions:
:set viewoptions=folds,cursor
:autocmd BufWinLeave * mkview
:autocmd BufWinEnter * silent loadviewPliegues anidados y nivel de plegado
Los pliegues se anidan jerárquicamente. 'foldlevel' determina el nivel más profundo que queda abierto — foldlevel=0 lo cierra por completo, 99 lo abre por completo. zr/zm ajustan de 1 en 1, zR/zM son los extremos. 'foldnestmax' limita la profundidad de anidamiento para evitar pliegues descontrolados en código muy anidado. Las funciones foldtext personalizadas te permiten controlar qué se muestra en un pliegue cerrado.
# Folds can nest. 'foldlevel' controls which are open:
:set foldlevel=0 # all folds closed
:set foldlevel=1 # only top-level open
:set foldlevel=99 # all open
# Display current fold level:
:echo &foldlevel
# Increase/decrease by 1:
zr # reduce (open one level everywhere)
zm # more (close one level everywhere)
zR # open ALL folds (set foldlevel to 99)
zM # close ALL folds (set foldlevel to 0)
# Limit nesting:
:set foldnestmax=10
# Each indent level adds a fold level.
# Useful for deeply-nested code:
# function outer() {
# function inner() { <- foldlevel 2
# function deep() { <- foldlevel 3
# }
# }
# }
# Custom foldtext for nested folds:
:set foldtext=NeatFoldText()
function! NeatFoldText()
let line = getline(v:foldstart)
let n = v:foldend - v:foldstart + 1
return line . ' (' . n . ' lines)'
endfunctionVentanas divididas (splits)
Dividir ventanas
:split/:vsplit dividen la ventana actual — ambas muestran el mismo buffer por defecto (los cambios se sincronizan). :split file abre un archivo en un split nuevo. :new/:vnew crean buffers vacíos. Ctrl-w s/v son los atajos de teclado. Un prefijo numérico fija el tamaño de la ventana nueva (:10split crea una ventana de 10 filas).
:split / :sp # horizontal split (current file)
:vsplit / :vs # vertical split (current file)
:split file.txt # split + open file
:vsplit file.txt # vsplit + open file
:new # horizontal split with empty buffer
:vnew # vertical split with empty buffer
:5split / :5vsplit # split with 5 rows/cols
# Quick splits (Normal mode):
Ctrl-w s # split horizontally (same as :split)
Ctrl-w v # split vertically (same as :vsplit)
Ctrl-w n # new horizontal split (empty)
Ctrl-w q # close window (same as :q)
# Split with size hints:
:10split file.txt # split with height 10
:vert 30split file # vertical split with width 30
# Reopen current file in a new split:
Ctrl-w s # same buffer, two views (sync scroll optional)Navegación entre ventanas
Ctrl-w seguido de h/j/k/l navega entre ventanas (mnemotecnia: hjkl como el movimiento). Ctrl-w w cicla a la ventana siguiente. Para ir rápido, muchos usuarios mapean Ctrl-h/j/k/l directamente a la navegación de ventanas. Ctrl-w p vuelve a la ventana usada anteriormente — útil al saltar entre dos ventanas.
Ctrl-w h # left window
Ctrl-w j # below window
Ctrl-w k # above window
Ctrl-w l # right window
Ctrl-w w # cycle to next window (wraps)
Ctrl-w W # cycle to previous window
Ctrl-w t # top-left window
Ctrl-w b # bottom-right window
Ctrl-w p # previous (last accessed) window
# Faster (with mapping):
:nmap <C-h> <C-w>h
:nmap <C-j> <C-w>j
:nmap <C-k> <C-w>k
:nmap <C-l> <C-w>l
# In terminal mode:
Ctrl-w N # exit terminal mode (to Normal)
Ctrl-w h/j/k/l # navigate (after exiting terminal mode)
# List windows in current tab:
:ls # also shows windows' buffersRedimensionar ventanas
Ctrl-w +/-/</> ajustan el tamaño en 1; antepón un conteo (10 Ctrl-w +) para pasos mayores. Ctrl-w _ maximiza la altura, Ctrl-w | maximiza la anchura. Ctrl-w = iguala todas las ventanas. Para precisión, usa :resize N (altura) y :vertical resize N (anchura). Con 'mouse=a', puedes arrastrar las líneas de estado y los separadores directamente.
Ctrl-w = # equalize all window sizes
Ctrl-w + # increase height by 1
Ctrl-w - # decrease height by 1
Ctrl-w > # increase width by 1
Ctrl-w < # decrease width by 1
Ctrl-w _ # maximize height (current window)
Ctrl-w | # maximize width (current window)
10 Ctrl-w + # increase height by 10
# Ex commands for precise resize:
:resize 20 # set height to 20 (horizontal split)
:resize +5 # increase height by 5
:resize -5 # decrease height by 5
:vertical resize 80 # set width to 80 (vertical split)
:vertical resize +10 # increase width by 10
# Mouse: drag the status line / vertical separator
# (with :set mouse=a)
# Auto-resize on split:
:set equalalways # default: auto-equalize on split/close
:set noequalalways # don't auto-resizeMover ventanas
Ctrl-w H/J/K/L mueven la ventana actual a los bordes extremos (mayúscula = pantalla completa en ese lado). Ctrl-w r/R rotan las ventanas dentro del layout. Ctrl-w x intercambia con la ventana siguiente. Ctrl-w T mueve una ventana a una pestaña nueva. Un truco elegante: Ctrl-w K/H también convierte entre orientación horizontal y vertical.
Ctrl-w H # move current window to far LEFT (full height)
Ctrl-w J # move current window to BOTTOM (full width)
Ctrl-w K # move current window to TOP (full width)
Ctrl-w L # move current window to far RIGHT (full height)
Ctrl-w r # rotate windows DOWN/RIGHT
Ctrl-w R # rotate windows UP/LEFT
Ctrl-w x # exchange current window with next
Ctrl-w T # move current window to a NEW tab page
# Move split orientation:
Ctrl-w K # if vertical, become horizontal (and move to top)
Ctrl-w H # if horizontal, become vertical (and move to left)
# Example: convert a vertical split to horizontal:
:vsplit # creates vertical split
Ctrl-w H # moves it to the left, becoming horizontal
# Reopen current buffer in a new tab:
Ctrl-w T # current window moves to a new tabOrganizar ventanas
Ctrl-w = iguala los tamaños de las ventanas. :ball abre una ventana por buffer — útil para ver la totalidad a la vez. Ctrl-w r/R rotan las ventanas dentro del layout. Para guardar y restaurar un layout de ventanas completo (incluyendo buffers, pliegues, etc.), usa :mksession y :source. Cada pestaña mantiene su propio layout de ventanas.
# Equalize window sizes:
Ctrl-w = # equalize height and width
# Stack layouts:
# Vertical splits side by side, horizontal splits stacked
# Example setup:
# :vsplit -> | win1 | win2 |
# :split -> | win1 | win3 |
# | | win2 |
# Cycle through layouts (with plugins like golden-ratio,
# or use built-in rotation):
Ctrl-w r # rotate down/right
Ctrl-w R # rotate up/left
# Distribute buffers across windows:
:ball # one window per buffer (horizontal)
:vertical ball # one window per buffer (vertical)
# Layouts persist within a tab page.
# Save current layout to a session:
:mksession mylayout.vim
# Restore:
:source mylayout.vim
# Tab page = a collection of windows
:tabnew # new tab with one windowCerrar ventanas
:q cierra una ventana (y sale de Vim si es la última). :close (o Ctrl-w c) cierra una ventana pero no la última. :only (Ctrl-w o) cierra todas las demás ventanas. Con 'hidden' activado, cerrar una ventana con un buffer modificado lo oculta en lugar de forzar una decisión de guardado. :only! fuerza el cierre de las demás aunque estén modificadas.
:q / :quit # close current window (errors if last)
:q! # close without saving
:wq # save and close
:close / Ctrl-w c # close window (won't close last)
:only / Ctrl-w o # close all OTHER windows
:hide # hide current buffer in window (close window)
# Save and close splits:
:xa # save all and exit (close all windows)
:wqa # same as :xa
# Closing a window with modified buffer:
# - :q prompts: "Save changes?"
# - :q! discards
# - :wq saves and closes
# - :hide (with 'hidden' set) keeps buffer in memory
# Close every window except the current:
:only # or Ctrl-w o
# Errors if other windows have unsaved changes:
:only! # force-close other windows
# When you close the last window, Vim exits.
# To prevent accidental exit:
:q! on last window still exits Vim.Pestañas (tabs)
Crear pestañas
:tabnew/:tabedit crean una pestaña nueva. vim -p file1 file2 abre cada archivo en su propia pestaña al arrancar. Cada pestaña contiene una o más ventanas — una pestaña es un layout, no un único archivo. Ctrl-w T mueve la ventana actual a una pestaña nueva. Las pestañas son geniales para separar contextos de trabajo no relacionados (p. ej., una pestaña por área del proyecto).
:tabnew # new tab with empty buffer
:tabedit file.txt # new tab opening file
:tab split # new tab with current buffer in a split
:tabfind file.txt # new tab, find file in 'path'
# Open multiple files in tabs at startup:
vim -p file1.txt file2.txt file3.txt
# From inside Vim, open files in tabs:
:args *.py | argdo tabe %
# Or one-by-one:
:tabe file1.txt
:tabe file2.txt
# Keyboard shortcut (common mapping):
:nmap <C-t> :tabnew<CR>
# Open current buffer in a new tab (move window):
# Ctrl-w T (move current window to a new tab page)
# Each tab page has its own window layout
# (multiple splits/windows per tab allowed)Navegación entre pestañas
gt/gT cambian de pestaña (modo Normal). Ngt salta directamente a la pestaña N (indexada desde 1). :tabs lista todas las pestañas y sus ventanas. Es habitual mapear Ctrl-Tab/Ctrl-Shift-Tab o <leader>1/2/3 para cambiar de pestaña rápido. Las pestañas dan la vuelta por defecto. Cada pestaña mantiene su propio layout de ventanas (splits, etc.).
:tabnext / :tabn # next tab
:tabprevious / :tabp # previous tab
:tabfirst / :tabr # first tab
:tablast / :tabl # last tab
gt # next tab (Normal mode)
gT # previous tab
3gt # go to tab 3
:tabn 3 # go to tab 3 (Ex command)
# Common mappings (Vim default):
:nmap <C-Tab> :tabnext<CR>
:nmap <C-S-Tab> :tabprevious<CR>
# Or use leader keys:
:nmap <leader>1 1gt
:nmap <leader>2 2gt
:nmap <leader>3 3gt
# Cycle behavior:
# gt at last tab wraps to first
# gT at first tab wraps to last
# To disable wrap:
:set tabpagemax=50 # max tabs (not wrap-related)
# Show all tabs:
:tabs # list tabs with their windowsOperaciones con pestañas
:tabc cierra la pestaña actual; :tabo cierra todas las demás. :tabm N mueve la pestaña actual a la posición N (0 = primera). :tabdo ejecuta un comando Ex en cada pestaña — útil para operaciones globales en espacios de trabajo separados por pestañas. Cerrar una pestaña cierra todas sus ventanas; los buffers modificados se conservan si 'hidden' está activado.
:tabclose / :tabc # close current tab
:tabclose! / :tabc! # force close (discard changes)
:tabonly / :tabo # close all OTHER tabs
:tabonly! / :tabo! # force close others
# Reorder tabs:
:tabmove / :tabm 0 # move current tab to position 0 (first)
:tabm # move to last position
:tabm 2 # move to position 2
:tabm +1 # move right by 1
:tabm -1 # move left by 1
# Quick keyboard reordering (no default, common mapping):
:nmap <leader>tm :tabmove<Space>
# Run a command in every tab:
:tabdo cmd # run cmd in every tab page
# Example:
:tabdo %s/old/new/ge # substitute in every tab's first window
# Each tab can hold multiple windows/splits.
# 'Tabclose' closes all windows in the tab.Layout de pestañas y multi-ventana
Cada pestaña mantiene un layout de ventanas independiente (splits, tamaños, posiciones). Puedes tener varias ventanas por pestaña. Ctrl-w T mueve una ventana a su propia pestaña nueva. :set showtabline=2 muestra siempre la barra de pestañas. Las pestañas se usan mejor como separadores de espacios de trabajo (p. ej., una pestaña por área del proyecto), cada una con su propio layout.
# Each tab page has its own window layout.
# Create a tab with a 3-window layout:
:tabnew # new tab
:vsplit # split vertically (2 windows)
:split # split horizontally (3 windows)
# Now tab has: [win1] [win2]
# [win3]
# Add a buffer to current tab:
:e file.txt # replaces current window's buffer
# Move a window to its own tab:
Ctrl-w T # window becomes a new tab page
# Show tab line (always):
:set showtabline=2 # 0=never, 1=multi-tab, 2=always
# Tab page-local options:
:setlocal ... # option applies only to current tab's windows
:tabdo setlocal ... # apply across all tabs
# Tab label customization (status line):
:set guitablabel=%t # show filename in GUI tab label
# Common use case: one tab per project area:
# Tab 1: source files
# Tab 2: tests
# Tab 3: docs
# Each with its own split layout.Opciones y etiquetas de pestañas
showtabline controla la barra de pestañas (0=nunca, 1=solo con varias pestañas, 2=siempre). Puedes personalizar por completo la tabline con una función que devuelva el string de formato — útil para mostrar estado de modificación, nombres de buffer, números de pestaña. guitablabel/guitabtooltip personalizan el Vim gráfico. Las pestañas se numeran desde 1.
:set showtabline=2 # always show tab bar (0=never, 1=auto)
:set tabpagemax=50 # max tabs creatable
:set hidden # allow switching tabs with unsaved changes
# Custom tab labels (terminal Vim):
:set tabline=%!MyTabLine()
function! MyTabLine()
let s = ''
for i in range(tabpagenr('$'))
let n = i + 1
let s .= '%' . n . 'T'
let s .= (n == tabpagenr() ? '%#TabLineSel#' : '%#TabLine#')
let s .= ' [' . n . '] '
let buflist = tabpagebuflist(n)
let bufname = bufname(buflist[0])
let s .= empty(bufname) ? '[No Name]' : fnamemodify(bufname, ':t')
let s .= ' '
endfor
let s .= '%T%#TabLineFill#'
return s
endfunction
# GUI tab labels:
:set guitablabel=%t # show filename
:set guitabtooltip=%f # show full path on hover
# Quickly switch with number:
:nmap <leader>t :tabs<CR>Comandos de pestañas
:tabs lista las pestañas y sus ventanas. :tabdo ejecuta un comando Ex en cada pestaña. :tab ball abre cada buffer en su propia pestaña. <C-w>gf abre el archivo bajo el cursor en una pestaña nueva. Usa pestañas para agrupar archivos relacionados (una pestaña por función/área). Para operaciones entre pestañas, :tabdo es la herramienta — combínalo con windo para pestañas multi-ventana.
:tabs # list all tabs and their windows
:tabdo cmd # run cmd in every tab
:tab ball # open each buffer in its own tab
:tab help subject # open help in a new tab
:tab split # split current window into new tab
# Quickly duplicate a tab's layout:
# (no built-in, but possible with sessions)
# Or manually: create a new tab, re-open buffers
# Open file under cursor in a new tab:
:nmap gf :tabe <cfile><CR>
# (or use the built-in <C-w>gf)
# Common workflow:
# 1. Group related files in tabs
# 2. Use gt/gT to switch
# 3. Use :tabdo for cross-tab operations
# Save all tabs' buffers:
:tabdo windo w # write every window in every tab
# (or simpler)
:wall # write all buffers (across all tabs)
# Close all tabs but keep buffers:
# (no single command — use :tabo + :b then :bd)Configuración (.vimrc)
Conceptos básicos de vimrc
$MYVIMRC es la ruta de tu archivo vimrc — :edit $MYVIMRC lo abre, :source $MYVIMRC lo recarga tras editar. El runtimepath controla dónde busca Vim los archivos de sintaxis, plugins, etc. Usa :verbose set option? para ver dónde se fijó una opción por última vez — inestimable para depurar plugins en conflicto.
# vimrc location:
# Unix: ~/.vimrc (or ~/.vim/vimrc)
# Windows: ~/_vimrc (or ~/vimfiles/vimrc)
# Neovim: ~/.config/nvim/init.vim
# Reload vimrc after editing:
:source $MYVIMRC # or :so %
# Edit vimrc quickly:
:edit $MYVIMRC # $MYVIMRC = path to your vimrc
# Runtime path (where Vim looks for scripts):
:set runtimepath?
# Add a custom path:
:set runtimepath+=~/.vim/custom
# Conditional config (only in terminal Vim):
if !has('gui_running')
set mouse=a
endif
# Per-filetype settings (in vimrc or ftplugin/):
:autocmd FileType python setlocal expandtab shiftwidth=4
# Check where an option was set:
:verbose set tabstop?Ajustes básicos
Estos son ajustes comunes de calidad de vida. relativenumber + number muestra numeración híbrida — números de línea relativos al cursor para saltar fácil, con el absoluto en la línea actual. showmatch destella el corchete coincidente. wildmenu mejora el autocompletado de :comandos con un menú. scrolloff mantiene el contexto visible alrededor del cursor — nunca edites en el borde de la pantalla.
set nocompatible # Vim mode (not Vi)
set number # show line numbers
set relativenumber # relative line numbers (great for jumps)
set cursorline # highlight current line
set cursorcolumn # highlight current column
set showcmd # show partial commands in status
set showmode # show current mode (insert, visual...)
set showmatch # highlight matching brackets
set wildmenu # better command-line completion
set wildmode=longest:full,full # completion style
set laststatus=2 # always show status line
set ruler # show cursor position
set backspace=indent,eol,start # backspace through everything
set encoding=utf-8 # default encoding
set scrolloff=5 # keep 5 lines above/below cursor
set sidescrolloff=5 # keep 5 cols left/right of cursor
set mouse=a # enable mouse (all modes)Indentación
tabstop controla cuántas columnas muestra un carácter de tabulación. shiftwidth es la cantidad de indentación que usan <<, >> y autoindent. softtabstop hace que Backspace quite el número correcto de columnas incluso con expandtab desactivado. expandtab convierte tabulaciones en espacios — recomendado por consistencia. :retab convierte las tabulaciones/espacios existentes tras cambiar los ajustes.
set autoindent # copy indent from previous line
set smartindent # smart auto-indent for code (basic)
set cindent # C-style indenting (more language-aware)
set expandtab # use spaces instead of tabs
set tabstop=4 # tab key inserts 4-column tabs visually
set shiftwidth=4 # indent/outdent amount (<<, >>, autoindent)
set softtabstop=4 # backspace removes 4 cols even with tabs
set shiftround # round indent to multiple of shiftwidth
set smarttab # tab key respects shiftwidth at line start
# Toggle tabs vs spaces:
:set expandtab! # toggle
:retab # convert existing tabs<->spaces
# Filetype-specific indent:
:filetype plugin indent on
# Then in ~/.vim/ftplugin/python.vim:
# setlocal expandtab shiftwidth=4
# Quick indent/dedent in Normal mode:
>> # indent current line
<< # dedent current line
5>> # indent 5 linesAjustes de búsqueda
ignorecase + smartcase es la combinación recomendada: sin distinguir mayúsculas salvo que tu patrón tenga alguna. hlsearch resalta todas las coincidencias; incsearch muestra las coincidencias incrementalmente mientras escribes. Mapeo habitual: <leader>h alterna hlsearch, o :noh limpia el resaltado actual. Vim 8.2+ puede mostrar el conteo de la búsqueda vía shortmess.
set ignorecase # case-insensitive search
set smartcase # case-sensitive if pattern has uppercase
set hlsearch # highlight all matches (hls)
set incsearch # show match as you type (is)
set wrapscan # wrap search around end of file (ws)
# Toggle search highlight:
:nmap <leader>h :set hlsearch!<CR>
# Or clear current highlight:
:nmap <leader>nh :nohlsearch<CR>
# Show search count (Vim 8.2+):
:set shortmess-=S
:set shortmess+=S # search stats in command line
# Search in visual selection:
:vmap * y/\V<C-R>"<CR>
# Use very-magic mode by default (advanced):
# No built-in, but a search mapping can prepend \v
# Improved '*' (don't jump on first press):
:nmap * *N
# Disable highlighting until next search:
:nohlsearchAjustes de visualización
wrap + linebreak cortan las líneas largas en límites de palabra (no a mitad de palabra) para legibilidad. list + listchars revelan tabulaciones, espacios finales y espacios duros. colorcolumn marca una columna (p. ej., 80 para límites de longitud de línea). termguicolors activa el color real de 24 bits en terminales modernos. splitright/splitbelow controlan dónde aparecen los splits nuevos.
set wrap # wrap long lines
set linebreak # wrap at word boundaries (not mid-word)
set textwidth=80 # auto-wrap at 80 chars when typing
set showbreak=+++ # marker for wrapped lines
set list # show invisible chars
set listchars=tab:>-,trail:.,extends:>,precedes:<
set fillchars=fold:-,vert:\| # chars for folds/vsplits
set colorcolumn=80 # highlight column 80
set signcolumn=yes # always show sign column (LSP)
set conceallevel=0 # don't conceal chars
set splitright # new vsplit on the right
set splitbelow # new split below
set termguicolors # 24-bit color (if terminal supports)
set background=dark # or 'light' — adjusts color scheme
# Color scheme:
:colorscheme desert
# Or with a plugin (e.g. vim-colors-solarized):
:colorscheme solarizedMapear teclas
Usa SIEMPRE las variantes *noremap (nnoremap, vnoremap, etc.) para tus mapeos personales — no son recursivos, evitando comportamientos inesperados. <leader> es una tecla prefijo personalizable (por defecto la barra invertida; muchos la cambian a coma o espacio). <CR> es Enter, <Esc> es escape, <C-x> es Ctrl-X. Mapea atajos de leader para comandos comunes como guardar/salir.
# Map families:
:map # normal, visual, select, operator-pending
:nmap # normal mode only
:imap # insert mode only
:vmap # visual + select mode
:xmap # visual mode only
:smap # select mode only
:omap # operator-pending mode only
:cmap # command-line mode only
:tmap # terminal mode only
# Non-recursive (RECOMMENDED):
:nnoremap # normal mode, non-recursive
:vnoremap # visual mode, non-recursive
:inoremap # insert mode, non-recursive
:cnoremap # command-line mode, non-recursive
# Examples:
nnoremap <leader>w :w<CR> # save with leader-w
nnoremap <leader>q :q<CR> # quit
inoremap jk <Esc> # Esc with jk
nnoremap <C-h> <C-w>h # window nav
# Leader key (default is \):
:let mapleader = ','
:let maplocalleader = '\\'
# Special keys:
# <CR> <Esc> <Tab> <Space> <C-x> <A-x> <M-x> <F1>-<F12>
# <Up> <Down> <Left> <Right> <leader> <localleader>Plugins (vim-plug)
Conceptos básicos de vim-plug
vim-plug es el gestor de plugins moderno más popular. Declara los plugins entre call plug#begin y plug#end. Cada línea Plug especifica un repo de GitHub (user/repo). Tras añadir plugins, :source $MYVIMRC y luego :PlugInstall los descarga. Puedes fijar una tag, rama o commit por estabilidad. Los plugins se instalan en el directorio 'plugged'.
# Installation (Unix):
# curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
# https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# In vimrc:
call plug#begin('~/.vim/plugged')
Plug 'junegunn/fzf.vim' " GitHub repo: user/repo
Plug 'tpope/vim-surround' " another plugin
Plug 'morhetz/gruvbox' " colorscheme
Plug 'preservim/nerdtree' " file explorer
call plug#end()
# After editing vimrc:
:source $MYVIMRC # or restart Vim
:PlugInstall # install all declared plugins
# Plugin directory structure:
# ~/.vim/plugged/<plugin-name>/
# Pin to a specific commit/tag/branch:
Plug 'tpope/vim-fugitive', { 'tag': 'v3.0' }
Plug 'user/repo', { 'branch': 'dev' }
Plug 'user/repo', { 'commit': 'abc123' }Comandos de gestión de plugins
:PlugInstall instala plugins nuevos, :PlugUpdate actualiza la totalidad, :PlugClean elimina los no listados, :PlugStatus muestra su estado. El hook 'do' ejecuta un comando tras instalar — útil para plugins que necesitan compilar o instalar binarios. Las opciones 'on'/'for' activan la carga perezosa (cargar solo cuando un comando/filetype lo dispara) — mejora el tiempo de arranque.
:PlugInstall # install newly added plugins
:PlugUpdate # update all plugins
:PlugClean # remove plugins no longer in vimrc
:PlugStatus # show plugin status (loaded, errored)
:PlugUpgrade # update vim-plug itself
:PlugDiff # review changes from last update
:PlugSnapshot # generate a snapshot of plugin versions
# Post-install hooks:
Plug 'user/repo', { 'do': ':GoInstallBinaries' }
Plug 'user/repo', { 'do': './install.sh' }
Plug 'user/repo', { 'do': 'npm install' }
# Lazy loading (load only when needed):
Plug 'user/repo', { 'on': 'CommandName' } " on command
Plug 'user/repo', { 'for': 'python' } " for filetype
Plug 'user/repo', { 'on': ['Cmd1', 'Cmd2'] }
# Frozen plugin (don't update):
Plug 'user/repo', { 'frozen': 1 }
# Disable a plugin temporarily:
# (no built-in, but comment out the Plug line and :PlugClean)Plugins esenciales comunes
Esenciales habituales: fzf para búsqueda difusa de archivos/buffers/texto (mucho más rápido que :find), vim-surround para editar comillas/corchetes/etiquetas alrededor del texto, vim-fugitive para integración con Git, vim-commentary para comentar rápido (operador gc), NERDTree para un explorador de archivos lateral, vim-airline para una línea de estado más bonita, y un buen colorscheme como gruvbox.
" Fuzzy finder (requires fzf binary):
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
" :Files :GFiles :Buffers :Rg
" Surround (cs/ds/ys for surroundings):
Plug 'tpope/vim-surround'
" cs"' change " to '
" ds" delete surrounding "
" ysiw) surround word with ()
" Fugitive (Git integration):
Plug 'tpope/vim-fugitive'
" :G :Gstatus :Gcommit :Gpush
" Commentary (gc to toggle comments):
Plug 'tpope/vim-commentary'
" gcc comment line
" gc{motion} comment motion
" NERDTree (file explorer sidebar):
Plug 'preservim/nerdtree'
" :NERDTree :NERDTreeToggle
" Airline (status line):
Plug 'vim-airline/vim-airline'
" Gruvbox (colorscheme):
Plug 'morhetz/gruvbox'Configuración de plugins
Usa 'on'/'for' para cargar plugins con pereza — solo se cargan cuando se disparan, mejorando el arranque. La configuración específica de cada plugin suele usar variables g:pluginname_var fijadas en el vimrc, O archivos en ~/.vim/after/plugin/. El hook 'do' corre tras instalar/actualizar para los pasos de compilación. Fijar g:loaded_pluginname=1 en el vimrc impide que un plugin cargue en absoluto.
" Lazy load on command:
Plug 'tpope/vim-fugitive', { 'on': 'Git' }
" Lazy load on filetype:
Plug 'fatih/vim-go', { 'for': 'go' }
" Multiple triggers:
Plug 'junegunn/fzf.vim', { 'on': ['Files', 'Buffers', 'Rg'] }
" Post-install hook:
Plug 'dense-analysis/ale', { 'do': 'npm install' }
" Configuration AFTER plugin loads:
Plug 'preservim/nerdtree'
let g:NERDTreeShowHidden = 1
let g:NERDTreeWinSize = 30
nmap <leader>n :NERDTreeToggle<CR>
" Configuration in AFTER/plugin-name.vim:
" (alternative to setting g: vars in vimrc)
" ~/.vim/after/plugin/nerdtree.vim:
" let g:NERDTreeShowHidden = 1
" Disable plugin entirely:
let g:loaded_nerdtree = 1 " prevent loadingCarga de plugins y runtime
Vim evalúa los archivos plugin/*.vim al arrancar en orden de directorios, y after/plugin/*.vim al final (para sobrescribir). :scriptnames lista la totalidad de lo evaluado — inestimable para depurar. :verbose map <tecla> muestra dónde se definió un mapeo; :verbose set option? hace lo mismo con las opciones. Los archivos autoload/ se cargan con pereza cuando sus funciones se llaman por primera vez.
" Plugin loading sequence:
" 1. Vim starts, reads vimrc
" 2. plug#begin / plug#end registers plugins
" 3. Runtime path is updated to include plugin dirs
" 4. plugin/*.vim files are sourced (in directory order)
" 5. after/plugin/*.vim files are sourced last
" Check if a plugin is loaded:
:echo exists('g:loaded_fugitive')
:scriptnames # list all sourced scripts in order
" Manually source a plugin:
:source ~/.vim/plugged/foo/plugin/foo.vim
" Find where a mapping was defined:
:verbose map <leader>w
" Find where an option was set:
:verbose set formatprg?
" Plugin runtime files:
" plugin/ - loaded at startup
" ftplugin/ - loaded for specific filetypes
" syntax/ - syntax highlighting
" indent/ - indentation rules
" autoload/ - lazily-loaded functions
" after/ - sourced last (overrides)
" Helptags for plugin docs:
:Helptags (vim-plug generates these on install)Gestores de plugins alternativos
Además de vim-plug, hay opciones como Vundle (API similar, menos funciones), Pathogen (el más simple — solo añade directorios bundle al runtimepath), Dein.vim (rápido, centrado en la carga perezosa) y los packages integrados de Vim 8+ (no hace falta gestor — suelta los plugins en pack/<name>/start/). Para usuarios de Neovim, Packer (basado en Lua) es popular. Los packages integrados son perfectos para minimalistas.
" 1. Vundle (older, similar to vim-plug):
" set rtp+=~/.vim/bundle/Vundle.vim
" call vundle#begin()
" Plugin 'tpope/vim-surround'
" call vundle#end()
" 2. Pathogen (just adds dirs to runtimepath):
" Execute:
" git clone https://github.com/tpope/vim-pathogen ~/.vim/bundle
" In vimrc:
" execute pathogen#infect()
" Then clone plugins into ~/.vim/bundle/
" 3. Dein.vim (modern, lazy-loading focused):
" set runtimepath+=~/.cache/dein/repos/github.com/Shougo/dein.vim
" if dein#load_state('~/.cache/dein')
" call dein#begin('~/.cache/dein')
" call dein#add('tpope/vim-surround')
" call dein#end()
" call dein#save_state()
" endif
" 4. Vim 8+ built-in packages (NO plugin manager needed):
" Place plugins in:
" ~/.vim/pack/<name>/start/<plugin>/ " loaded at startup
" ~/.vim/pack/<name>/opt/<plugin>/ " loaded on demand
" Load an opt plugin: :packadd <plugin>
" 5. Packer (Neovim Lua):
" require('packer').startup(function()
" use 'tpope/vim-surround'
" end)Movimiento avanzado
Búsqueda de caracteres (f/F/t/T)
f/F encuentran el siguiente/anterior carácter en la línea actual (el cursor cae sobre él); t/T se mueven hasta justo antes/después de él. ; repite la última f/F/t/T en la misma dirección, , en la opuesta. Combínalo con operadores: dt, borra hasta (sin incluir) la siguiente coma, df. borra hasta el siguiente punto. Rápido y preciso para navegar dentro de la línea.
f{x} # find next char 'x' on line (cursor ON x)
F{x} # find previous char 'x' (cursor ON x)
t{x} # till next char 'x' (cursor BEFORE x)
T{x} # till previous char 'x' (cursor AFTER x)
; # repeat last f/F/t/T (same direction)
, # repeat last f/F/t/T (opposite direction)
# Examples (cursor on 'a' in "hello world abc"):
# fw -> cursor on 'w' (world)
# tw -> cursor on space before 'w'
# Fo -> cursor on 'o' (hello) - backwards
# ; -> next 'w'... or next match of last
# Combined with operators:
dt, # delete up to (not including) next ','
df. # delete up to AND including next '.'
ct; # change up to next ';'
yt: # yank up to next ':'
# Find on a long line (no built-in multi-line f):
# Use :s or search for multi-line patterns.
# Set 'hlsearch' to highlight f/F/t/T targets:
:set hlsearch " doesn't highlight f, but / does.Movimiento por frases y párrafos
( y ) se mueven por frases (las frases terminan con . ! ? más espacio); { y } se mueven por párrafos (separados por líneas en blanco). En líneas envueltas, gj/gk/g0/g$ operan sobre líneas visuales de pantalla mientras j/k/0/$ operan sobre líneas lógicas — esencial con 'wrap' activado. Combina ( ) { } con operadores: das borra una frase, yap copia un párrafo.
( # previous sentence start
) # next sentence start
{ # previous paragraph start (blank-line delimited)
} # next paragraph start
# Sentence boundaries: ends with . ! ? followed by
# whitespace or end of paragraph.
# Paragraph: block of lines separated by blank lines.
# Examples:
# Hello world. This is a sentence.
# ^ ^ ^
# ( ) ( moves to sentence starts
# Combine with operators:
das # delete a sentence
cis # change inside sentence
yap # yank a paragraph
dip # delete inside paragraph
# Move by visual line (with 'wrap' on):
gj # down one screen line (wrap-aware)
gk # up one screen line
g0 # start of screen line
g$ # end of screen line
g_ # last non-blank of screen line
# These respect wrapping where j/k don't.Pares coincidentes (%)
% salta entre corchetes coincidentes (por defecto: (), [], {}). También funciona con #if/#endif y /* */ si 'matchpairs' está configurado en consecuencia. Combínalo con operadores: d% borra desde el cursor hasta la coincidencia, v% la selecciona. [( [{ ]) ]} saltan a los corchetes sin pareja — útil para encontrar el bloque de función/clase que lo envuelve.
% # jump to matching bracket: ( ) [ ] { }
# also works on #if/#endif, /* */ with matching pairs
# In Normal mode:
% # if cursor on (, jumps to matching )
% # if cursor on ), jumps to matching (
# Combine with operators:
d% # delete from cursor to matching bracket
c% # change from cursor to matching bracket
y% # yank from cursor to matching bracket
v% # visually select from cursor to matching bracket
# Extend matching to other pairs:
:set matchpairs+=<:>
:set matchpairs+=«:»
# Default: (:),[:],{:}
# Move to enclosing bracket:
# [( # back to unmatched (
# ]) # forward to unmatched )
# [{ # back to unmatched {
# ]} # forward to unmatched }
# [} / ]{ similar for braces
# Example: jump to outer function's opening brace:
[{ " previous unmatched {Movimiento por pantalla
H/M/L saltan a la parte superior/central/inferior de la pantalla visible. Ctrl-f/b desplazan páginas completas; Ctrl-d/u medias páginas (menos desorientador); Ctrl-e/y desplazan una línea sin mover el cursor. zz/zt/zb reposicionan la línea del cursor al centro/arriba/abajo de la pantalla — esencial para conservar el contexto. 'scrolloff' garantiza que el cursor nunca llegue al borde de la pantalla.
H # top of screen (High) — first non-blank
M # middle of screen
L # bottom of screen (Low) — first non-blank
N H # Nth line from top (e.g. 5H = 5 lines from top)
N L # Nth line from bottom
# Scrolling:
Ctrl-f # forward (down) full screen
Ctrl-b # backward (up) full screen
Ctrl-d # down half screen
Ctrl-u # up half screen
Ctrl-e # scroll down 1 line (cursor stays)
Ctrl-y # scroll up 1 line (cursor stays)
# Reposition cursor on screen:
zz # cursor line to middle of screen
zt # cursor line to top of screen
zb # cursor line to bottom of screen
z. # cursor to middle, first non-blank
z+ # cursor to bottom, scroll up (like zb but accepts count)
# Keep cursor off edges:
:set scrolloff=5 # always 5 lines above/below cursor
:set sidescrolloff=5 # 5 cols left/right of cursorDesplazamiento vinculado y sincronizado
:set scrollbind sincroniza el desplazamiento entre ventanas — actívalo en cada ventana que quieras sincronizar. :vimdiff abre dos archivos en modo diff con scrollbind activado, diferencias resaltadas por sintaxis y [c/]c para navegar los fragmentos. do (diff obtain) toma los cambios de la otra ventana, dp (diff put) los envía. Genial para comparar versiones de un archivo.
# Bind windows to scroll together:
:set scrollbind # current window syncs scroll
:set syncbind # force immediate sync
:scrollbind # same as :set scrollbind
# In each window you want synced:
# :set scrollbind
# Unbind:
:set noscrollbind
# Common use: diff two files side by side
:vimdiff file1 file2 # opens both, scrollbound, diff highlighted
:diffthis # mark current window as a diff
:diffoff # turn off diff mode for current window
:diffupdate # refresh diff highlighting
# Vertical diff split:
:vert diffsplit file2.txt
# In diff mode:
[c # previous diff hunk
]c # next diff hunk
do # diff obtain (pull from other window)
dp # diff put (push to other window)
# Bind but at different starting positions:
# Set scrollbind AFTER scrolling to desired positions.Ir a posiciones
Hay muchas formas de posicionar el cursor: :N para la línea N, N% para porcentaje, `.`/`"`/[`]/`</`> para marcas especiales (último cambio, última salida, último yank, último visual). Ctrl-o/Ctrl-i navegan la jumplist. `" restaura la posición al cerrar el archivo por última vez — combinado con un ajuste de viminfo, persiste entre sesiones.
:N # go to line N (e.g. :42)
Ng / N G # go to line N (e.g. 42G or 42gg)
gg # first line
G # last line
N% # go to N% of file (e.g. 50% = middle)
:-N # N lines before current (e.g. :-5)
:+N # N lines after current (e.g. :+10)
# Marks and jumps:
\`. # position of last change in this buffer
\`" # position when file was last closed
\`[ # start of last yanked/changed region
\`] # end of last yanked/changed region
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # last insert position (gi goes here + insert)
# Recent jumps:
Ctrl-o # back in jumplist
Ctrl-i # forward in jumplist
\`' # position before last jump (where you came from)
# File position on save:
:set viminfo^=% # remember buffer positions across sessions
# Cursor hold (no movement for 'updatetime' ms):
# CursorHold event triggers (advanced)Modo línea de comandos
Comandos con rango
Los rangos especifican a qué líneas afecta un comando. :% es el archivo entero (1,$). . es la línea actual, $ la última. '<,'> es la última selección visual (se rellena sola al pulsar : en modo visual). 'a,'b es de la marca a a la marca b. También puedes usar patrones de búsqueda como límites de rango: :/foo/,/bar/d borra de la línea que coincide con foo a la que coincide con bar.
# Range syntax: :{start},{end}command
# Range forms:
:% # whole file (1,$)
:1,10 # lines 1-10
:.,$ # current line to end of file
:1,. # first line to current
:'a,'b # from mark a to mark b
:'<,'> # last visual selection
:. # current line only
:N # line N only
:.,+5 # current line + 5 below
:.,-2 # current line - 2 above
# Examples:
:1,10d # delete lines 1-10
:%s/old/new/g # substitute whole file
:'<,'>s/old/new/g # substitute visual selection
:.,$j # join from current to end into one line
:5,10y a # yank lines 5-10 into register a
:g/pattern/m$ # move matching lines to end of file
# Search-based range:
:/start/,/end/d # delete from 'start' to 'end' patternsComandos de archivo
:w guarda, :e abre un archivo nuevo, :r inserta el contenido de otro archivo (o la salida de un comando de shell vía :r !cmd). :saveas guarda y cambia al archivo nuevo. :e! recarga el archivo descartando los cambios. ++enc/++ff especifican codificación/fines de línea explícitamente — útil para convertir archivos. :browse e abre un diálogo de archivos gráfico (en el Vim gráfico).
:w / :write # save current file
:w file.txt # save as new file
:w! file.txt # overwrite existing file
:w >> file.txt # append to file
:saveas / :sav file # save as new file and switch to it
:e / :edit file # open file (replace current buffer)
:e! # reload current file (discard changes)
:e # # edit alternate file
:r / :read file # insert file below cursor
:r !command # insert command output below cursor
:0r !date # insert date at top of file
# Multiple files:
:wa / :wall # write all buffers
:xa / :xall # write all and quit
:qa! # quit all without saving
# Browse file system:
:browse e # GUI file open dialog
:Explore # Netrw file browser
# File encoding:
:w ++enc=utf-8 # save as UTF-8
:e ++enc=latin1 file # open with specific encoding
# File format (line endings):
:w ++ff=unix # save as Unix line endingsComandos de buffer y ventana
Todas las operaciones multi-buffer/ventana/pestaña tienen forma de comando Ex. :b cambia de buffer, :sp/:vs dividen ventanas, :tabnew crea pestañas. La familia :*do (bufdo, argdo, tabdo, windo, cdo) ejecuta un comando sobre muchos objetivos — sumamente potente para operaciones por lotes. :ls muestra los buffers; :tabs las pestañas; :args la arglist.
# Buffer commands:
:b N / :buffer N # switch to buffer N
:b name # switch by name (tab-completes)
:bd / :bdelete # delete buffer
:bw / :bwipeout # wipe buffer (clears marks)
:ls / :buffers # list buffers
:bn / :bp # next / previous buffer
:b# # alternate buffer
# Window commands:
:sp / :split # horizontal split
:vs / :vsplit # vertical split
:new # split with empty buffer
:close # close window
:only # close all other windows
:qa / :qa! # quit all windows
# Tab page commands:
:tabnew # new tab
:tabe file # new tab with file
:tabc # close tab
:tabo # close other tabs
:tabs # list tabs
:tabn / :tabp # next / previous tab
# Argument list commands:
:args # show arg list
:n / :next # next arg file
:prev # previous arg file
:argdo cmd # run cmd on each arg fileFijar opciones
:set alterna opciones booleanas con !, fija valores con =, añade/quita con +=/-= y restablece a los valores por defecto con &. :set option? muestra el valor actual. :setlocal fija un valor local del buffer/ventana (no afecta a otros buffers). :set sin argumentos lista la totalidad de las opciones cambiadas; :set all lo muestra por completo. Tab completa los nombres de las opciones.
:set option # turn boolean option on
:set nooption # turn boolean option off
:set option! # toggle boolean
:set option? # show current value
:set option=value # set value
:set option+=value # append to value
:set option-=value # remove from value
:set option& # reset to default
:set all # show all options
:set # show changed options
# Local vs global:
:setlocal option # buffer/window-local only
:setglobal option # global value
# Examples:
:set number # show line numbers
:set nonumber # hide line numbers
:set number! # toggle
:set tabstop=4 # set tabstop to 4
:set formatoptions+=r # add 'r' to formatoptions
:set ignorecase& # reset ignorecase to default
# View all set options:
:set # shows only non-default values
# Find option with substring:
:set ic<tab> # tab-complete (ignorecase)Comandos de mapeo
Usa las variantes *noremap para tus mapeos personales — no son recursivos, evitando comportamientos inesperados. <leader> es un prefijo personalizable (por defecto la barra invertida; muchos lo cambian a espacio o coma). <buffer> hace que un mapeo sea local del buffer actual. Las teclas especiales usan <notación> como <CR>, <Esc>, <C-x> (Ctrl-X), <A-x> (Alt-X).
:map <key> <action> # generic map (most modes)
:nmap <key> <action> # normal mode
:imap <key> <action> # insert mode
:vmap <key> <action> # visual mode
:xmap <key> <action> # visual mode only
:smap <key> <action> # select mode
:omap <key> <action> # operator-pending mode
:cmap <key> <action> # command-line mode
:tmap <key> <action> # terminal mode
# Non-recursive (RECOMMENDED for personal mappings):
:nnoremap <key> <action> # normal mode
:vnoremap <key> <action> # visual mode
:inoremap <key> <action> # insert mode
:onoremap <key> <action> # operator-pending
:cnoremap <key> <action> # command-line
:tnoremap <key> <action> # terminal
# Buffer-local mappings:
:nnoremap <buffer> <key> <action>
# Clear a mapping:
:nunmap <key> # or :nmapclear (clears all normal maps)
# Special keys in mappings:
# <CR> <Esc> <Tab> <Space> <BS> <C-x> <A-x> <M-x>
# <F1>-<F12> <Up> <Down> <Left> <Right>
# <leader> <localleader> <C-r> <C-w>
:let mapleader = ' '
:let maplocalleader = '\\'Comandos Ex útiles
:!cmd ejecuta un comando de shell; :r !cmd inserta su salida en el buffer. :sort ordena líneas (u=únicas, n=numérico, !=inverso). :retab convierte entre tabulaciones y espacios. :normal ejecuta pulsaciones de modo normal como comando Ex — añade ! para ignorar los mapeos personalizados. :%!cmd pasa el archivo entero por un comando externo y lo reemplaza con la salida.
:!command # run shell command
:r !command # insert command output below cursor
:!! # repeat last :! command
:sh # open a shell (exit to return)
:terminal / :term # open terminal in a window
:read file # insert file contents below cursor
:sort # sort selected lines (visual mode)
:sort u # sort and remove duplicates
:sort n # numeric sort
:sort! # reverse sort
:retab # convert tabs to spaces (and vice versa)
:retab! # also convert in strings
:normal {cmds} # run normal-mode commands
:normal! {cmds} # ignore mappings (use raw keys)
# Execute Ex commands from a register:
:@a # run Ex commands in register 'a'
:@@ # repeat last :@
# Range + command examples:
:5,20s/old/new/g # substitute in lines 5-20
:%!sort # pipe whole file through sort
:'<,'>!column -t # format visual selection as columns
# Help:
:help :command # help on a specific commandConceptos básicos de Vimscript
Variables
Vimscript usa let para asignar y unlet para borrar. Las variables tienen ámbitos indicados por prefijos: g: (global), b: (buffer), w: (ventana), t: (pestaña), s: (script), l: (local de función), v: (integrada). const crea valores inmutables (Vim 8+). exists() comprueba si una variable está definida. Vim 8.2+ soporta interpolación de strings con $"...{expr}...".
let var = value # assignment
let var = "hello" # string
let var = 42 # number
let var = 3.14 # float
let var = [1, 2, 3] # list
let var = {"key": "val"} # dictionary
unlet var # delete a variable
# Variable scopes (prefix with letter + colon):
let g:global_var = 1 # global (everywhere)
let b:buffer_var = 1 # buffer-local
let w:window_var = 1 # window-local
let t:tab_var = 1 # tab-local
let s:script_var = 1 # script-local (this file only)
let l:local_var = 1 # function-local
let v:count # built-in Vim variable
# Constants (Vim 8+):
const PI = 3.14159
let g:CONFIG = #{name: "vim"} # locked dictionary
# Check if a variable exists:
if exists('var')
if exists('g:plugin_var')
# String interpolation (Vim 8.2+):
let name = "World"
echo $"Hello, {name}!"Funciones
function! Name(args) ... endfunction define una función — el ! permite redefinirla. a: accede a los argumentos; a:000 es la lista de argumentos variádicos. Los argumentos por defecto (Vim 8+) usan =value. Las lambdas (Vim 8+) son {args -> expr}. function('Name') devuelve una funcref que puedes pasar. Usa :call para invocar una función por sus efectos secundarios.
# Define a function:
function! MyFunc(arg1, arg2)
echo a:arg1 . ' ' . a:arg2
return a:arg1 + a:arg2
endfunction
# The ! in function! overrides an existing function
# (without ! Vim errors if function already exists).
# Call a function:
call MyFunc("hello", "world")
let result = MyFunc(1, 2)
# Variadic arguments (...):
function! Sum(...)
let total = 0
for i in a:000
let total += i
endfor
return total
endfunction
# Default arguments (Vim 8+):
function! Greet(name, greeting="Hello")
echo a:greeting . ', ' . a:name
endfunction
# Lambda / anonymous functions (Vim 8+):
let Square = {x -> x * x}
echo Square(5) " 25
# Function as a value:
let Fn = function('MyFunc')
echo Fn(1, 2)Condicionales y bucles
if/elseif/else/endif para condicionales. for recorre una lista (range(N) genera 0..N-1) y puede desempaquetar pares [key, val] de items(). while/endwhile para bucles con condición. break/continue funcionan como se espera. Comprobaciones habituales: has() para funciones del programa, exists() para variables/comandos, filereadable() para archivos, empty() para valores vacíos, type() para comparar tipos.
# Conditionals:
if x > 10
echo "big"
elseif x > 5
echo "medium"
else
echo "small"
endif
# Ternary:
let result = (x > 0) ? "positive" : "non-positive"
# Loops:
for i in range(5) # 0,1,2,3,4
echo i
endfor
for [key, val] in items({'a': 1, 'b': 2})
echo key . '=' . val
endfor
while x > 0
let x -= 1
endwhile
# Loop control:
break # exit loop
continue # skip to next iteration
# Match-related conditionals:
if has('python3') # feature check
if exists(':Command') # command exists
if filereadable('file') # file is readable
if empty(var) # variable is empty
if type(var) == type([]) # type checkCadenas
. concatena strings. Vim 8.2+ añade la interpolación $"...{expr}...". len/strlen dan la longitud en bytes; strcharlen da el conteo de caracteres (importante para multibyte). split/join convierten entre strings y listas. substitute() es el comando :s programático. matchstr() extrae una coincidencia de regex. =~ es el operador de coincidencia de regex.
# String concatenation:
let s = "Hello" . " " . "World"
# String interpolation (Vim 8.2+):
let name = "Vim"
echo $"Welcome to {name}!"
# Common functions:
len("hello") # 5
strlen("hello") # 5 (byte length)
strcharlen("hello") # 5 (char length)
tolower("HELLO") # "hello"
toupper("hello") # "HELLO"
strpart("hello", 1, 3) # "ell" (substring)
matchstr("foo123bar", '\d\+') # "123"
substitute("foo", 'o', '0', 'g') # "f00"
split("a,b,c", ',') # ['a', 'b', 'c']
join(['a', 'b', 'c'], '-') # "a-b-c"
trim(" hello ") # "hello"
# printf-style formatting:
printf("%d + %d = %d", 1, 2, 3) # "1 + 2 = 3"
printf("%05.2f", 3.14159) # "03.14"
# Regex matching:
if "hello" =~ '^h'
echo "starts with h"
endifListas y diccionarios
Las listas son ordenadas (como arrays); los diccionarios son mapas clave-valor. El slicing de listas usa [start:end]. add/insert/remove modifican listas en el sitio. sort/reverse también mutan. En los dicts funcionan tanto .key como ["key"]; keys()/values()/items() devuelven listas. has_key() comprueba la pertenencia. #{...} (Vim 8+) es un literal de dict más limpio que no exige entrecomillar las claves.
# Lists (like arrays):
let nums = [1, 2, 3, 4, 5]
echo nums[0] # 1 (first)
echo nums[-1] # 5 (last)
echo nums[1:3] # [2, 3, 4] (slice)
# List operations:
call add(nums, 6) # append 6
call insert(nums, 0, 0) # insert 0 at index 0
call remove(nums, 0) # remove index 0
echo len(nums) # length
call sort(nums) # sort in place
call reverse(nums) # reverse in place
call extend(nums, [7, 8]) # concatenate
# Iterate:
for n in nums
echo n
endfor
# Dictionaries (like hash maps / objects):
let d = {"name": "Vim", "version": 9}
echo d.name # "Vim"
echo d["version"] # 9
let d.lang = "Vimscript" # add a key
call remove(d, "version") # remove a key
echo keys(d) # ['name', 'lang']
echo values(d) # ['Vim', 'Vimscript']
echo items(d) # [['name', 'Vim'], ['lang', 'Vimscript']]
echo has_key(d, "name") # 1 (true)
# Dictionary literal (Vim 8+, cleaner):
let d2 = #{key: "value", count: 42}Autocmds y comandos personalizados
autocmd ejecuta código ante eventos de Vim (BufRead, BufWritePre, FileType, VimEnter, CursorMoved, etc.). Envuelve siempre los autocmds en un augroup con autocmd! para limpiar las definiciones viejas al recargar — evita duplicados. Los comandos personalizados usan :command! -nargs=N -range -bang Name acción. <args>, <line1>, <line2>, <bang> acceden a la entrada del usuario en la definición del comando.
# Autocmds: run code on events
:autocmd BufWritePre *.md :%s/\s\+$//e " trim trailing whitespace
# Group autocmds (recommended - prevents duplicates on reload):
augroup markdown_settings
autocmd!
autocmd BufRead,BufNewFile *.md setlocal spell
autocmd FileType markdown setlocal textwidth=80
autocmd BufWritePre *.md :%s/\s\+$//e
augroup END
# Common events:
# BufReadPost - after loading a file
# BufWritePre - before saving
# BufWritePost - after saving
# FileType - when filetype is set
# VimEnter - after Vim startup
# CursorMoved - cursor moved in normal mode
# InsertEnter - entering insert mode
# Custom Ex commands:
command! -nargs=1 Grep !grep <args> %
command! -range Sum echo <line1> + <line2>
command! -bang Q quit<bang>
# Use them:
:Grep pattern
:Sum
# Show all autocmds:
:autocmd
# Show autocmds for a specific event:
:autocmd BufWritePreFragmentos de Vim relacionados
Copy-paste ready code for common tasks.
Buffer, Window y Tab
Editar múltiples archivos con buffers, splits y tabs.
Buscar y Reemplazar
Buscar texto con /, reemplazar con :s, usar regex y rangos.
Registros (Multi-Portapapeles)
Guardar yank/delete en registros nombrados y pegar desde ellos.
Marks (Marcadores)
Saltar a posiciones dentro o entre archivos con marks.
Macros (Grabar Keystrokes)
Grabar secuencias de teclas y reproducirlas para automatizar ediciones repetitivas.
Folding (Plegar Código)
Ocultar regiones de código con folding para enfocar la estructura.
Gestores de Plugins y Ecosistema
Instalar, configurar y descubrir plugins con vim-plug / packer / lazy.
LSP, Completado y Diagnósticos
Obtener features de IDE vía LSP (autocompletado, go-to-definition, diagnósticos).
Was this helpful?