Learn Neovim - Operators, Text Objects & Advanced Motions

#Introduction

After covering modal editing and mastering basic navigation (Vim motions) in episode 2 — from hjkl, word & line motions, to searching with / and * — in this episode we will assemble the real puzzle. This is where Neovim's "grammar" takes complete shape: operator + motion, text objects, and marks/jump list.

Why is this important? Up to episode 2, you could only move — but you could not yet efficiently modify text content. In this episode you will learn to delete, change, yank, and paste at a speed that is impossible with modeless editors. Think of it like learning to cook: motions are how you hold the knife, and operators are the slicing movements. Both must be mastered together.

This is also the episode that separates true Neovim users from mere dabblers: when people ask "how are you editing so fast?", the answer is almost always here — text objects and operator+motion combinations.

#The Operator + Motion Grammar

#Verbs and Objects

Neovim's philosophy in one sentence: every editing operation is a sentence with the format operator + count + motion. Operators are the verbs (what to do), motions are the objects (what it applies to). This grammar is consistent — once you understand it, hundreds of combinations can be guessed without memorization.

Important difference between d and c: d only deletes, while c deletes and immediately enters insert mode so you can type the replacement right away. This saves a step (d + i).

#Operator + Motion Combinations

Now let's combine the grammar:

#Real-World Scenario Example

Imagine this line, with the cursor at the start of the word quick:

The quick brown fox jumps

Various operations using the grammar above:

#Text Objects

Text objects are one of the most powerful features in Neovim — and yet the most ignored by beginners. Text objects let you operate on text structures (words, sentences, paragraphs, or content inside quotes/parens), not just characters.

#Inner (i) vs Around (a)

There are two families of text objects:

• i (inner) — operates on the content inside a delimiter, without the delimiter itself.
• a (around) — operates on the content plus the delimiter.

The difference is critical. For ci" on the text "hello world":

• ci" (change inner) → deletes hello world, leaving "" — the cursor sits inside the quotes, ready to type.
• ca" (change around) → deletes "hello world" including the quotes.

#Text Objects Table

Notice the pattern: c/d/y + i/a + delimiter. Verb + (inner/around) + object. Same grammar, hundreds of combinations.

#Why Text Objects Change Your Life

Compare two ways of replacing the content of a string argument:

const user = fetch("/api/users?name=username");

• The old way (modeless): click inside the string → select-all inside the quotes → retype → click again.
• The Neovim way: place the cursor anywhere inside the string → ci" → type the new value → Esc. Done in 3 keys + typing.

Now imagine having to change an argument inside fetch(...) across 20 different lines of code. With ci( you can do it without ever moving the cursor to a precise position — just anywhere inside the parens.

#Marks & Jump List

When working on long files, you will often go back and forth between two locations. Neovim provides two mechanisms: marks (manual markers) and the jump list (automatic trail).

#Marks: Marking Locations

Marks are "bookmarks" you place manually inside a file:

Marks can be lowercase letters (a–z, per-file) or uppercase letters (A–Z, global across files). When editing large files, the habit of "mark location A, move to B, then come back" (ma ... `a) is a super-fast jump.

#Jump List: The Automatic Navigation Trail

Unlike manual marks, the jump list automatically records every big jump you make (long-distance motions, searches, cross-file jumps):

A classic usage pattern: you are reading line 500, then jump to line 20 (20G), then want to return exactly to line 500 — one press of Ctrl+o brings you back. Ctrl+o/Ctrl+i is the fastest way to alternate between locations without remembering line numbers.

#Other Advanced Motions

gi and g; are very useful for repeating edits: gi returns you exactly to your last typing position — perfect after pressing Esc and browsing around for a bit. gf works on files that reference a relative path (e.g. import "./utils.ts") — place the cursor on the file name and press gf.

#Hands-On Practice

Create a file latihan3.txt and copy the following lines:

const name = "budi";        // TODO: ganti jadi "siti"
const url = "https://api.dev/users?filter=all";
const list = [1, 2, 3, 4, 5];
function calculate(a, b) { return a * b; }

Do the following in Neovim:

1. Change "budi" to "siti" — cursor anywhere inside "budi", press ci", type siti, Esc.
2. Delete ?filter=all — place the cursor on ?, press d$.
3. Copy the array to a register then paste two lines below — yy → p → p.
4. Change the function body to return a + b; — cursor inside { ... }, press ci{, type return a + b;, Esc.
5. Marks practice — gg (top), ma (mark), G (bottom), then `a (return).
6. Jump list practice — do gg → 10G → $, then press Ctrl+o twice to go back, Ctrl+i to go forward.
7. g;/g, practice — make 3 random changes, then trace their locations with g; and g,.
8. ddp practice — swap the positions of lines 1 and 2.

#Common Pitfalls

1. Forgetting the motion, not just the operator. d alone does nothing — always follow it with a motion/object: dw, dd, d$, d'a. If you press d and get confused, press Esc and start over.

2. Confusing ciw vs cw. cw is change-word (delete from the cursor to the end of the word); ciw is change-inner-word (delete the entire word the cursor is in, from any position within it). To change a whole word, ciw is more predictable.

3. Getting i vs a wrong. ci" leaves the quotes, ca" deletes them. You will regret thinking you changed a string's content only to find the quotes are gone too (or vice versa). Practice both.

4. Pressing p but the paste lands in the wrong place. p pastes after the cursor, P before. For lines, p pastes below the current line, P above. If a paste looks weird, check the register (:reg) before panicking.

5. Overusing u. u is undo, Ctrl+r is redo. If you undo too far, Ctrl+r saves you. Neither needs to be memorized — but both must be practiced.

6. gf fails because the file is not found. gf needs a file that actually exists at the relative path. If you think gf is "broken", check first whether the referenced file really exists.

#Closing

In episode 3 you assembled Neovim's core grammar: linking operators (d, c, y, p, u, Ctrl+r) with motions to form editing sentences (d$, cw, y3w, ddp), mastering text objects that operate on text structure (ci", di(, yap, ci{, ca}), and leveraging marks (ma/`a), the jump list (Ctrl+o/Ctrl+i), and advanced motions (gi, g;/g,, gf, Ctrl+^).

Key points to take with you:

• Neovim is a grammar: operator + count + motion, consistent and predictable.
• Text objects (i vs a) are the biggest efficiency differentiator — master ciw, ci", ci(, ci{, yap.
• Marks for manual positions, jump list for the automatic trail — they complement each other.
• Ctrl+o/Ctrl+i is the fastest way to go back and forth between locations.

Now you can edit with precision. In episode 4, we will cover Registers, Macros & Efficient Editing — diving deeper into Neovim's temporary storage system (registers ", a-z, 0-9, +), recording action sequences as macros (qa...q, @a, 10@a), and mastering search & replace (:%s/old/new/g) and the dot command (.). This is the episode where you will feel the "multiplied efficiency" that modal editing promises. Stay motivated!