Learn Neovim - Registers, Macros & Efficient Editing

#Introduction

After covering operators, text objects, and advanced motions in episode 3 — assembling the operator + motion grammar and mastering text objects (ci", di(, yap) — in this episode we go up to the next level: repetitive efficiency. The two most powerful tools for that are registers (temporary storage) and macros (automation recorder), plus advanced search & replace.

Why is this important? In episode 3 you could already edit with precision — but still one at a time. In the real world, you often have to repeat the same pattern dozens of times: reformatting 30 strings, adding a prefix to 50 lines, fixing a variable name in 20 places. Doing that manually is a recipe for fatigue and errors. Registers and macros turn repetitive work into automation — this is the promise of "multiplied efficiency" that makes people stick with modal editing.

There is also one crucial detail in this episode: the clipboard. The + register connects Neovim to the system clipboard — you will learn to copy from Neovim and paste outside it (browser, other apps), and vice versa.

#Registers

Registers are Neovim's temporary storage. Every time you delete (d) or yank (y), the content automatically goes into a register. Registers give you full control over what is stored and where it comes from.

#Types of Registers

#Storing & Pasting from Registers

The syntax is consistent: " + register name + operator.

"ay    yank baris ini ke register a
"ap    paste isi register a setelah kursor
"aP    paste isi register a sebelum kursor
"+y    yank ke system clipboard
"+p    paste dari system clipboard
"0p    paste hasil yank terakhir (tidak tertimpa delete)

#Viewing & Modifying Registers

The :reg command displays all current register contents:

:reg
--- Registers ---
""   The quick brown fox
"0   The quick brown fox
"1   const name = "budi"
"a   lorem ipsum dolor
"+   teks dari clipboard

To modify a register's content directly (without yanking):

:let @a = "nilai baru"
:echo @a        # menampilkan "nilai baru"

@a is the syntax to access register a's value as a string. This is useful for setting registers programmatically — even :let @+ = "..." changes the clipboard directly.

#Macros (Recording)

A macro is a recorded sequence of actions that can be replayed. This is the most important automation tool for repetitive edits — the "record & replay" equivalent in the editor world.

#Recording a Macro

The macro recording flow: q + name (a-z) → do the actions → q (stop).

qa        mulai merekam ke register a
...       lakukan urutan tindakan apapun (motion, edit, dll)
q         stop rekaman

Running a macro:

@a        jalankan macro a sekali
@@        jalankan macro terakhir dijalankan
10@a      jalankan macro a sebanyak 10 kali

#Case Study: Transforming Many Lines

The most classic example — turning a list format into declarations. We have a list of names:

budi
siti
agung

We want the final result to be:

name = "budi"
name = "siti"
name = "agung"

Without a macro this is 9 manual steps (editing each line one by one). With a macro:

qa              mulai rekam
I               masuk insert mode di awal baris
name = "        ketik prefix + buka kutip
Esc             kembali ke normal mode (kursor di awal kata)
e               lompat ke akhir kata (sebelum spasi)
a"              append setelah kata (menutup kutip)
Esc             kembali ke normal mode
j               pindah ke baris berikutnya
q               stop rekam

Now run the macro on the remaining two lines:

@a    # baris ke-2 jadi "name = \"siti\""
@@   # baris ke-3 jadi "name = \"agung\""

The key: the macro must end in a position ready for the next iteration (here, we end with j to move down to the next line). This is the art of recording macros — ending with a movement that makes the macro repeatable.

#Advanced Macro Techniques

1. Macro + text objects = the most explosive combination. Record ci" inside a macro, and the macro will replace the content of all strings following the same pattern.
2. Macro at the end of a file: 999@a stops automatically when a motion cannot continue.
3. Check macro content: :reg a displays the recording. Macros are stored as text — you can even edit them manually!
4. Call a macro across buffers: macros are stored in registers, so @a remains available when switching files.

#Search & Replace

#Substitution :s

The substitution command is: :s/<pattern>/<replacement>/<flags>. With % before s, the substitution applies to the entire file.

:%s/budi/siti/g        # ganti semua "budi" jadi "siti" di seluruh file
:%s/budi/siti/gc       # sama, tapi konfirmasi tiap penggantian
:s/budi/siti/          # hanya baris saat ini saja, kemunculan pertama

#Special Characters & Capture Groups

To replace characters that have special meaning in regex (like ., [, *), escape them with \:

:%s/\./->/g    # ganti semua titik menjadi -> (titik di-escape)

Capture groups \(...\) (and the \1 reference) let you capture part of a pattern and reuse it in the replacement:

:%s/\(budi\)/\1@example.com/g    # "budi" → "budi@example.com"
:%s/\(name=\) "\(.*\)"/\1'\2'/g  # ubah kutip ganda jadi kutip tunggal

The second real-world example above is a transformation often used when changing quote styles: the pattern captures name= and its content (\1, \2), then reassembles them with single quotes.

#The Dot Command (.)

The dot command repeats the last change — a small trick with extraordinary power. After a change (for example ciw replacing one word), pressing . repeats it exactly at the current cursor position.

# Ganti "merah" jadi "biru":
ciw biru Esc      # perubahan pertama
.                 # ulangi di kata berikutnya
.                 # dan lagi...

Combine it with n (next search result): /merah → ciw → biru → Esc → n → . → n → . — replacing every "merah" with 2 keys per occurrence. This is the "n-dot" technique much loved by the community.

#Hands-On Practice

Create a file latihan4.txt with the following content:

apple;merah;buah
banana;kuning;buah
carrot;orange;sayur
grape;ungu;buah

Do the following in Neovim:

1. Yank & register practice. yy then "0p and "1p — compare the results. Then "+y to copy to the OS clipboard.
2. Named register practice. "ay on one line, "by on another line, then "ap and "bp in different places.
3. Macro practice. Record a macro that turns the line apple;merah;buah into nama=apple warna=merah jenis=buah (replace ; with a space, add the nama=, warna=, jenis= prefixes). Run it with @a on all lines (you can use 999@a).
4. Search & replace practice. Change all buah to fruit with :%s/buah/fruit/g. Then with c for confirmation: :%s/banana/pisang/gc.
5. Capture group practice. Change apple;merah into apple (merah) with :%s/\(apple\);\(merah\)/\1 (\2)/g.
6. Dot command practice. Change apple → apel on all lines using the n + . technique (search with /apple, then ciw, type, Esc, n, ., repeat).

#Common Pitfalls

1. p pastes the wrong thing (register " overwritten). After a yank, do not do a delete before p. Use "0p for the last yank, which resists being overwritten.

2. Forgetting to end the macro with q. This happens often: start qa, finish the actions, but forget to press q again. The result: everything you type afterwards gets recorded too. If your cursor suddenly acts "weird" while typing, check with :reg a.

3. The macro ends in the wrong position. If the macro ends in a position not ready for the next line (for example without j), the next iteration will not run correctly. The golden rule: end the macro with a movement that prepares the next iteration.

4. :%s without g. Only replaces the first occurrence per line. Always use g unless there is a reason.

5. Trouble replacing special characters (., /, [, *). In substitution patterns, regex characters must be escaped with \. If :%s/./x/g replaces every character (not just dots), that is because . means "any character" in regex. Escape it as \. for a literal dot.

6. Forgetting to save after changes. :w before :q — or directly :wq / :x.

#Closing

In episode 4 you unlocked the gate to repetitive efficiency: mastering registers (", 0, 1-9, a-z, +) for precise storage, recording macros (qa...q, @a, @@, 999@a) to automate repetitive edits, mastering search & replace (:%s/old/new/g with the c, i flags and the \1 capture group), and the dot command (.) to repeat the last change.

Key points to take with you:

• Registers give you control over what is stored and pasted; "0p rescues yank results, "+y/"+p connect to the OS clipboard.
• Macros turn repetitive work into a single recording; end the macro in a position ready for the next iteration.
• :%s/old/new/g with the right flags, the \1 capture group, and the n dry-run prevents mistaken replacements.
• The dot command is the most concise way to repeat simple changes.

With this, Phase 1 — Fundamentals of Modal Editing of this series is officially complete: you now have a full foundation (setup, history, modes & navigation, operators & text objects, and registers & macros). In episode 5, we enter Phase 2 — Managing Buffers, Windows & Tabs: understanding Neovim's three layout components, splitting the screen with split windows (:split, :vsplit), and switching between buffers (:bnext, :bdelete). Stay motivated, because from here you start building a real working "workspace" on top of the foundation you have mastered!