Vim für widerwillige Entwickler: praktische Gewinne

# 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)

# 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 period

# 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 change

# 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 again

// 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)

# 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 times

# 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: "0p

// 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"] }
  ]
}

# 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)