vim Power Tools: Marks, Filters, Config, Windows and Many Files

A mark is a bookmark on a position. Press m and a letter: ma marks the cursor position as a. Later, 'a (apostrophe) jumps to the line of mark a, and ` a ` (backtick) jumps to the exact *line and column*. Lowercase marks a–z belong to one file. Uppercase marks A–Z are **file marks**: 'C` takes you back to that position even from another file, which makes them handy for "the config I keep returning to".

Vim also sets marks for you. '' jumps back to where you were before your last jump (a search, a G, a :42), and pressing it again returns, so two presses toggle between two places. ` . ` goes to the position of your last change. :marks` lists everything that's set.

The real power is that a mark is a line address, so it can end a range. Mark the first line of a block with ma, move to its last line and mark it with mb, and now :'a,'bd deletes the block, :'a,'bs/old/new/g replaces only inside it, and :'a,'b!sort filters just those lines (step 3). Visual mode does the same thing behind the scenes: after a selection, : pre-fills :'<,'>, which are the marks for the start and end of the selection.

You already know yy, dd and p. The surprise comes next: you yank a line, delete some junk, press p, and get the junk instead of what you yanked. Every delete also goes into the unnamed register "", which is what p pastes. Vim keeps the pieces apart for you:

• "0 always holds your last yank, untouched by deletes, so "0p pastes what you copied even after deleting in between.
• "1 to "9 hold your last nine line deletes, newest first.
• "_ is the black hole: "_dd deletes without touching any register.
• "a to "z are yours: "ayy yanks into a, and "Ayy (capital) appends to it.
• "+ is the system clipboard, on builds that have it (vim --version | grep clipboard). Over SSH it usually isn't there.

:reg shows them all.

For whole lines, Ex has two commands that skip the registers entirely. :t (copy, short for transfer) and :m (move) take a destination line: :5t. copies line 5 below the cursor, :1t$ copies line 1 to the end of the file, and :m0 moves the current line to the top. They take ranges too: :'a,'bt$ duplicates a marked block at the end. When you know the line numbers, this is faster than jumping, yanking, jumping back and pasting.

Vim doesn't need its own sort, uniq, column or jq, because it can filter text through any of them. A filter sends lines to a command's standard input and replaces them with its standard output:

• :%!sort -u filters the whole file (%) through sort -u.
• :'a,'b!column -t filters a marked range; :'<,'>!… does the same for a visual selection.
• !!cmd in Normal mode filters the current line, and !}cmd filters to the end of the paragraph. ! followed by any motion works.

The mirror image is reading a command's output into the file without replacing anything: :r !cmd inserts its output below the cursor, and :3r !cmd below line 3. :r file does the same with a file.

Several transforms don't need the shell at all, which matters on a stripped-down box.

• :sort sorts by byte value, so capitals come first. :sort u also drops duplicates, :sort n sorts numerically (so 9 comes before 10), :sort i ignores case and :sort! reverses. It takes a range like any Ex command: :'a,'bsort.
• :g/pattern/cmd runs an Ex command on every line that matches: :g/^#/d deletes all comment lines, and :g/TODO/t$ copies every TODO line to the end. :v/pattern/cmd (or :g!) does the same for lines that don't match.
• Case: in Normal mode ~ flips one character, and gU{motion} / gu{motion} upper- or lowercase a motion, so gUiw capitalises the word under the cursor and guu lowercases the line. In a substitution, \U and \L switch the replacement's case: :%s/.*/\L&/ lowercases every line.

Every option can be changed live with :set, and it lasts until you quit. Put the same lines in `~/.vimrc` (or ~/.vim/vimrc) and they apply every time vim starts.

• :set number turns a boolean option on, :set nonumber turns it off, and :set number! or :set invnumber toggles it.
• :set tabstop=4 sets a value. :set tabstop? asks for the current value, and :set all lists every option.
• Options worth knowing: tabstop/shiftwidth (how wide a tab and an indent are), expandtab (insert spaces instead of tabs), number/relativenumber, ignorecase with smartcase (case-insensitive search unless you type a capital), hlsearch/incsearch, and list (show tabs and line ends).

Mappings bind a key to keystrokes. Two rules keep them working:

1. Use the `noremap` forms: nnoremap for Normal mode, inoremap for Insert mode. Plain nmap/map re-expand other mappings inside the right-hand side, which leads to surprises and loops.

2. A mapping replays the keys literally. nnoremap <F5> :set invlist types the command but never presses Enter, so nothing happens. It needs <CR> at the end: nnoremap <F5> :set invlist<CR>.

After editing ~/.vimrc, :source ~/.vimrc reloads it without restarting. vim -u NONE starts with no configuration at all, which is the quickest way to find out whether your vimrc is causing a problem.

Three words that trip everyone up, from the inside out:

• A buffer is a file loaded into memory. :e file opens one, :ls lists them with numbers, :b 3 or :b nam<Tab> switches, :bn/:bp step next and previous, and :bd unloads one. A buffer can stay open without being visible.
• A window is a viewport onto a buffer. :sp file splits horizontally, :vs file splits vertically, and two windows can show the same buffer. Ctrl-w is the window prefix: Ctrl-w w cycles, Ctrl-w h/j/k/l moves in a direction, Ctrl-w q closes this window, Ctrl-w o closes all the others, and Ctrl-w = equalises sizes.
• A tab page is a whole layout of windows. :tabnew file opens one, gt/gT move to the next or previous tab, and :tabclose closes it.

From the shell: vim -o a b opens files in horizontal splits, vim -O a b in vertical splits, and vim -p a b in tabs.

:wn walks files one at a time. When the same change applies to twenty files, let vim loop instead. The argument list is the set of files vim was started with, or that you give it later: :args /etc/app/*.conf replaces the list, and :args **/*.conf recurses. Then:

• :argdo CMD runs an Ex command in every file in the list.
• :bufdo CMD runs it in every open buffer, and :windo CMD in every visible window.

The standard pattern is :argdo %s/^old=/new=/e | update. The e flag stops a file that has no match from aborting the loop with an error. update writes the file only if it changed, where w would rewrite every file. After a big argdo, :args shows the list and :ls shows which buffers were modified.

Each of these runs on any lab box. They create their own scratch files under /tmp, so try them, then open the same files interactively with vim and do the same edits with the keystroke forms: ma/mb, !}sort, gUiw, :sp, Ctrl-w w. The three vim labs grade the same skills on a real file: Filter Pipeline (ranges, filters and :r !cmd), Make vim Yours (a vimrc that vim itself verifies), and Fleet Refactor (:argdo across a directory without collateral damage).