Selection & Yanking

You’re in Zed’s vim mode and you want to copy a word. Your hand reaches for the old reflex: double-click to select, then Cmd+C. It half-works, it feels clumsy, and it breaks your flow. That reflex is select-then-copy — and in Vim it’s backwards.

In a normal editor you select first, then act: highlight a region, then copy it. Vim flips the order. You say the verb first, then name what to copy — no highlighting step at all. The verb is y (yank, Vim’s word for copy). What follows is a tiny description of the target.

y  i  w
│  │  └─ noun:  "word"
│  └──── modifier: "inner"
└─────── verb: yank (copy)

Read yiw as one thought: “yank inner word.” Put your cursor anywhere on a word, press those three keys, and the whole word is in your clipboard. You never selected it. You described it.

The mental shift: operator + text object

Every copy is two parts:

1. The operator — what to do. y for yank. (Later: d to delete, c to change. Same grammar, different verb.)
2. The target — a motion or a text object that answers “copy what?”

A text object is a named region Vim already understands — a word, the text inside quotes, the contents of a bracket pair. You don’t draw the boundary; you name it and Vim finds the edges. The selection is implicit.

So the question to train yourself to ask isn’t “what do I drag over?” It’s “copy WHAT?” — and the answer is always a text object or a motion.

The targets you’ll actually use

The pattern is y + a target. The target is either an object (i = inner / a = around) or a motion (t, f, $). These cover the vast majority of real copies:

Copy this	Press	Read it as
The word under the cursor	yiw	yank inner word
The word plus its trailing space	yaw	yank a word
Text inside "…"	yi"	yank inside quotes
Text inside (…) / {…} / […]	yi( yi{ yi[	yank inside brackets
Text inside an HTML/JSX tag	yit	yank inside tag
The whole current line	yy	yank line
Three lines, starting here	3yy	yank 3 lines
From cursor to end of line	y$	yank to line end
From cursor up to (not incl.) the next ;	yt;	yank till ;
From cursor up to and including the next ;	yf;	yank find ;

Two distinctions worth burning in early, because they’re the ones people trip on:

• i vs a — i is inner (just the contents), a is around (contents plus the surrounding whitespace or delimiters). yiw grabs word; yaw grabs word with its space, handy when you’re about to paste it elsewhere.
• t vs f — t stops till the character (exclusive), f finds it and includes it. yt; leaves the ; behind; yf; takes it with you.

Zed’s vim mode and the system clipboard

You’re in Zed, not terminal Vim — so a yank lands in Vim’s own registers, and whether it also reaches your OS clipboard is a setting. In settings.json:

{
  "vim": {
    // "never" | "on_yank" | "always"
    "use_system_clipboard": "on_yank"
  }
}

• "never" — yanks stay inside Vim; Cmd+C/Cmd+V are separate.
• "on_yank" — recommended. Every y also copies to the system clipboard, so paste-into-another-app just works without surprising you on every motion.
• "always" — even deletes feed the clipboard (noisy; small motions clobber it).

Whatever the default, you can force the system clipboard per-yank by prefixing the register "+: "+yiw, "+yy. And you can stash a copy in a named register so a later delete doesn’t overwrite it — "ayiw yanks into register a, and "ap pastes it back.

Practice in the playground

Put your cursor in the editor, press Esc to make sure you’re in normal mode, then work the challenges. The reg " chip on the right shows what’s currently in your unnamed register — watch it change as you yank.

⌨ Practice: yank by naming the target

reg " — Reset

Esc → normal mode. Each challenge checks the unnamed register after you yank.

• Yank the word greeting — put the cursor on it and press yiw.

  Hint Show keys
• Yank what is *inside* the quotes with yi".

  Hint Show keys
• Yank the arguments inside the parens with yi(.

  Hint Show keys
• Yank the whole return line with yy (linewise).

  Hint Show keys
• From the function line, yank 3 lines with 3yy.

  Hint Show keys
• Fallback drill: select the first line with V then press y.

  Hint Show keys

When to drop to visual mode

Text objects don’t cover everything. Sometimes the region you want isn’t a word, a line, or a balanced delimiter pair — it’s an irregular span only you can see. That’s what visual mode is for: you highlight it by hand, then yank.

Key	Selects	Then
v	character-wise (grow with motions)	y to yank
V	whole lines	y to yank
Ctrl-v	a rectangular block (column)	y to yank

The flow is select, then y — the old reflex, but deliberate. Use it for things like “from here to that random spot three words in,” or a block of aligned columns, where no text object names the boundary cleanly.

The trap

If you find yourself pressing v and then carefully extending the highlight over a whole word, a whole line, or everything inside a bracket — stop. That’s a text object you’re hand-drawing. yiw, yy, yi( already name it, faster and without the mis-clicks. Rule of thumb: reach for visual mode only when the target is too irregular to name.

A quick drill

Run these in order in the playground above (press Esc first). The goal is to feel the name-it reflex replace the select-it one.

1. Cursor on greeting. Press yiw, then move to a blank spot and p to paste. You copied a word without touching the boundary.

2. Cursor inside the "…" string. Press yi", then p. You got the contents, no quotes.

3. Cursor inside (a, b). Press yi(. The reg " chip now reads a, b.

4. Anywhere on the return line, press yy (the chip shows an LW badge — linewise). Then 3yy from the function line to grab the whole body.

5. Now the fallback: press V on the first line to select it line-wise, then y. Same result as yy here — which is exactly the point. When a text object fits, prefer it; save visual mode for the spans that don’t.

Recap

The whole lesson in one sentence:

Don’t select-then-copy. Say copy (y), then name what to copy (a text object like iw, i", i(, or a whole line with yy) — and drop to visual mode only when the target is too irregular to name.

Once the verb→noun grammar clicks, it generalizes: swap y for d and you delete the same targets; swap in c and you change them. Same nouns, new verb. That’s the next lesson.