Vim Intermediate/Advanced

Chapter 2 — Registers In Depth

What Registers Are For

Every editor has a clipboard — but most editors give you exactly one. Copy something new, and whatever was there before is gone. Vim's answer is registers: up to dozens of independent storage slots, each holding its own piece of yanked or deleted text, all available simultaneously.

This matters more than it sounds. Imagine restructuring a function: you need to move three separate blocks of code to three different places. In a single-clipboard editor, you'd yank the first block, paste it, then have to go back and re-select the second block from scratch — because copying it would have overwritten the first. With registers, you can yank all three blocks into three named slots up front, then paste each one exactly where it belongs, in any order.

Chapter 1's macros are themselves stored in a register — this chapter is what makes that fact make sense, and unlocks a much wider set of copy/paste workflows along the way.

The Unnamed Register

Every plain y (yank) or d/c (delete/change) you've used since Chapter 1 of Learning Vim already uses a register — you just haven't had to name it. This default is the unnamed register, written "":

yy       # yanks the current line into the unnamed register
dd       # deletes the current line into the unnamed register (overwriting whatever was yanked)
p        # pastes from the unnamed register

Named Registers a–z and A–Z

Prefixing any yank, delete, or paste with "{letter} targets a specific named register instead of the unnamed one:

"ayy      # yank the current line into register 'a'
"bdd      # delete the current line into register 'b'
"ap       # paste from register 'a'

The distinction between lowercase and uppercase is deliberate and useful:

# Collect three scattered lines into ONE register, in order:
"ayy      # yank line 1 into 'a' (overwrites)
"Ayy      # yank line 2, APPENDED to 'a'
"Ayy      # yank line 3, APPENDED to 'a'
# register 'a' now holds all three lines, in the order collected
"ap       # paste all three at once

Viewing register contents

:registers       # list every register and a preview of its contents
:reg             # shorthand for the same command
:reg a b         # list only registers 'a' and 'b'

--- Registers ---
""   function processOrder(id) {
"0   const result = calculate(x, y)
"a   const BASE_URL = "https://api.example.com"^Jconst TIMEOUT = 5000
"1   old line that was deleted

The ^J you'll sometimes see inside a register's preview represents a newline character — visible proof that register a above holds two full lines appended together, not one.

Numbered Registers 0–9

Vim automatically maintains ten numbered registers without you ever naming them explicitly — but they follow two different rules depending on the number.

# Demonstrating the split between "0 and the "1-"9 ring:
yy        # yank line A — now in both "" and "0
dd        # delete line B — "" now holds B, "1 holds B, but "0 STILL holds A
"0p       # pastes line A — the yank register was untouched by the delete
"1p       # pastes line B — the most recent delete

Special Registers

A handful of registers are always populated automatically, each recording something specific about your session:

# Insert the current filename into the text itself:
i (enter Insert mode)
Ctrl-r %    # pastes the "% register — the filename — right into the text

# Use "+ to copy INTO the OS clipboard, so it's pasteable in another app:
"+yy      # yank the current line to the system clipboard

# The expression register does math (or any Vim expression) inline:
i (enter Insert mode)
Ctrl-r =12*8<CR>   # inserts "96" directly into the text

Practical Workflow: Juggling Multiple Registers

A realistic scenario: refactoring a function's three parameters into a config object, each needing to move to a different destination.

Compare this to a single-clipboard workflow, which would require interleaving every yank with its paste — copy one, immediately paste it, go back for the next — because a second copy would destroy the first. Named registers remove that ordering constraint entirely.

Commands Introduced in This Chapter