Vim para el desarrollador reacio: mejoras prácticas
Los movimientos y flujos de trabajo prácticos de Vim que realmente aceleran la programación diaria — sin ideología, solo eficiencia real al editar código.
El debate sobre Vim es agotador. Un bando insiste en que es la única herramienta seria para desarrolladores serios. El otro bando lo cierra escribiendo :q! y no vuelve jamás. Ambos se equivocan de enfoque. Vim no es cuestión de ideología, sino de un lenguaje de edición componible que, una vez interiorizado, te permite manipular código más rápido que cualquier flujo de trabajo basado en el mouse.
No hace falta cambiar de editor. VS Code con atajos de Vim, JetBrains IdeaVim y Neovim te dan el mismo modelo de edición sin renunciar a las funciones modernas del IDE. La inversión se amortiza en pocas semanas.
La gramática de Vim
El poder de Vim viene de su estructura de comandos componible: verbo + modificador + sustantivo. Una vez que aprendes el vocabulario, puedes construir cualquier operación de edición sin memorizar atajos individuales.
# The formula: [count] verb [modifier] noun
# Verbs (operators)
d → delete
c → change (delete + enter insert mode)
y → yank (copy)
v → visual select
# Nouns (motions/text objects)
w → word
b → back a word
$ → end of line
0 → start of line
gg → start of file
G → end of file
# Modifiers
i → inner (inside delimiters)
a → around (including delimiters)Esta gramática se combina de forma infinita:
# Operations that read like English
dw → delete word
d$ → delete to end of line
ciw → change inner word
ci" → change inner quotes (delete contents between " ")
da( → delete around parentheses (including the parens)
yap → yank around paragraph
di{ → delete inner braces (contents between { })
ct. → change to next periodAprender d, c, y, v como verbos y w, b, $, i", a{ como sustantivos te da docenas de operaciones a partir de un puñado de piezas básicas.
Los movimientos que más importan
No todos los movimientos de Vim son igual de útiles. Estos diez cubren el 80% de la edición diaria:
# Essential movement
w / b → forward/back by word
f{char} → jump to next {char} on current line
/{pattern} → search forward
* → search for word under cursor
% → jump to matching bracket
# Essential editing
ciw → change inner word (replace a word)
ci" → change inner quotes
dd → delete entire line
o / O → insert line below / above
. → repeat last changeEl comando . es la mejor característica de Vim. Repite tu última acción de edición. Combínalo con la búsqueda / y n (siguiente coincidencia) para un buscar-y-reemplazar manual que te da control sobre cada aparición:
# Find-and-change workflow
/oldVariable → search for the text
ciw → change inner word
newVariable → type replacement
<Esc> → back to normal mode
n → jump to next occurrence
. → repeat the ciw + replacement
n → next occurrence
. → repeat againEsto es más rápido que :%s/old/new/gc cuando el número de reemplazos es pequeño, porque ves cada cambio en su contexto.
Objetos de texto: la función estrella
Los objetos de texto (el modificador i, de interior, y el modificador a, de entorno) operan sobre unidades estructuradas de código: el contenido dentro de comillas, paréntesis, etiquetas o párrafos. Eliminan la selección manual por completo.
// Cursor is anywhere inside the string
const message = "Hello, world!";
// ^ cursor here
// ci" → deletes "Hello, world!" and puts you in insert mode
// Result: const message = "|" (cursor between quotes)
// Cursor is on the function arguments
function calculate(price, quantity, tax) {
// ^ cursor here
// di( → deletes everything inside parentheses
// Result: function calculate() {}
// Cursor is inside the object
const config = { host: "localhost", port: 3000 };
// ^ cursor here
// da{ → deletes the entire object including braces
// Result: const config = ;// HTML/JSX text objects (with appropriate plugin)
<div className="container">
<p>Some content here</p>
</div>
// With cursor inside the div:
// dit → delete inner tag (everything between <div> and </div>)
// dat → delete around tag (including the opening and closing tags)Macros para ediciones repetitivas
Las macros graban una secuencia de pulsaciones de teclas y las reproducen. Para ediciones estructurales repetitivas en muchas líneas, las macros son un orden de magnitud más rápidas que editar a mano.
# Scenario: Convert 50 lines of
# const x = require('x');
# to
# import x from 'x';
# Record macro into register q
qq → start recording into register q
0 → go to start of line
cwimport<Esc> → change 'const' to 'import'
f= → jump to '='
C from<Esc> → change from '=' to end of line to ' from'
A;<Esc> → append semicolon (if needed)
$x → delete trailing character
J → join any broken lines
q → stop recording
# Replay: apply to next 49 lines
49@q → execute macro 49 timesLa clave está en diseñar la macro para que el cursor quede en la siguiente línea a procesar. Así, 49@q las encadena automáticamente.
Registros y portapapeles
Vim tiene 26 registros con nombre (a-z) más registros especiales. Esto resuelve el problema de "necesito pegar algo, pero copiar sobrescribe mi portapapeles".
# Named registers
"ayy → yank line into register a
"bdd → delete line into register b
"ap → paste from register a
"bp → paste from register b
# Special registers
"" → default register (last yank/delete)
"0 → last yank (NOT affected by delete)
"+ → system clipboard
"_ → black hole register (delete without storing)# Common workflow: delete lines without losing your clipboard
# 1. Yank the text you want to paste: yiw
# 2. Delete the text you want to replace: "_diw (into black hole)
# 3. Paste: p
# Or use the yank register:
# 1. Yank: yiw
# 2. Delete target: diw (this overwrites "" but not "0)
# 3. Paste from yank register: "0pConfiguración práctica de VS Code + Vim
La mayoría de los desarrolladores obtiene los mejores resultados con VS Code y la extensión de Vim, conservando las funciones del IDE y sumando el modelo de edición.
// settings.json — practical Vim configuration for VS Code
{
"vim.useSystemClipboard": true,
"vim.hlsearch": true,
"vim.leader": "<space>",
"vim.handleKeys": {
"<C-d>": true,
"<C-u>": true,
"<C-f>": false,
"<C-b>": false,
"<C-p>": false,
"<C-w>": false
},
"vim.normalModeKeyBindingsNonRecursive": [
{ "before": ["<leader>", "w"], "commands": ["workbench.action.files.save"] },
{ "before": ["<leader>", "f"], "commands": ["workbench.action.quickOpen"] },
{ "before": ["<leader>", "p"], "commands": ["editor.action.formatDocument"] },
{ "before": ["g", "d"], "commands": ["editor.action.revealDefinition"] },
{ "before": ["g", "r"], "commands": ["editor.action.goToReferences"] }
]
}La sección handleKeys es fundamental: permite que Ctrl+F, Ctrl+P y Ctrl+W conserven el comportamiento nativo de VS Code mientras Vim se encarga de todo lo demás. Así evitas el período incómodo en el que Vim sobrescribe atajos que ya usas.
Estrategia para la curva de aprendizaje
No intentes aprenderlo todo de una vez. Suma un movimiento nuevo por semana:
# Week 1: hjkl, i, <Esc>, :w, :q, dd, yy, p
# Week 2: w, b, 0, $, ciw, diw
# Week 3: f{char}, /{pattern}, n, N, .
# Week 4: ci", ci(, da{, visual mode (v, V)
# Week 5: macros (qq, q, @q)
# Week 6: registers ("a, "+, "0)La primera semana es dura. Para la tercera, los movimientos básicos ya son automáticos. Para la sexta, eres más rápido que con tu flujo de trabajo anterior en la mayoría de las tareas de edición. El retorno de la inversión es permanente: los movimientos de Vim funcionan en cualquier editor y en la mayoría de las herramientas de terminal.
Puntos clave
- Aprende la gramática, no atajos individuales — verbo + modificador + sustantivo se combinan en infinitas operaciones
- Los objetos de texto son la mayor ganancia de productividad —
ci",da{,diweliminan la selección manual - El comando
.es la mejor función — repite tu último cambio con una sola pulsación - Usa VS Code + Vim, no Vim puro — obtén el modelo de edición sin perder las funciones del IDE
- Suma un movimiento por semana — la adopción gradual construye memoria muscular duradera
- Las macros resuelven las ediciones masivas — grábalas una vez y reprodúcelas cientos de veces
