Chapter 1: Introduction to Vim and Neovim

1.1 History and Philosophy

The Birth of Vi

To understand Vim and Neovim, we must first travel back to 1976, when Bill Joy created vi (visual) at the University of California, Berkeley. At the time, most text editors were line-oriented, meaning you could only edit one line at a time. Vi revolutionized text editing by allowing users to see and edit multiple lines simultaneously on their screen—a “visual” mode of editing that seems obvious today but was groundbreaking then.

Vi was built on top of ex, a line editor that itself descended from ed, the standard Unix text editor. This lineage explains why Vim still has an “Ex mode” and why many commands begin with a colon (:). These Ex commands are the DNA of vi, preserved through generations of evolution.

Vim: Vi IMproved

In 1991, Bram Moolenaar wanted to use vi on his Amiga computer but found no suitable port. So he created one, initially called “Vi IMitation.” As he added more features, the name evolved to “Vi IMproved”—Vim. The first public release came in November 1991 (Vim 1.14).

What started as a simple port became something far more powerful:

• Multiple levels of undo (original vi only had one level)

• Syntax highlighting for hundreds of languages

• Split windows for viewing multiple files

• Visual mode for selecting text

• Plugin system for extensibility

• Scripting language (VimScript/VimL) for customization

• Extensive help system built into the editor

Over three decades, Vim became one of the most popular text editors in the world, beloved by programmers, system administrators, and writers. Bram Moolenaar maintained Vim until his passing in August 2023, leaving behind an incredible legacy.

The Neovim Revolution

In 2014, Thiago de Arruda started Neovim as a fork of Vim with ambitious goals:

1. Refactor the codebase to make it more maintainable

2. First-class support for embedding Neovim as a library

3. Built-in terminal emulator

4. Asynchronous job control

5. Lua as a first-class scripting language

6. Better default settings out of the box

7. Modern development practices (continuous integration, better testing)

The Neovim project wasn’t born from animosity toward Vim, but from a desire to modernize the codebase while preserving what made Vim great. The motto became: “Vim, but better.”

The Philosophical Divide

Both Vim and Neovim share the same core philosophy:

Modal Editing: Unlike most editors where keys directly insert characters, Vim and Neovim separate editing into distinct modes. In Normal mode, keys are commands; in Insert mode, they insert text. This separation allows for powerful editing commands without endless keyboard shortcuts.

Composability: Commands are built from simple, composable parts. d means “delete,” w means “word,” so dw deletes a word. 3dw deletes three words. This grammar-like structure makes Vim incredibly powerful once you learn its vocabulary.

Text as Data: Vim treats text editing as data manipulation. Macros, registers, and repeatable operations make complex edits simple and automatable.

Where they diverge:

• Vim prioritizes backward compatibility and stability. Changes are conservative, and existing scripts should continue working.

• Neovim prioritizes modern features and developer experience. Breaking changes are acceptable if they lead to a better future.

Why This Matters

Understanding this history helps you appreciate both editors:

• Vim is mature, stable, and available everywhere. If you SSH into a server, Vim is likely there.

• Neovim is innovative, extensible, and has a thriving plugin ecosystem leveraging Lua and modern APIs.

Both are actively developed. Both are excellent. This book focuses more on Neovim because:

1. It represents the future of modal editing

2. Its Lua integration makes plugin development more accessible

3. Its built-in LSP client brings IDE-like features natively

4. Its architecture is cleaner for learning concepts

But everything you learn applies to both—they share 95% of their DNA.

1.2 Vim vs Neovim: Key Differences

Architectural Differences

Codebase

• Vim: Original C codebase, over 30 years of accumulated code. Approximately 450,000 lines.

• Neovim: Refactored C codebase with aggressive removal of legacy code. Cleaner separation of concerns.

Scripting Languages

• Vim: VimScript (VimL) is the primary scripting language. Lua support added in Vim 8.2+ but secondary.

• Neovim: Both VimScript and Lua are first-class. Lua is preferred and faster. Most new plugins use Lua.

Asynchronous Operations

• Vim: Added async support in Vim 8.0 (2016) via jobs and channels.

• Neovim: Built with async in mind from the start. Uses libuv for async I/O.

Embedding

• Vim: Not designed to be embedded.

• Neovim: Built as a library that can be embedded in other applications. Remote UI protocol allows GUI clients.

Feature Differences

Configuration Differences

File Locations

# Vim
~/.vimrc              # Main config file
~/.vim/               # Vim directory
~/.vim/autoload/      # Autoload scripts
~/.vim/plugin/        # Plugin files

# Neovim
~/.config/nvim/init.vim    # VimScript config
~/.config/nvim/init.lua    # Lua config (preferred)
~/.config/nvim/lua/        # Lua modules
~/.local/share/nvim/       # Data directory
~/.local/state/nvim/       # State files (undo, shada)

Sample Configurations

Vim (VimScript)

" ~/.vimrc
set number
set relativenumber
set expandtab
set shiftwidth=4
set tabstop=4

" Plugin management with vim-plug
call plug#begin('~/.vim/plugged')
Plug 'tpope/vim-fugitive'
Plug 'junegunn/fzf.vim'
call plug#end()

" Key mappings
nnoremap <leader>ff :Files<CR>
nnoremap <leader>fg :Rg<CR>

Neovim (VimScript)

" ~/.config/nvim/init.vim
set number
set relativenumber
set expandtab
set shiftwidth=4
set tabstop=4

" Plugin management with vim-plug
call plug#begin('~/.local/share/nvim/plugged')
Plug 'tpope/vim-fugitive'
Plug 'nvim-telescope/telescope.nvim'
call plug#end()

" Key mappings
nnoremap <leader>ff <cmd>Telescope find_files<cr>
nnoremap <leader>fg <cmd>Telescope live_grep<cr>

Neovim (Lua)

-- ~/.config/nvim/init.lua
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.expandtab = true
vim.opt.shiftwidth = 4
vim.opt.tabstop = 4


-- Plugin management with lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  "tpope/vim-fugitive",
  {
    "nvim-telescope/telescope.nvim",
    dependencies = { "nvim-lua/plenary.nvim" }
  }
})


-- Key mappings
vim.keymap.set('n', '<leader>ff', '<cmd>Telescope find_files<cr>')
vim.keymap.set('n', '<leader>fg', '<cmd>Telescope live_grep<cr>')

API Differences

VimScript Function Call

" Vim and Neovim
:echo expand('%:p')
:call setline(1, 'Hello, World!')

Neovim Lua API

-- Neovim only
print(vim.fn.expand('%:p'))
vim.api.nvim_buf_set_lines(0, 0, 1, false, {'Hello, World!'})


-- Better performance with direct API calls
local current_file = vim.api.nvim_buf_get_name(0)

Performance Differences

Startup Time

• Vim: Generally faster startup with minimal configuration

• Neovim: Slightly slower due to Lua runtime initialization, but faster with optimized configs

Plugin Loading

• Vim: Traditional runtime loading

• Neovim: Lazy loading is more common and effective with modern plugin managers

Syntax Highlighting

• Vim: Regex-based syntax highlighting

• Neovim: Tree-sitter provides faster, more accurate highlighting

Default Behaviors

Neovim’s Better Defaults

" These are ON by default in Neovim but need to be set in Vim:
set autoindent          " Copy indent from current line when starting new line
set autoread            " Reload files changed outside of Vim
set backspace=indent,eol,start  " Backspace over everything in insert mode
set belloff=all         " Never ring the bell
set complete-=i         " Don't scan included files for completion
set display=lastline    " Show as much as possible of the last line
set encoding=utf-8      " Default encoding
set formatoptions=tcqj  " Better format options
set history=10000       " Longer command history
set hlsearch            " Highlight search matches
set incsearch           " Incremental search
set langnoremap         " Helps avoid mapping conflicts
set laststatus=2        " Always show status line
set listchars=tab:>\ ,trail:-,nbsp:+  " Better whitespace characters
set mouse=a             " Enable mouse support (not in Vim by default in terminals)
set nrformats=bin,hex   " Better number formats for <C-a>/<C-x>
set ruler               " Show cursor position
set sessionoptions-=options  " Don't save all options in sessions
set showcmd             " Show partial commands
set sidescroll=1        " Smoother horizontal scrolling
set smarttab            " Smart tab behavior
set tabpagemax=50       " More tab pages allowed
set tags=./tags;,tags   " Better tags file search
set ttyfast             " Faster terminal connection
set viminfo+=!          " Better viminfo
set wildmenu            " Command-line completion menu

When to Choose Which?

Choose Vim if:

• You need maximum compatibility with older systems

• You prefer conservative, battle-tested updates

• You’re working on servers where Neovim isn’t installed

• You have extensive VimScript customizations you don’t want to migrate

• You prefer the traditional Unix philosophy of stability

Choose Neovim if:

• You want modern IDE-like features (LSP, Tree-sitter)

• You prefer Lua over VimScript for configuration

• You want the latest features and active development

• You’re building a new configuration from scratch

• You appreciate better defaults out of the box

• You want a more active plugin ecosystem

Use Both if:

• You maintain systems with different editors installed

• You want to learn both for maximum flexibility

• You keep a shared configuration that works on both

Migration Path

If you’re coming from Vim to Neovim:

1. Start with your existing Vim config: Neovim reads ~/.vimrc if ~/.config/nvim/init.vim doesn’t exist

2. Gradually adopt Neovim features: Add LSP, Tree-sitter, Lua configs incrementally

3. Use compatibility layers: Most Vim plugins work in Neovim unchanged

4. Keep both installed: They can coexist peacefully

-- init.lua: Load your old vimrc first
vim.cmd('source ~/.vimrc')


-- Then add Neovim-specific features
require('neovim-specific-config')

1.3 Installation and Setup

Installing Vim

Linux

# Debian/Ubuntu
sudo apt update
sudo apt install vim

# For full features (Python, Ruby, etc.)
sudo apt install vim-gtk3  # or vim-gnome

# Fedora/RHEL/CentOS
sudo dnf install vim-enhanced

# Arch Linux
sudo pacman -S vim

# Check version and features
vim --version

macOS

# macOS comes with Vim, but it's often outdated
vim --version  # Check current version

# Install latest with Homebrew
brew install vim

# For GUI version (MacVim)
brew install macvim

Windows

1. Download from vim.org

2. Run the installer (gvim##.exe)

3. Or use package managers:

# Chocolatey
choco install vim

# Scoop
scoop install vim

# Winget
winget install vim.vim

Building from Source

# Get the source
git clone https://github.com/vim/vim.git
cd vim/src

# Configure with desired features
./configure --with-features=huge \

            --enable-multibyte \

            --enable-python3interp=yes \

            --enable-rubyinterp=yes \

            --enable-luainterp=yes \

            --enable-perlinterp=yes \

            --enable-gui=gtk3 \

            --enable-cscope \

            --prefix=/usr/local

# Compile and install
make
sudo make install

Installing Neovim

Linux

# Ubuntu/Debian (stable version)
sudo apt install neovim

# For latest stable via PPA
sudo add-apt-repository ppa:neovim-ppa/stable
sudo apt update
sudo apt install neovim

# Fedora
sudo dnf install neovim

# Arch Linux
sudo pacman -S neovim

# AppImage (works on most Linux distros)
curl -LO https://github.com/neovim/neovim/releases/latest/download/nvim.appimage
chmod u+x nvim.appimage
./nvim.appimage

# Move to PATH
sudo mv nvim.appimage /usr/local/bin/nvim

macOS

# Homebrew
brew install neovim

# MacPorts
sudo port install neovim

Windows

# Chocolatey
choco install neovim

# Scoop
scoop install neovim

# Winget
winget install Neovim.Neovim

# Or download from GitHub releases
# https://github.com/neovim/neovim/releases

Building from Source

# Install dependencies (Ubuntu/Debian)
sudo apt install ninja-build gettext cmake unzip curl

# Clone repository
git clone https://github.com/neovim/neovim
cd neovim

# Checkout stable version (or use master for bleeding edge)
git checkout stable

# Build
make CMAKE_BUILD_TYPE=RelWithDebInfo
sudo make install

Verify Installation

# Check Neovim version
nvim --version

# Should show something like:
# NVIM v0.9.4
# Build type: Release
# LuaJIT 2.1.1692716794

Initial Configuration

Neovim Directory Structure

# Create Neovim config directory
mkdir -p ~/.config/nvim

# Create subdirectories for organization
mkdir -p ~/.config/nvim/lua
mkdir -p ~/.config/nvim/after/plugin
mkdir -p ~/.config/nvim/colors

First init.lua

Create ~/.config/nvim/init.lua:

-- Basic settings
vim.opt.number = true                -- Show line numbers
vim.opt.relativenumber = true        -- Show relative line numbers
vim.opt.mouse = 'a'                  -- Enable mouse support
vim.opt.ignorecase = true            -- Case insensitive search
vim.opt.smartcase = true             -- Unless search contains uppercase
vim.opt.hlsearch = false             -- Don't highlight all search matches
vim.opt.wrap = false                 -- Don't wrap lines
vim.opt.breakindent = true           -- Preserve indentation in wrapped text
vim.opt.tabstop = 4                  -- Tabs are 4 spaces
vim.opt.shiftwidth = 4               -- Indent by 4 spaces
vim.opt.expandtab = true             -- Use spaces instead of tabs
vim.opt.termguicolors = true         -- True color support


-- Set leader key to space
vim.g.mapleader = ' '
vim.g.maplocalleader = ' '


-- Basic keymaps
vim.keymap.set('n', '<leader>w', '<cmd>write<cr>', {desc = 'Save'})
vim.keymap.set('n', '<leader>q', '<cmd>quit<cr>', {desc = 'Quit'})


-- Navigate between windows
vim.keymap.set('n', '<C-h>', '<C-w>h')
vim.keymap.set('n', '<C-j>', '<C-w>j')
vim.keymap.set('n', '<C-k>', '<C-w>k')
vim.keymap.set('n', '<C-l>', '<C-w>l')

print("Neovim configuration loaded!")

Alternative: VimScript Configuration

Create ~/.config/nvim/init.vim:

" Basic settings
set number
set relativenumber
set mouse=a
set ignorecase
set smartcase
set nohlsearch
set nowrap
set breakindent
set tabstop=4
set shiftwidth=4
set expandtab
set termguicolors

" Set leader key
let mapleader = ' '
let maplocalleader = ' '

" Basic keymaps
nnoremap <leader>w :write<CR>
nnoremap <leader>q :quit<CR>

" Navigate between windows
nnoremap <C-h> <C-w>h
nnoremap <C-j> <C-w>j
nnoremap <C-k> <C-w>k
nnoremap <C-l> <C-w>l

echo "Neovim configuration loaded!"

Health Check

Neovim includes a health check system:

:checkhealth

This command checks:

• Python provider setup

• Ruby provider setup

• Node.js provider setup

• Clipboard integration

• Terminal support

• And more…

Fix any warnings or errors shown. Common issues:

# Install Python provider
pip3 install pynvim

# Install Node.js provider
npm install -g neovim

# Install Ruby provider
gem install neovim

Setting Up a Plugin Manager

We’ll use lazy.nvim, the modern plugin manager for Neovim.

Installing lazy.nvim

Add to your init.lua:

-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)


-- Setup plugins
require("lazy").setup({

  -- Your plugins will go here
  {
    "folke/which-key.nvim",
    event = "VeryLazy",
    init = function()
      vim.o.timeout = true
      vim.o.timeoutlen = 300
    end,
    opts = {}
  },
  

  -- Colorscheme
  {
    "folke/tokyonight.nvim",
    lazy = false,
    priority = 1000,
    config = function()
      vim.cmd([[colorscheme tokyonight]])
    end,
  },
})

Managing Plugins

:Lazy              " Open lazy.nvim UI
:Lazy sync         " Install/update/clean plugins
:Lazy install      " Install missing plugins
:Lazy update       " Update plugins
:Lazy clean        " Remove unused plugins
:Lazy health       " Run health checks

Creating a Modular Configuration

For better organization, split your configuration:

File Structure: ~/.config/nvim/

├│── init.lua

├│── lua/

││ ├── config/

││ │ ├── options.lua

││ │ ├── keymaps.lua

││ │ └── autocmds.lua

││ └── plugins/

││ ├── init.lua

││ ├── telescope.lua

││ ├── treesitter.lua

││ └── lsp.lua

init.lua:

-- Load core configuration
require('config.options')
require('config.keymaps')
require('config.autocmds')


-- Bootstrap and load plugins
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup("plugins")

lua/config/options.lua:

local opt = vim.opt


-- Line numbers
opt.number = true
opt.relativenumber = true


-- Tabs and indentation
opt.tabstop = 4
opt.shiftwidth = 4
opt.expandtab = true
opt.autoindent = true


-- Search
opt.ignorecase = true
opt.smartcase = true
opt.hlsearch = false
opt.incsearch = true


-- Appearance
opt.termguicolors = true
opt.signcolumn = "yes"
opt.cursorline = true


-- Behavior
opt.mouse = "a"
opt.clipboard = "unnamedplus"
opt.undofile = true
opt.updatetime = 250
opt.timeoutlen = 300

lua/config/keymaps.lua:

local keymap = vim.keymap


-- Set leader
vim.g.mapleader = " "
vim.g.maplocalleader = " "


-- Save and quit
keymap.set("n", "<leader>w", "<cmd>write<cr>", { desc = "Save file" })
keymap.set("n", "<leader>q", "<cmd>quit<cr>", { desc = "Quit" })


-- Window navigation
keymap.set("n", "<C-h>", "<C-w>h", { desc = "Go to left window" })
keymap.set("n", "<C-j>", "<C-w>j", { desc = "Go to lower window" })
keymap.set("n", "<C-k>", "<C-w>k", { desc = "Go to upper window" })
keymap.set("n", "<C-l>", "<C-w>l", { desc = "Go to right window" })


-- Better visual mode indenting
keymap.set("v", "<", "<gv")
keymap.set("v", ">", ">gv")


-- Move lines up and down
keymap.set("n", "<A-j>", ":m .+1<cr>==", { desc = "Move line down" })
keymap.set("n", "<A-k>", ":m .-2<cr>==", { desc = "Move line up" })
keymap.set("v", "<A-j>", ":m '>+1<cr>gv=gv", { desc = "Move selection down" })
keymap.set("v", "<A-k>", ":m '<-2<cr>gv=gv", { desc = "Move selection up" })

1.4 First Steps: Understanding Modes

The most fundamental concept in Vim/Neovim is modal editing. Unlike traditional editors where every key press inserts a character, Vim has different modes for different tasks.

The Primary Modes

1. Normal Mode

This is the default mode when you open Vim. In Normal mode, keys are commands, not text input.

" You start here when opening Vim
" Press keys to execute commands:
j      " Move down one line
k      " Move up one line
dd     " Delete current line
yy     " Yank (copy) current line
p      " Paste after cursor
u      " Undo
<C-r>  " Redo (Ctrl+r)

To return to Normal mode from any other mode, press <Esc> or <C-[> (Control+[).

2. Insert Mode

This is where you actually type text, like in a normal editor.

Enter Insert mode from Normal mode:

i      " Insert before cursor
a      " Append after cursor
I      " Insert at beginning of line
A      " Append at end of line
o      " Open new line below
O      " Open new line above

In Insert mode, you can type normally. Return to Normal mode with <Esc>.

3. Visual Mode

For selecting text. There are three variants:

v      " Character-wise visual mode
V      " Line-wise visual mode
<C-v>  " Block-wise visual mode (Ctrl+v)

Once in Visual mode:

" Navigate to expand selection
h, j, k, l    " Expand in any direction
w, e, b       " Expand by word
$, 0          " Expand to line end/start

" Then perform operations
d      " Delete selection
y      " Yank (copy) selection
c      " Change selection (delete and enter insert mode)
>      " Indent selection
<      " Unindent selection

4. Command-Line Mode

For executing Ex commands, searches, and filters.

:      " Enter command-line mode for Ex commands
/      " Search forward
?      " Search backward

Examples:

:w              " Write (save) file
:q              " Quit
:wq             " Write and quit
:e file.txt     " Edit file.txt
:20             " Go to line 20
:%s/old/new/g   " Replace all 'old' with 'new'

5. Terminal Mode

Neovim’s built-in terminal emulator (also available in Vim 8.1+).

:terminal       " Open terminal in current window
:split | terminal  " Open terminal in horizontal split

In terminal mode:

<C-\><C-n>     " Return to Normal mode
i or a         " Return to Terminal mode from Normal mode

6. Replace Mode

Overwrites existing text instead of inserting.

R      " Enter Replace mode
<Esc>  " Return to Normal mode

Mode Indicators

Vim By default, Vim shows the current mode in the bottom-left:

– INSERT –

– VISUAL –

– REPLACE – (nothing shown in Normal mode)

Neovim Similar to Vim, but can be customized more easily.

To always see the mode in your statusline:

vim.opt.showmode = true  -- Default in both Vim and Neovim

Modal Thinking

The power of modal editing comes from composability. In Normal mode, you combine:

1. Operators (actions)

2. Motions (where to apply the action)

3. Text objects (what to act upon)

Operators:

d    " Delete
c    " Change (delete and enter insert mode)
y    " Yank (copy)
>    " Indent
<    " Unindent
=    " Auto-indent

Motions:

w    " Next word
e    " End of word
b    " Beginning of word
$    " End of line
0    " Beginning of line
gg   " Top of file
G    " Bottom of file
}    " Next paragraph
{    " Previous paragraph

Text Objects:

iw   " Inner word
aw   " A word (includes surrounding space)
i"   " Inside double quotes
a"   " Around double quotes (includes quotes)
it   " Inside tag
at   " Around tag
ip   " Inner paragraph

Combining them:

dw    " Delete word
d$    " Delete to end of line
d2w   " Delete 2 words
di"   " Delete inside quotes
da"   " Delete around quotes (including quotes)
ciw   " Change inner word
yap   " Yank a paragraph
>ip   " Indent paragraph

The Grammar of Vim

Think of Vim commands as sentences:

[count] operator [count] motion/text-object

Examples:

3dw    " 3 times, delete a word
2dd    " 2 times, delete a line (dd = delete line)
d3w    " Delete 3 words (same as 3dw)
c2w    " Change 2 words
y5j    " Yank current line plus 5 lines down

Practice Exercise: Modal Workflow

Let’s walk through a common editing task:

Task: You have this text: The quick brown fox jumps over the lazy dog

You want to change “brown” to “red”:

1. Navigate: Use /brown<Enter> to search for “brown”

2. Change: Type ciw (change inner word)

3. Insert: Type “red”

4. Exit Insert: Press <Esc>

The full sequence: /brown<Enter>ciwred<Esc>

Another example: Delete everything inside parentheses:

Text:

print("Hello, World!")

Cursor on the line:

1. Navigate to inside the parentheses: f( (find opening paren)

2. Delete inside: di" (delete inside quotes)

Or more directly: f(ldi" (find paren, move right one char, delete inside quotes)

Or even simpler if cursor is anywhere on the line: /print<Enter>f"di"

Mode-Specific Best Practices

Normal Mode:

• Stay in Normal mode as much as possible

• Use motions instead of arrow keys

• Learn to compose commands

• Use . to repeat the last change

Insert Mode:

• Get in, make your change, get out

• Don’t use arrow keys (use <C-o> for one Normal mode command)

• Use <C-w> to delete a word backward

• Use <C-u> to delete to start of line

Visual Mode:

• Use sparingly; often Normal mode commands are faster

• Great for irregular selections

• Perfect for block operations (<C-v>)

Command-Line Mode:

• Use <Up> and <Down> to browse history

• Use <C-r>" to paste from default register

• Use <C-f> to open command-line window for editing

Your First Vim Session

Let’s put it all together. Open Neovim:

nvim practice.txt

Step 1: Enter Insert mode and type some text:

i
This is my first Neovim file.
I am learning modal editing.
It feels strange but powerful.
<Esc>

Step 2: Navigate (in Normal mode):

gg      " Go to top
j       " Down one line
$       " End of line
0       " Beginning of line
w       " Next word
b       " Previous word

Step 3: Make some edits:

" Go to the word 'strange'
/strange<Enter>

" Change it to 'different'
ciwdifferent<Esc>

" Go to end of second line and add text
j$aIt's starting to make sense.<Esc>

" Delete the third line
jdd

Step 4: Save and quit:

:wq

Understanding Why Modes Matter

Efficiency: Your fingers stay on the home row. No reaching for arrow keys, mouse, or complex Ctrl combinations.

Precision: Normal mode commands are surgical. You can express exactly what you want to do.

Repeatability: The . command repeats your last change. Combined with n (next search result), you can make identical edits across a file rapidly.

Composability: Learning 10 operators and 10 motions gives you 100 combinations, not 20 separate commands to memorize.

Example: Suppose you want to delete everything from your cursor to the next occurrence of “end”:

d/end<Enter>

This combines:

• d (delete operator)

• /end<Enter> (motion: to the next “end”)

No special “delete to search result” command needed—you just composed two concepts you already know.

Common Beginner Mistakes

1. Staying in Insert Mode Wrong approach: Enter Insert mode, use arrow keys to move, delete with Backspace. Right approach: Stay in Normal mode, use motions, enter Insert mode briefly.

2. Not Using Text Objects Wrong: dllll (delete and then press l four times) Right: dw (delete word)

3. Fighting the Modes Wrong: Getting frustrated that keys don’t type letters in Normal mode. Right: Embrace the modes. Normal is your home; Insert is a quick visit.

4. Ignoring the Dot Command Wrong: Manually repeating the same edit multiple times. Right: Make the edit once, then use . to repeat it.

5. Not Learning Motions Wrong: Using jjjjj to move down five lines. Right: Use 5j or relative line numbers with 5j.

Next Steps

Now that you understand modes:

1. Practice switching between modes until it feels natural

2. Learn the basic motions (h, j, k, l, w, e, b, $, 0)

3. Learn the basic operators (d, c, y)

4. Start combining them

5. Gradually add text objects to your vocabulary

In the next chapters, we’ll dive deep into each of these concepts, building your Vim vocabulary until you’re thinking in Vim.

Chapter Summary:

In this chapter, you learned:

• The history of vi, Vim, and Neovim

• The philosophical differences between Vim and Neovim

• Key architectural and feature differences

• How to install and configure both editors

• The fundamental concept of modal editing

• The six primary modes and when to use each

• How to think compositionally in Vim

• Your first practical editing session

With this foundation, you’re ready to explore the powerful features that make Vim and Neovim beloved by millions of developers worldwide.

Chapter 2: Navigation Mastery

Navigation is the foundation of Vim efficiency. While other editors rely on arrow keys and mouse clicks, Vim provides a rich vocabulary of motion commands that keep your hands on the home row and your mind in a flow state. Master navigation, and everything else in Vim becomes exponentially more powerful.

2.1 Basic Navigations

The Home Row Movement: h, j, k, l

The most fundamental navigation commands:

h    " Move left (←)
j    " Move down (↓)
k    " Move up (↑)
l    " Move right (→)

Why these keys? When Bill Joy created vi, he used an ADM-3A terminal where these keys had arrow symbols on them. More importantly, they keep your fingers on the home row.

Mnemonic:

• j looks like a down arrow

• k is above j, so it goes up

• h is on the left, goes left

• l is on the right, goes right

Using counts:

5j    " Move down 5 lines
10k   " Move up 10 lines
3h    " Move left 3 characters
7l    " Move right 7 characters

Practice exercise: Open any file and navigate using only hjkl for 5 minutes. Resist the urge to use arrow keys.

Word-Wise Movement

Moving by words is much faster than character-by-character:

w     " Move to the beginning of the next word
W     " Move to the beginning of the next WORD (whitespace-separated)
e     " Move to the end of the current/next word
E     " Move to the end of the current/next WORD
b     " Move to the beginning of the previous word
B     " Move to the beginning of the previous WORD
ge    " Move to the end of the previous word
gE    " Move to the end of the previous WORD

Understanding word vs WORD:

# Example text:
my_variable = get_data(user.id)

# Using 'w' (word): stops at underscores and dots
# Cursor positions: my | _ | variable | = | get | _ | data | ( | user | . | id | )

# Using 'W' (WORD): stops only at whitespace
# Cursor positions: my_variable | = | get_data(user.id)

word: Delimited by non-keyword characters (punctuation, whitespace)

WORD: Delimited only by whitespace

Example with counts:

3w    " Move forward 3 words
2b    " Move backward 2 words
5e    " Move to the end of the 5th word forward

Practical use case:

Suppose you want to delete the next 3 words:

d3w   " Delete 3 words forward

Or change the next word:

cw    " Change word (delete word and enter insert mode)

Line-Wise Movement

0     " Move to the first column of the line (column 0)
^     " Move to the first non-blank character of the line
$     " Move to the end of the line
g_    " Move to the last non-blank character of the line

Example:

    print("Hello, World!")
#   ^                    $
#   |                    |
# First non-blank    End of line

0     " Takes you to the very beginning (before the spaces)
^     " Takes you to 'p' (first non-blank)
$     " Takes you after the exclamation mark
g_    " Takes you to the exclamation mark (last non-blank)

Combining with operators:

d$    " Delete from cursor to end of line
d0    " Delete from cursor to beginning of line
d^    " Delete from cursor to first non-blank character
c$    " Change from cursor to end of line (same as C)
y^    " Yank from cursor to first non-blank character

Line Number Movement

gg    " Go to the first line of the file
G     " Go to the last line of the file
{n}G  " Go to line number n (e.g., 42G goes to line 42)
:{n}  " Same as above (e.g., :42 goes to line 42)
{n}gg " Alternative to {n}G

Examples:

1G    " Go to line 1 (same as gg)
100G  " Go to line 100
:250  " Go to line 250

With relative line numbers enabled:

-- In your init.lua
vim.opt.relativenumber = true
vim.opt.number = true

Your screen shows: 3 ” some line 2 ” another line 1 ” yet another line 42 ” current line (absolute line number) 1 ” next line 2 ” line after that 3 ” three lines down

Now you can jump precisely:

5j    " Jump down 5 lines (you can see it's 5 lines away)
3k    " Jump up 3 lines

Percentage Movement

{n}%  " Go to n% through the file

Examples:

50%   " Go to the middle of the file
25%   " Go to 1/4 through the file
75%   " Go to 3/4 through the file

The special meaning of %:

When your cursor is on a bracket, parenthesis, or brace:

%     " Jump to the matching bracket/paren/brace

Example:

function example() {
  if (condition) {
    doSomething();
  }
}

With cursor on the opening { after example(), pressing % takes you to the matching } at the end of the function.

2.2 Jump Lists and Change Lists

Vim keeps track of where you’ve been and what you’ve changed. This creates a navigational history you can traverse.

Jump List

Every time you make a “jump” (movement that goes farther than one line), Vim records it.

What counts as a jump?

• G, gg, {n}G (line number jumps)

• / or ? (searching)

• % (matching bracket)

• ( or ) (sentence movement)

• { or } (paragraph movement)

• H, M, L (screen position jumps)

• Opening a file

Jump list navigation:

<C-o>  " Jump to older position in jump list (go back)
<C-i>  " Jump to newer position in jump list (go forward)

Think of it like a web browser’s back/forward buttons.

Example workflow:

:e file1.txt     " Open file1
/search_term     " Search for something (creates a jump)
<C-o>            " Go back to previous position
gg               " Go to top (creates a jump)
<C-o>            " Go back
<C-o>            " Go back again
<C-i>            " Go forward

View the jump list:

:jumps

Output looks like: jump line col file/text 4 100 10 ~/file1.txt 3 42 5 ~/file2.txt 2 15 0 ~/file1.txt 1 88 12 ~/file3.txt >

The > indicates your current position.

Change List

Vim also tracks every position where you made a change.

g;    " Go to previous change position
g,    " Go to next change position

View the change list:

:changes

Practical use case:

You’re editing a function, make a change, then scroll around the file. To quickly return to where you were editing:

g;    " Jump back to last change

Jump to Definition (with tags)

If you have a tags file (generated by ctags or LSP):

<C-]>     " Jump to definition
<C-t>     " Jump back from definition
g<C-]>    " If multiple matches, show a list

" Preview definition without jumping
<C-w>}    " Open definition in preview window

Example workflow with LSP in Neovim:

-- In your LSP configuration
vim.keymap.set('n', 'gd', vim.lsp.buf.definition, { desc = 'Go to definition' })
vim.keymap.set('n', 'gr', vim.lsp.buf.references, { desc = 'Go to references' })
vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, { desc = 'Go to implementation' })

Then:

gd      " Jump to definition (uses LSP)
<C-o>   " Jump back
gr      " See all references

2.3 Marks and Bookmarks

Marks are like bookmarks in your code. You can set a mark and instantly jump back to it.

Setting Marks

m{a-z}    " Set a mark in the current file (lowercase = file-local)
m{A-Z}    " Set a global mark (uppercase = across files)

Example:

ma    " Set mark 'a' at current cursor position
mA    " Set global mark 'A'

Jumping to Marks

'{mark}   " Jump to the line of {mark}
`{mark}   " Jump to the exact position (line and column) of {mark}

Examples:

'a    " Jump to line of mark a
`a    " Jump to exact position of mark a
'A    " Jump to line of global mark A
`A    " Jump to exact position of global mark A

Difference between ’ and `:

• ' (single quote): Jumps to the first non-blank character of the line

• ` (backtick): Jumps to the exact character position

Special Marks

Vim automatically sets some marks:

''    " Jump to position before the latest jump
``    " Jump to exact position before the latest jump
'.    " Jump to line of last change
`.    " Jump to exact position of last change
'^    " Jump to position where Insert mode was last stopped
`"    " Jump to position when last editing this file
`[    " Jump to beginning of last changed or yanked text
`]    " Jump to end of last changed or yanked text
`<    " Jump to beginning of last visual selection
`>    " Jump to end of last visual selection

Practical examples:

" You make an edit, then navigate away
" To return to where you were editing:
`.

" You paste some text
" To go to the beginning of what you just pasted:
`[

" To go to the end:
`]

" To select what you just pasted:
`[v`]

Viewing All Marks

:marks       " Show all marks
:marks aB    " Show only marks a and B

Deleting Marks

:delmarks a      " Delete mark a
:delmarks a-d    " Delete marks a, b, c, d
:delmarks!       " Delete all lowercase marks in current buffer

Practical Mark Usage

Use case 1: Comparing two sections of code

" At first section
ma

" Navigate to second section
/second_function<CR>

" Set another mark
mb

" Now you can jump between them
'a    " First section
'b    " Second section
'a    " Back to first

Use case 2: Refactoring across files

" In file1.txt
mA    " Set global mark A

" Open file2.txt
:e file2.txt

" Do some work...

" Jump back to file1.txt at mark A
`A

Use case 3: Quick navigation in a large file

" At the function you're working on
mf    " Mark 'f' for "function"

" At important variable declaration
mv    " Mark 'v' for "variable"

" At test section
mt    " Mark 't' for "test"

" Now jump around easily
'f    " Back to function
'v    " Check variable
't    " Check test
'f    " Back to function

2.4 Same-Line Navigation

Character Search

f{char}   " Find next occurrence of {char} on current line
F{char}   " Find previous occurrence of {char} on current line
t{char}   " Till next {char} (cursor stops before the character)
T{char}   " Till previous {char}
;         " Repeat last f, t, F, or T command
,         " Repeat last f, t, F, or T command in opposite direction

Examples:

Line of text: const result = calculateTotal(price, quantity);

fc    " Find next 'c' → moves to 'c' in 'const'
;     " Repeat → moves to 'c' in 'calculate'
;     " Repeat → moves to 'c' in 'price'
,     " Reverse → moves back to 'c' in 'calculate'

fp    " Find next 'p' → moves to 'p' in 'price'
2fp   " Find 2nd occurrence of 'p' → moves to 'p' in 'price' (if first was earlier)

Using ‘t’ (till):

ct,   " Change till comma → deletes everything up to (but not including) comma
dt)   " Delete till closing paren

Line: print(“Hello, World!”)

Cursor at the start, type f" to find the quote, then dt" to delete till the closing quote: print(““)

Combining with Operators

This is where same-line navigation becomes powerful:

df,   " Delete from cursor through the next comma
dF,   " Delete from cursor back through the previous comma
ct.   " Change from cursor till (before) the next period
yf)   " Yank from cursor through the next closing paren

Real-world example:

Changing a function argument:

function example(oldParam, anotherParam, thirdParam) {

Cursor on ‘oldParam’, want to change it:

ciw   " Change inner word

Or if you want to delete everything up to the comma:

df,   " Delete through comma

Column Movement

{n}|  " Move to column n
0     " Move to column 0 (beginning of line)

Example:

50|   " Move to column 50

This is useful when working with formatted text or data files.

Inline Search

For more complex same-line searches, you can use:

/{pattern}\%{line}l

But typically f, F, t, T are sufficient for same-line navigation.

2.5 Screen Adjust

These commands reposition the screen without moving the cursor in the file:

zt    " Move current line to top of screen
zz    " Move current line to center of screen (mnemonic: 'z'oom to center)
zb    " Move current line to bottom of screen

Visual representation:

Before zt: 1 some line 2 another line 3 target line (cursor here) 4 next line 5 more lines

After zt: 3 target line (cursor here) ← now at top of screen 4 next line 5 more lines 6 … 7 …

Practical use:

You’re debugging and want to see what comes after a particular line:

/error_handler<CR>   " Find the error handler
zt                    " Put it at top of screen to see what follows

Or you want to see context before and after:

/critical_function<CR>
zz                     " Center it to see surrounding code

Screen Position Jumps

H     " Jump to the top (High) of the screen
M     " Jump to the middle (Middle) of the screen
L     " Jump to the bottom (Low) of the screen

With counts:

3H    " Jump to 3rd line from top of screen
5L    " Jump to 5th line from bottom of screen

Combining with operators:

dL    " Delete from cursor to bottom of screen
yH    " Yank from cursor to top of screen

2.6 Scroll

Smooth Scrolling

<C-e>  " Scroll down one line (Extra line appears at bottom)
<C-y>  " Scroll up one line (Yester line appears at top)
<C-d>  " Scroll down half a screen
<C-u>  " Scroll up half a screen
<C-f>  " Scroll forward one full screen (Forward)
<C-b>  " Scroll backward one full screen (Backward)

Mnemonic:

• <C-e>: Extra line at bottom

• <C-y>: Yester line at top

• <C-d>: Down half page

• <C-u>: Up half page

• <C-f>: Forward full page

• <C-b>: Backward full page

Customizing scroll amount:

-- In init.lua
vim.opt.scroll = 10  -- <C-d> and <C-u> scroll 10 lines instead of half-page

Smooth Scrolling Configuration

For a more pleasant scrolling experience:

-- Enable smooth scrolling in Neovim
vim.opt.scrolloff = 8        -- Keep 8 lines visible above/below cursor
vim.opt.sidescrolloff = 8    -- Keep 8 columns visible left/right of cursor

With scrolloff=8, the cursor never gets closer than 8 lines to the edge of the screen when scrolling.

Horizontal Scrolling

When wrap is off:

zh    " Scroll right (move screen to the left, revealing text on left)
zl    " Scroll left (move screen to the right, revealing text on right)
zH    " Scroll half a screen width right
zL    " Scroll half a screen width left

-- Disable line wrapping to use horizontal scroll
vim.opt.wrap = false

2.7 Paragraph and Section Movement

Paragraph Movement

{     " Jump to previous paragraph (or code block)
}     " Jump to next paragraph (or code block)

A “paragraph” is text separated by blank lines.

Example:

def function_one():
    print("First function")
    return True

def function_two():
    print("Second function")
    return False

def function_three():
    print("Third function")
    return None

{     " Jump to previous blank line (previous function)
}     " Jump to next blank line (next function)

Combining with operators:

d}    " Delete to end of paragraph
y{    " Yank to beginning of paragraph
c}    " Change to end of paragraph

Sentence Movement

(     " Jump to previous sentence
)     " Jump to next sentence

A sentence ends with ., !, or ? followed by whitespace or end of line.

Example: This is the first sentence. This is the second sentence. This is the third sentence.

)     " Next sentence
(     " Previous sentence

Useful in text editing:

das   " Delete a sentence
cis   " Change inner sentence

Section Movement

[[    " Jump to previous section (or function in some languages)
]]    " Jump to next section (or function in some languages)
[]    " Jump to previous end of section
][    " Jump to next end of section

What constitutes a “section” depends on the file type and syntax.

In C/C++: Sections are typically defined by { at column 0.

In Markdown: Sections are headings.

For more precise function navigation, use:

[m    " Jump to previous start of method (in some languages)
]m    " Jump to next start of method
[M    " Jump to previous end of method
]M    " Jump to next end of method

2.8 File Navigation and Buffer Jumping

The Alternate File

<C-^>  " Toggle between current and alternate file (same as :e #)

Example workflow:

:e file1.txt    " Open file1
:e file2.txt    " Open file2 (file1 becomes alternate)
<C-^>           " Toggle back to file1
<C-^>           " Toggle back to file2

This is incredibly useful for switching between header/implementation files, test files, etc.

Buffer Navigation

:ls           " List all buffers
:buffer {n}   " Go to buffer number n
:bnext        " Go to next buffer
:bprevious    " Go to previous buffer
:bfirst       " Go to first buffer
:blast        " Go to last buffer
:buffer {name} " Go to buffer by name (supports tab completion)

Shortcuts:

:bn    " Short for :bnext
:bp    " Short for :bprevious
:bf    " Short for :bfirst
:bl    " Short for :blast
:b#    " Go to alternate buffer (same as <C-^>)

Buffer by partial name:

:b fil<Tab>   " Tab completion to find buffer with 'fil' in name

Useful mappings:

-- In init.lua
vim.keymap.set('n', '[b', ':bprevious<CR>', { desc = 'Previous buffer' })
vim.keymap.set('n', ']b', ':bnext<CR>', { desc = 'Next buffer' })
vim.keymap.set('n', '<leader>bd', ':bdelete<CR>', { desc = 'Delete buffer' })
vim.keymap.set('n', '<leader>ba', ':%bd|e#|bd#<CR>', { desc = 'Delete all buffers except current' })

Window Navigation

When you have split windows:

<C-w>h    " Move to window on the left
<C-w>j    " Move to window below
<C-w>k    " Move to window above
<C-w>l    " Move to window on the right

<C-w>w    " Cycle through windows
<C-w>p    " Go to previous window
<C-w>t    " Go to top-left window
<C-w>b    " Go to bottom-right window

Better mappings (removes the Ctrl-w prefix):

vim.keymap.set('n', '<C-h>', '<C-w>h')
vim.keymap.set('n', '<C-j>', '<C-w>j')
vim.keymap.set('n', '<C-k>', '<C-w>k')
vim.keymap.set('n', '<C-l>', '<C-w>l')

Now you can use <C-h> directly instead of <C-w>h.

Tab Navigation

:tabnew       " Create new tab
:tabnext      " Go to next tab
:tabprevious  " Go to previous tab
:tabfirst     " Go to first tab
:tablast      " Go to last tab
:tabclose     " Close current tab
gt            " Go to next tab (in normal mode)
gT            " Go to previous tab (in normal mode)
{n}gt         " Go to tab number n

Better mappings:

vim.keymap.set('n', '<leader>tn', ':tabnew<CR>', { desc = 'New tab' })
vim.keymap.set('n', '<leader>tc', ':tabclose<CR>', { desc = 'Close tab' })
vim.keymap.set('n', '[t', ':tabprevious<CR>', { desc = 'Previous tab' })
vim.keymap.set('n', ']t', ':tabnext<CR>', { desc = 'Next tab' })

2.9 Search-Based Navigation

Basic Search

/pattern   " Search forward for pattern
?pattern   " Search backward for pattern
n          " Go to next match
N          " Go to previous match (opposite direction)

*          " Search forward for word under cursor
#          " Search backward for word under cursor
g*         " Search forward for partial word under cursor
g#         " Search backward for partial word under cursor

Example:

In a Python file, cursor on user:

*    " Finds next exact match of 'user'
#    " Finds previous exact match of 'user'
g*   " Finds 'user', 'username', 'user_id', etc.

Search Offset

You can specify where the cursor lands after a search:

/pattern/+2   " Search for pattern, land 2 lines below
/pattern/-3   " Search for pattern, land 3 lines above
/pattern/e    " Search for pattern, land at end of match
/pattern/e+1  " Search for pattern, land one char after end
/pattern/b    " Search for pattern, land at beginning (default)
/pattern/b+2  " Search for pattern, land 2 chars after beginning

Example:

/function/+1   " Find "function", move cursor 1 line down

This lands you inside the function body instead of on the function declaration.

Search Highlighting

:set hlsearch      " Highlight all search matches
:set nohlsearch    " Don't highlight search matches
:set incsearch     " Show matches as you type
:nohlsearch        " Temporarily turn off highlight (until next search)

Common mapping:

-- Clear search highlight with Esc in normal mode
vim.keymap.set('n', '<Esc>', ':nohlsearch<CR><Esc>', { silent = true })

Search History

/{pattern}   " Start a search
<Up>         " Previous search from history
<Down>       " Next search from history
/            " Start search, then press Up to cycle through history

View complete search history:

:history /    " or :history search

Case-Sensitive Search Control

:set ignorecase    " Case-insensitive search
:set smartcase     " Case-sensitive only if search contains uppercase

With these settings:

/test     " Matches: test, Test, TEST, TeSt
/Test     " Matches: Test only (because of uppercase)
/TEST     " Matches: TEST only

Force case sensitivity in a single search:

/\Cpattern    " Case-sensitive search (even with ignorecase on)
/\cpattern    " Case-insensitive search (even with noignorecase)

Count Matches

In Neovim/Vim 8.1+:

:%s/pattern//gn   " Count occurrences without replacing

This shows: X matches on Y lines

Or use a plugin:

" With vim-searchindex plugin (shows "match X of Y")
" Or in Neovim, configure:

vim.opt.shortmess:append("S")  -- Show search count in command line

Now when you search, you see: [1/5] (match 1 of 5).

2.10 Advanced Navigation Patterns

Pattern Matching in Navigation

You can use regex patterns in your navigation:

/\<word\>     " Search for exact word (word boundaries)
/\d\+         " Search for one or more digits
/^function    " Search for lines starting with "function"
/TODO\|FIXME  " Search for TODO or FIXME

Example - Navigate to next TODO:

/\cTODO       " Case-insensitive search for TODO
n             " Next TODO
n             " Next TODO

Navigate to Matching Pairs

%     " Jump to matching parenthesis/bracket/brace
[{    " Jump to previous unmatched {
]}    " Jump to next unmatched }
[(    " Jump to previous unmatched (
])    " Jump to next unmatched )

Example:

function example() {
  if (condition) {
    doSomething();
  }
  return result;
}

Cursor inside doSomething():

[{    " Jump to opening { of if statement
[{    " Jump to opening { of function

Method/Function Navigation

Using built-in commands:

[m    " Jump to start of previous method/function
]m    " Jump to start of next method/function
[M    " Jump to end of previous method/function
]M    " Jump to end of next method/function

Better with plugins:

With nvim-treesitter-textobjects:

require'nvim-treesitter.configs'.setup {
  textobjects = {
    move = {
      enable = true,
      goto_next_start = {
        ["]m"] = "@function.outer",
        ["]]"] = "@class.outer",
      },
      goto_next_end = {
        ["]M"] = "@function.outer",
        ["]["] = "@class.outer",
      },
      goto_previous_start = {
        ["[m"] = "@function.outer",
        ["[["] = "@class.outer",
      },
      goto_previous_end = {
        ["[M"] = "@function.outer",
        ["[]"] = "@class.outer",
      },
    },
  },
}

Now ]m reliably jumps to the next function in any language Tree-sitter supports.

Navigating Diagnostics (LSP)

In Neovim with LSP:

vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, { desc = 'Previous diagnostic' })
vim.keymap.set('n', ']d', vim.diagnostic.goto_next, { desc = 'Next diagnostic' })
vim.keymap.set('n', '[e', function()
  vim.diagnostic.goto_prev({ severity = vim.diagnostic.severity.ERROR })
end, { desc = 'Previous error' })
vim.keymap.set('n', ']e', function()
  vim.diagnostic.goto_next({ severity = vim.diagnostic.severity.ERROR })
end, { desc = 'Next error' })

Now you can jump between errors and warnings easily.

Navigating Quickfix List

:cnext    " Go to next item in quickfix list
:cprevious " Go to previous item
:cfirst   " Go to first item
:clast    " Go to last item
:cnfile   " Go to first item in next file
:cpfile   " Go to first item in previous file

Shortcuts:

:cn    " :cnext
:cp    " :cprevious
:cf    " :cfirst
:cl    " :clast

Better mappings:

vim.keymap.set('n', '[q', ':cprevious<CR>', { desc = 'Previous quickfix' })
vim.keymap.set('n', ']q', ':cnext<CR>', { desc = 'Next quickfix' })
vim.keymap.set('n', '[Q', ':cfirst<CR>', { desc = 'First quickfix' })
vim.keymap.set('n', ']Q', ':clast<CR>', { desc = 'Last quickfix' })

Location List (Buffer-Local Quickfix)

:lnext      " Next location list item
:lprevious  " Previous location list item
:lfirst     " First location list item
:llast      " Last location list item

Mappings:

vim.keymap.set('n', '[l', ':lprevious<CR>', { desc = 'Previous location' })
vim.keymap.set('n', ']l', ':lnext<CR>', { desc = 'Next location' })

2.11 File Explorer Navigation

Netrw (Built-in File Explorer)

:Explore    " Open explorer in current window
:Sexplore   " Open explorer in horizontal split
:Vexplore   " Open explorer in vertical split
:Texplore   " Open explorer in new tab

Shortcuts:

:Ex     " :Explore
:Sex    " :Sexplore
:Vex    " :Vexplore

Inside Netrw:

<Enter>  " Open file/directory

-        " Go to parent directory
D        " Delete file
R        " Rename file
%        " Create new file
d        " Create new directory
i        " Change view style
s        " Change sort order

Better alternative: Use a modern file explorer plugin like nvim-tree or neo-tree.

nvim-tree example:

require("nvim-tree").setup()

vim.keymap.set('n', '<leader>e', ':NvimTreeToggle<CR>', { desc = 'Toggle file explorer' })

Then inside nvim-tree:

<Enter>  " Open file
h        " Collapse directory
l        " Expand directory
a        " Create file
d        " Delete file
r        " Rename file
y        " Copy name

2.12 Fuzzy Finding Navigation

Modern Neovim workflows heavily rely on fuzzy finders like Telescope.

Telescope.nvim

require('telescope').setup{}

local builtin = require('telescope.builtin')
vim.keymap.set('n', '<leader>ff', builtin.find_files, { desc = 'Find files' })
vim.keymap.set('n', '<leader>fg', builtin.live_grep, { desc = 'Live grep' })
vim.keymap.set('n', '<leader>fb', builtin.buffers, { desc = 'Find buffers' })
vim.keymap.set('n', '<leader>fh', builtin.help_tags, { desc = 'Help tags' })
vim.keymap.set('n', '<leader>fr', builtin.oldfiles, { desc = 'Recent files' })
vim.keymap.set('n', '<leader>fc', builtin.commands, { desc = 'Commands' })
vim.keymap.set('n', '<leader>fk', builtin.keymaps, { desc = 'Keymaps' })
vim.keymap.set('n', '<leader>fs', builtin.lsp_document_symbols, { desc = 'Document symbols' })
vim.keymap.set('n', '<leader>fw', builtin.lsp_workspace_symbols, { desc = 'Workspace symbols' })

Inside Telescope:

<C-n>    " Next item
<C-p>    " Previous item
<C-c>    " Close
<CR>     " Select
<C-x>    " Open in horizontal split
<C-v>    " Open in vertical split
<C-t>    " Open in new tab

This becomes your primary navigation method for:

• Finding files by name

• Searching file contents

• Jumping to symbols/functions

• Navigating buffers

• Finding help

2.13 Navigation Best Practices

1. Think in Text Objects, Not Lines

Instead of:

jjjjdw   " Move down 4 lines, delete word

Think:

4jdw     " More intentional

Or better, if you’re targeting a specific word:

/word<CR>daw   " Search for word, delete it

2. Use Relative Line Numbers

vim.opt.relativenumber = true
vim.opt.number = true  -- Shows absolute number on current line

This lets you see exactly how many lines away things are.

3. Minimize Keystrokes

Instead of:

lllllll   " Move right 7 times

Use:

7l        " Move right 7 times

Or even better, if you’re targeting the end of line:

$         " End of line

Or a specific character:

fx        " Find next 'x'

4. Use Search for Long Distances

Instead of:

15j       " Move down 15 lines (requires counting)

Use:

/function_name<CR>   " Search for what you want

Search is often faster than counting lines.

5. Combine Navigation with Editing

Don’t navigate, then delete separately:

" Don't do this:
5j      " Navigate
dd      " Delete

" Do this instead:
d5j     " Delete down 5 lines

6. Set Up Jump-Related Mappings

-- Quick jump to beginning/end of line
vim.keymap.set({'n', 'v'}, 'H', '^', { desc = 'Start of line' })
vim.keymap.set({'n', 'v'}, 'L', '$', { desc = 'End of line' })


-- Keep cursor centered when jumping
vim.keymap.set('n', 'n', 'nzzzv', { desc = 'Next search result' })
vim.keymap.set('n', 'N', 'Nzzzv', { desc = 'Previous search result' })
vim.keymap.set('n', '<C-d>', '<C-d>zz', { desc = 'Scroll down' })
vim.keymap.set('n', '<C-u>', '<C-u>zz', { desc = 'Scroll up' })


-- Join lines but keep cursor position
vim.keymap.set('n', 'J', 'mzJ`z', { desc = 'Join lines' })

7. Use Marks for Context Switching

When you’re about to navigate far away but want to come back:

ma              " Set mark 'a'
/some_pattern   " Navigate far away
...             " Do some work
'a              " Jump back

8. Learn the Quickfix Workflow

For navigating search results across files:

:vimgrep /pattern/ **/*.py   " Search all Python files
:copen                        " Open quickfix window

Then navigate with ]q and [q.

2.14 Navigation Exercises

Exercise 1: Basic Movement

Open any code file and navigate using only these commands (no arrow keys!):

h j k l w e b 0 $ gg G

Goal: Navigate for 5 minutes without using arrow keys or mouse.

Exercise 2: Search Navigation

1. Open a large file

2. Search for a common word: /the<CR>

3. Navigate through all occurrences using n and N

4. Use * on a word and navigate through those occurrences

Exercise 3: Mark Usage

1. Set mark a at the top of a function

2. Navigate to the bottom of the file

3. Set mark b

4. Jump between them using 'a and 'b

5. Try using `a and `b to see the difference

Exercise 4: Text Object Navigation

Practice these patterns:

di"    " Delete inside quotes
ci(    " Change inside parentheses
va}    " Visually select around braces
dap    " Delete a paragraph
cit    " Change inside HTML tag

Exercise 5: Combined Navigation

Delete from cursor to next occurrence of word “end”:

d/end<CR>

Change from cursor to the 3rd comma:

c3f,

Yank the current paragraph:

yap

2.15 Performance Tips

Lazy Redraw

When executing macros or complex operations:

vim.opt.lazyredraw = true  -- Don't redraw during macros

Efficient Searching

vim.opt.ignorecase = true
vim.opt.smartcase = true

This makes searching faster (case-insensitive) but still precise when needed.

Disable Mouse (for Faster Navigation Practice)

vim.opt.mouse = ""  -- Forces you to use keyboard navigation

Re-enable later:

vim.opt.mouse = "a"

Chapter Summary

In this chapter, you learned:

• Basic navigation with hjkl, words, and lines

• Jump lists and change lists for navigating your history

• Marks for bookmarking positions

• Same-line navigation with f, t, ;, and ,

• Screen positioning with zt, zz, zb, H, M, L

• Scrolling commands for viewing more code

• Paragraph and section movement with {} and [[]]

• Buffer, window, and tab navigation

• Search-based navigation with /, ?, *, and #

• Advanced patterns including LSP navigation and fuzzy finding

• Best practices for efficient navigation

• Practical exercises to build muscle memory

Navigation mastery is the foundation of Vim expertise. These commands become second nature with practice, and once they do, you’ll find yourself navigating code faster than you ever thought possible. In the next chapter, we’ll dive deep into editing fundamentals, where navigation combines with powerful text manipulation commands.

Chapter 3: Editing Fundamentals

Navigation gets you to the text you want to modify. Editing transforms it. In Vim, editing is where the philosophy of composability truly shines. You’ve already seen glimpses of it—operators like d, c, and y combined with motions. Now we’ll systematically explore the full editing vocabulary that makes Vim a text-editing language.

3.1 The Editing Grammar: Operators, Motions, and Text Objects

Vim’s editing commands follow a grammatical structure:

[count] [operator] [count] [motion/text-object]

Components:

• Operator: The action to perform (d for delete, c for change, y for yank)

• Motion: Where to apply the action (w for word, $ for end of line)

• Text Object: What to act upon (iw for inner word, ap for a paragraph)

• Count: How many times to repeat (optional)

Examples:

d2w      " Delete 2 words
c$       " Change to end of line
y3j      " Yank current line plus 3 below
2dd      " Delete 2 lines
3cw      " Change 3 words
gUiw     " Uppercase inner word

The Complete Operator Set

d        " Delete (cut)
c        " Change (delete and enter insert mode)
y        " Yank (copy)
~        " Toggle case
g~       " Toggle case (takes a motion)
gu       " Make lowercase
gU       " Make uppercase
>        " Indent right
<        " Indent left
=        " Auto-indent
!        " Filter through external program
gw       " Format text (wrap lines)
gq       " Format text (hard wrap)
g?       " ROT13 encode

Complete Motion Reference (Quick)

" Character-wise
h l 0 ^ $ f F t T ; , |

" Word-wise
w W e E b B ge gE

" Line-wise
j k + - _ gg G {n}G :{n}

" Paragraph/Section
{ } ( ) [[ ]] [] ][

" Search
/ ? n N * # g* g#

" Screen
H M L

" Marks
'{mark} `{mark}

Text Objects: The Inner and Around

Text objects are preceded by i (inner) or a (around):

iw    " Inner word (word only)
aw    " A word (word + trailing space)
iW    " Inner WORD
aW    " A WORD

is    " Inner sentence
as    " A sentence

ip    " Inner paragraph
ap    " A paragraph

i"    " Inner quotes (content between ")
a"    " Around quotes (includes quotes)
i'    " Inner single quotes
a'    " Around single quotes
i`    " Inner backticks
a`    " Around backticks

i(    " Inner parentheses (same as ib)
a(    " Around parentheses (same as ab)
i[    " Inner brackets
a[    " Around brackets
i{    " Inner braces (same as iB)
a{    " Around braces (same as aB)
i<    " Inner angle brackets
a<    " Around angle brackets

it    " Inner tag (HTML/XML)
at    " Around tag

Examples:

# Text: print("Hello, World!")
#       Cursor on 'H' in Hello

diw   " Delete 'Hello' → print(", World!")
daw   " Delete 'Hello, ' → print("World!")
di"   " Delete 'Hello, World!' → print("")
da"   " Delete "Hello, World!" → print()
di(   " Delete entire content → print()
da(   " Delete including parens → print

<!-- Text: <div class="container">Content here</div> -->
<!--       Cursor anywhere in 'Content here' -->

dit   " Delete 'Content here'
dat   " Delete <div class="container">Content here</div>
cit   " Change inner tag (delete content, enter insert mode)

Combining Operators and Text Objects

This is where Vim becomes incredibly powerful:

ciw     " Change inner word
dap     " Delete a paragraph
yit     " Yank inner HTML tag
gUaw    " Uppercase a word
>i{     " Indent inner braces
=a{     " Auto-indent a block
gqap    " Format a paragraph

Real-world example - Refactoring a function call:

result = calculate_total(price, quantity, tax_rate)

Cursor on calculate_total:

ciw     " Change function name
# Type new name
new_function<Esc>

Result:

result = new_function(price, quantity, tax_rate)

Or to change the first argument:

f(      " Find opening paren
w       " Move to first argument
ciw     " Change inner word

3.2 Basic Editing Commands

Insert and Append

i        " Insert before cursor
I        " Insert at beginning of line (first non-blank)
gi       " Insert at last insert position
gI       " Insert at column 1 (absolute beginning)

a        " Append after cursor
A        " Append at end of line

o        " Open new line below
O        " Open new line above

Examples:

    print("Hello")
#   ^cursor here

I        " Insert at beginning → cursor before 'p'
gI       " Insert at column 1 → cursor before indentation

Replace

r{char}  " Replace single character with {char}
R        " Enter Replace mode (like Insert, but overwrites)
gr{char} " Virtual replace (respects tabs)

Examples:

# Text: Hello World
#       ^cursor on H

rx       " Replace H with x → xello World
3r-      " Replace next 3 chars with - → ---lo World

Replace mode:

R        " Enter Replace mode
# Type 'Goodbye' (overwrites existing text)
<Esc>    " Exit Replace mode

Substitute

s        " Substitute character (delete char and enter insert mode)
S        " Substitute line (delete line and enter insert mode)

# With counts
3s       " Substitute 3 characters
2S       " Substitute 2 lines

Note: s is equivalent to cl (change letter), and S is equivalent to cc (change line).

Change

c{motion}   " Change (delete and enter insert mode)
cc          " Change entire line
C           " Change to end of line (same as c$)

# Examples
cw          " Change word
c2w         " Change 2 words
c$          " Change to end of line
c^          " Change to beginning of line
ciw         " Change inner word
cit         " Change inner tag
ci"         " Change inside quotes

Practical example - Changing a string:

const message = "Old message here";

Cursor on ‘O’ in “Old”:

ci"     " Change inside quotes
# Type new message
New message<Esc>

Result:

const message = "New message";

3.3 Delete Commands

Basic Deletion

x        " Delete character under cursor (like 'del' key)
X        " Delete character before cursor (like 'backspace')
d{motion}" Delete text defined by motion
dd       " Delete entire line
D        " Delete to end of line (same as d$)

# With counts
3x       " Delete 3 characters
2dd      " Delete 2 lines
d3w      " Delete 3 words

Delete with Motions

dw       " Delete word
de       " Delete to end of word
db       " Delete to beginning of word
d2w      " Delete 2 words
d$       " Delete to end of line
d^       " Delete to first non-blank character
d0       " Delete to beginning of line
dG       " Delete to end of file
dgg      " Delete to beginning of file
d}       " Delete to end of paragraph
d{       " Delete to beginning of paragraph

Delete with Text Objects

diw      " Delete inner word
daw      " Delete a word (including surrounding whitespace)
dis      " Delete inner sentence
das      " Delete a sentence
dip      " Delete inner paragraph
dap      " Delete a paragraph
di"      " Delete inside quotes
da"      " Delete around quotes (including quotes)
di(      " Delete inside parentheses
da(      " Delete around parentheses
dit      " Delete inner HTML tag
dat      " Delete around HTML tag
di{      " Delete inside braces
da{      " Delete around braces (including braces)

Practical examples:

def calculate(price, quantity):
    total = price * quantity
    return total

Cursor on calculate:

daw     " Delete 'calculate ' (function name with space)

Cursor inside the function body:

di{     " Delete all lines inside the function

Cursor on a parameter:

daw     " Delete the parameter and trailing comma/space

Delete to Character

df{char}  " Delete forward to and including {char}
dt{char}  " Delete forward till (before) {char}
dF{char}  " Delete backward to and including {char}
dT{char}  " Delete backward till (after) {char}

Example:

const result = getValue(param1, param2);

Cursor at start of line:

dt(      " Delete till opening paren → (param1, param2);
df)      " Delete through closing paren → ;

Delete Lines Matching Pattern

:g/pattern/d    " Delete all lines containing pattern
:g!/pattern/d   " Delete all lines NOT containing pattern
:v/pattern/d    " Same as above (v = inverse of g)

Examples:

:g/TODO/d       " Delete all lines with TODO
:g/^$/d         " Delete all empty lines
:g/^\s*$/d      " Delete all blank lines (including whitespace-only)
:v/import/d     " Delete all lines that don't contain 'import'

3.4 Copy (Yank) and Paste

Yank Commands

y{motion}   " Yank text defined by motion
yy          " Yank entire line (same as Y)
Y           " Yank entire line

# With counts
2yy         " Yank 2 lines
y3w         " Yank 3 words
y$          " Yank to end of line
yG          " Yank to end of file
ygg         " Yank to beginning of file

Yank with Text Objects

yiw      " Yank inner word
yaw      " Yank a word
yip      " Yank inner paragraph
yap      " Yank a paragraph
yi"      " Yank inside quotes
ya"      " Yank around quotes
yi(      " Yank inside parentheses
ya(      " Yank around parentheses
yit      " Yank inner HTML tag
yat      " Yank around HTML tag

Paste Commands

p        " Paste after cursor/below line
P        " Paste before cursor/above line
gp       " Paste and move cursor after pasted text
gP       " Paste before and move cursor after pasted text

# With counts
3p       " Paste 3 times
5P       " Paste 5 times above

Line-wise vs Character-wise paste:

If you yanked a full line with yy:

p        " Pastes below current line
P        " Pastes above current line

If you yanked characters/words with yw:

p        " Pastes after cursor
P        " Pastes before cursor

Paste from Different Registers

"ayy     " Yank line into register 'a'
"ap      " Paste from register 'a'
"bdiw    " Delete inner word into register 'b'
"bp      " Paste from register 'b'

"+y      " Yank to system clipboard
"+p      " Paste from system clipboard
"*y      " Yank to primary selection (X11)
"*p      " Paste from primary selection

Practical workflow:

" Yank function definition to register 'f'
"fyy

" Navigate elsewhere
/another_function<CR>

" Paste it
"fp

Paste in Insert Mode

<C-r>{register}    " Paste from register while in insert mode
<C-r>"             " Paste from default register
<C-r>+             " Paste from system clipboard
<C-r>0             " Paste from yank register (not delete)

Example:

i                  " Enter insert mode
<C-r>"             " Paste what was last yanked/deleted
<C-r>+             " Paste from system clipboard

Paste Over Selection

In visual mode:

v                  " Visual select
p                  " Paste, replacing selection

Important: After p in visual mode, the replaced text goes to the unnamed register. To avoid this:

" Use a specific register for yanking first
"ay        " Yank to register 'a'
v          " Visual select other text
"ap        " Paste from 'a', replacing selection

Or use the black hole register for deletion:

v          " Visual select
"_dP       " Delete to black hole, then paste

3.5 Undo and Redo

Basic Undo/Redo

u          " Undo last change
<C-r>      " Redo (undo the undo)
U          " Undo all changes on current line

# With counts
3u         " Undo 3 times
5<C-r>     " Redo 5 times

Undo Branches

Vim maintains a tree of changes, not just a linear history. If you undo and then make a new change, Vim doesn’t discard the undone changes—they become a branch.

g-         " Go to older text state
g+         " Go to newer text state
:earlier 5m    " Go to text state 5 minutes ago
:later 10s     " Go to text state 10 seconds later
:earlier 3     " Go back 3 changes
:later 2       " Go forward 2 changes

Time-based undo:

:earlier 1h    " Text as it was 1 hour ago
:earlier 30m   " 30 minutes ago
:earlier 2d    " 2 days ago
:later 5m      " 5 minutes later than current state

View Undo Tree

:undolist      " Show undo branches

Better visualization with plugin:

-- Using undotree plugin
vim.keymap.set('n', '<leader>u', ':UndotreeToggle<CR>', { desc = 'Toggle undo tree' })

Persistent Undo

Neovim can save undo history across sessions:

vim.opt.undofile = true
vim.opt.undodir = vim.fn.stdpath('cache') .. '/undo'

Now you can close Neovim, reopen a file, and still undo changes from previous sessions.

3.6 Repeat and Reverse

The Dot Command

The single most powerful editing command:

.          " Repeat last change

What counts as a “change”?

• Any command that modified the buffer in normal mode

• Everything typed in a single insert mode session

Examples:

# Change word:
ciw         " Change inner word
new_name<Esc>

# Move to another word and repeat:
w           " Move to next word
.           " Repeat the change → changes this word to 'new_name'

Delete line pattern:

dd          " Delete line
j           " Move down
.           " Delete next line
j.          " Move and delete
j.          " Move and delete

Append semicolon to multiple lines:

A;<Esc>     " Append semicolon and exit insert mode
j           " Move down
.           " Repeat (append semicolon)
j.j.j.      " Continue on multiple lines

Making Changes Repeatable

Structure your edits to be dot-repeatable:

Not ideal:

/target<CR>  " Search
dwi          " Delete word, enter insert
new_text<Esc>
n            " Next match
dwi          " Delete word again
new_text<Esc>  " Type same thing again

Better (repeatable):

/target<CR>  " Search
cwnew_text<Esc>  " Change word to 'new_text'
n            " Next match
.            " Repeat the change
n.n.n.       " Continue on other matches

Reverse Last f, t, F, T

;          " Repeat last f, t, F, or T
,          " Reverse last f, t, F, or T

Example:

const result = calculateTotal(price, quantity, tax);

f,         " Find first comma
.          " Not applicable (. doesn't work with motions)
;          " Find next comma
;          " Find next comma
,          " Go back to previous comma

But when combined with operators:

df,        " Delete to comma
;          " Find next comma
.          " Repeat delete to comma

Repeat Ex Commands

@:         " Repeat last Ex command
@@         " Repeat last @: (after first use)

Example:

:s/old/new/g    " Substitute in current line
j               " Move down
@:              " Repeat substitution
j@@             " Move down and repeat again

3.7 Visual Mode Editing

Entering Visual Mode

v          " Character-wise visual mode
V          " Line-wise visual mode
<C-v>      " Block-wise visual mode (column mode)
gv         " Reselect last visual selection

Visual Mode Operators

Once in visual mode, select text and apply operators:

d          " Delete selection
c          " Change selection
y          " Yank selection
~          " Toggle case
u          " Make lowercase
U          " Make uppercase
>          " Indent right
<          " Indent left
=          " Auto-indent
J          " Join lines
gq         " Format/wrap text

Example:

def calculate_total(price, quantity):
    subtotal = price * quantity
    tax = subtotal * 0.1
    total = subtotal + tax
    return total

Select the function body:

vi{        " Visual select inside braces
>          " Indent right

Visual Block Mode (Column Editing)

This is one of Vim’s killer features:

<C-v>      " Enter visual block mode

Example - Add semicolons to multiple lines:

const name = "John"
const age = 30
const city = "NYC"

1. Position cursor at end of first line

2. <C-v> to enter block mode

3. 2j to select down 2 lines (creates column)

4. $ to extend to end of each line

5. A to append

6. Type ;

7. <Esc> (semicolon appears on all lines)

Result:

const name = "John";
const age = 30;
const city = "NYC";

Example - Insert at beginning of multiple lines:

print("Line 1")
print("Line 2")
print("Line 3")

1. Position cursor at start of first line

2. <C-v> block mode

3. 2j to select down

4. I to insert before

5. Type #

6. <Esc>

Result:

# print("Line 1")
# print("Line 2")
# print("Line 3")

Visual Block with Ragged Lines

When lines have different lengths:

<C-v>      " Block mode
3j         " Down 3 lines
$          " Extend to end of each line (ragged)
A text<Esc>  " Append to all lines

Visual Line Mode

V          " Enter line-wise visual mode
3j         " Select 3 lines down
d          " Delete selected lines

Or directly:

3Vd        " Select 3 lines and delete

Increment/Decrement in Visual Block

<C-v>      " Block mode (select column of numbers)
g<C-a>     " Increment sequentially (1, 2, 3, 4...)
g<C-x>     " Decrement sequentially
<C-a>      " Increment all by 1
<C-x>      " Decrement all by 1

Example - Create numbered list:

Item Item Item Item

1. Cursor at start of first line

2. <C-v>3j to select column

3. I1. <Esc> to insert “1.”

4. Result:

5. Item

6. Item

7. Item

8. Item

9. Reselect: gv

10. g<C-a> to increment sequentially

Result:

1. Item

2. Item

3. Item

4. Item

3.8 Search and Replace

Basic Substitution

:s/old/new/          " Replace first occurrence in current line
:s/old/new/g         " Replace all occurrences in current line
:s/old/new/gc        " Replace all with confirmation
:%s/old/new/g        " Replace all in entire file
:%s/old/new/gc       " Replace all in entire file with confirmation
:5,10s/old/new/g     " Replace in lines 5-10
:'<,'>s/old/new/g    " Replace in visual selection

Flags:

• g - Global (all occurrences in line)

• c - Confirm each substitution

• i - Case insensitive

• I - Case sensitive

• n - Report number of matches without substituting

Examples:

:%s/foo/bar/g        " Replace all 'foo' with 'bar'
:%s/foo/bar/gc       " Same, but ask for confirmation
:%s/foo/bar/gn       " Count how many 'foo' exist
:%s/\<foo\>/bar/g    " Replace whole word 'foo' only
:%s/foo/bar/gi       " Case-insensitive replacement

Range Substitution

:1,10s/old/new/g     " Lines 1 to 10
:.,+5s/old/new/g     " Current line plus next 5
:.-3,.+3s/old/new/g  " 3 lines before to 3 lines after
:1,$s/old/new/g      " All lines (same as %)
:.,$s/old/new/g      " Current line to end

Pattern Matching in Substitution

:%s/\d\+/NUMBER/g          " Replace all numbers with 'NUMBER'
:%s/^/# /                   " Comment out lines (add # at start)
:%s/$/ END/                 " Append ' END' to all lines
:%s/\s\+$//                 " Remove trailing whitespace
:%s/^\_s\+$//               " Remove blank lines

Capture Groups and Backreferences

:%s/\(\w\+\) \(\w\+\)/\2 \1/   " Swap first two words
:%s/"\(.*\)"/'\1'/              " Change double quotes to single
:%s/\(.*\)/[\1]/                " Wrap each line in brackets

Example:

Text: John Doe Jane Smith

Command:

:%s/\(\w\+\) \(\w\+\)/\2, \1/

Result: Doe, John Smith, Jane

Using \= for Expression Substitution

:%s/\d\+/\=submatch(0) * 2/    " Double all numbers
:%s/.*/\=line('.')/            " Replace each line with its line number

Example:

Text: Price: 10 Price: 20 Price: 30

Command:

:%s/\d\+/\=submatch(0) * 2/g

Result: Price: 20 Price: 40 Price: 60

Special Characters in Replacement

\r       " Insert newline
\n       " Insert null (appears as ^@)
\t       " Insert tab
&        " Insert the whole matched pattern
~        " Use replacement from previous substitute
\L       " Make following chars lowercase
\U       " Make following chars uppercase
\0       " Insert whole matched pattern (same as &)
\1-\9    " Insert captured groups

Example - Add newline after comma:

:%s/, /,\r/g

Text: apple, banana, cherry

Result: apple, banana, cherry

Global Command

:g/pattern/command          " Execute command on lines matching pattern
:g!/pattern/command         " Execute on lines NOT matching
:v/pattern/command          " Same as g! (inverse)

Examples:

:g/TODO/d               " Delete all lines with TODO
:g/^$/d                 " Delete empty lines
:g/pattern/m$           " Move matching lines to end of file
:g/pattern/t$           " Copy matching lines to end of file
:g/pattern/normal @a    " Execute macro 'a' on matching lines
:g/import/s/$/;/        " Add semicolon to lines with 'import'

Complex example - Sort CSS properties:

.container {
    padding: 10px;
    color: red;
    margin: 5px;
    display: flex;
}

:g/{/+1,/}/-1 sort

Result (properties sorted):

.container {
    color: red;
    display: flex;
    margin: 5px;
    padding: 10px;
}

3.9 Case Conversion

Toggle Case

~          " Toggle case of character under cursor
g~{motion} " Toggle case of text defined by motion
g~~        " Toggle case of entire line
g~iw       " Toggle case of inner word

Make Lowercase

gu{motion} " Make lowercase
guu        " Make current line lowercase
guiw       " Make inner word lowercase
gue        " Make to end of word lowercase
gu$        " Make to end of line lowercase
guG        " Make to end of file lowercase

Make Uppercase

gU{motion} " Make uppercase
gUU        " Make current line uppercase
gUiw       " Make inner word uppercase
gUe        " Make to end of word uppercase
gU$        " Make to end of line uppercase

Visual Mode Case Change

v          " Visual select
u          " Make selection lowercase
U          " Make selection uppercase
~          " Toggle case of selection

Title Case

Vim doesn’t have built-in title case, but you can use substitution:

:%s/\<\(\w\)\(\w*\)\>/\u\1\L\2/g

This capitalizes the first letter of each word and lowercases the rest.

3.10 Indentation

Manual Indentation

>>         " Indent current line right
<<         " Indent current line left
>>{motion} " Indent motion right
>i{        " Indent inside braces
>ap        " Indent a paragraph
5>>        " Indent 5 lines right

Visual Mode Indentation

v          " Visual select
>          " Indent right
<          " Indent left

" Stay in visual mode after indenting:
v
>          " Indent
gv         " Reselect
>          " Indent again

Better: Configure indentation to stay in visual mode:

vim.keymap.set('v', '<', '<gv', { desc = 'Indent left and reselect' })
vim.keymap.set('v', '>', '>gv', { desc = 'Indent right and reselect' })

Now you can repeatedly press > or < without losing selection.

Auto-Indent

={motion}  " Auto-indent motion
==         " Auto-indent current line
=ap        " Auto-indent paragraph
=i{        " Auto-indent inside braces
gg=G       " Auto-indent entire file

With LSP formatting:

vim.keymap.set('n', '<leader>f', vim.lsp.buf.format, { desc = 'Format buffer' })

Or:

:lua vim.lsp.buf.format()

Set Indentation Settings

vim.opt.shiftwidth = 4      -- Indent by 4 spaces
vim.opt.tabstop = 4         -- Tab displays as 4 spaces
vim.opt.expandtab = true    -- Convert tabs to spaces
vim.opt.smartindent = true  -- Auto-indent new lines
vim.opt.autoindent = true   -- Copy indent from current line

Reindent Pasted Text

]p         " Paste and adjust indent to match current line
[p         " Same, but paste above

Or after pasting normally:

p          " Paste
=`]        " Reindent from start to end of pasted text

3.11 Joining and Splitting Lines

Join Lines

J          " Join current line with next (adds space)
gJ         " Join without adding space
3J         " Join next 3 lines

Examples:

name = "John"
age = 30

Cursor on first line, J:

name = "John" age = 30

With gJ:

name = "John"age = 30

Visual Mode Join

V          " Line-wise visual
3j         " Select 3 more lines
J          " Join all selected lines

Join with Specific Separator

No built-in command, but can use substitution:

:%s/\n/, /g    " Join all lines with comma-space

Or with a range:

:5,10s/\n/, /g  " Join lines 5-10 with comma

Split Lines

Vim doesn’t have a dedicated split command, but you can:

Method 1: Insert newline in normal mode

i<CR><Esc>     " Split at cursor position

Method 2: Substitute

:s/, /,\r/g    " Split at each comma

Method 3: Macro for splitting

:norm f,a^M    " Find comma, append newline (^M = <C-v><CR>)

3.12 Increment and Decrement

Basic Increment/Decrement

<C-a>      " Increment number under cursor
<C-x>      " Decrement number under cursor
5<C-a>     " Increment by 5
10<C-x>    " Decrement by 10

Examples:

count = 10

Cursor on 10, press <C-a>:

count = 11

Press 5<C-a>:

count = 16

Increment/Decrement in Visual Mode

<C-v>      " Block mode, select column of numbers
g<C-a>     " Increment sequentially (1, 2, 3, 4...)
g<C-x>     " Decrement sequentially
<C-a>      " Increment all by same amount

Example:

Item 0 Item 0 Item 0

Select the numbers with <C-v>, then g<C-a>: Item 1 Item 2 Item 3

Alphabetic Increment

By default, Vim only increments numbers. To increment letters:

vim.opt.nrformats:append('alpha')

Now: version_a

Cursor on a, press <C-a>: version_b

3.13 Formatting and Wrapping

Format/Wrap Lines

gq{motion}  " Format (hard wrap) text
gqq         " Format current line
gqap        " Format a paragraph
gqG         " Format from cursor to end of file

Example with textwidth:

vim.opt.textwidth = 80

Long line: This is a very long line that exceeds the textwidth setting and should be wrapped to multiple lines.

Position cursor on line, gqq: This is a very long line that exceeds the textwidth setting and should be wrapped to multiple lines.

Format Without Moving

gw{motion}  " Format but keep cursor position
gwap        " Format paragraph, stay at cursor

Join Lines Without Extra Space

gJ         " Join lines without inserting space

Format Comments

With formatoptions set correctly:

vim.opt.formatoptions:append('r')  -- Auto-insert comment leader on <CR>
vim.opt.formatoptions:append('o')  -- Auto-insert comment leader on 'o'/'O'
vim.opt.formatoptions:append('q')  -- Allow formatting comments with gq
vim.opt.formatoptions:append('n')  -- Recognize numbered lists
vim.opt.formatoptions:append('j')  -- Remove comment leader when joining

Now gqap in a comment block properly formats it.

External Formatting

!{motion}{program}  " Filter through external program
!!{program}         " Filter current line
5!!{program}        " Filter 5 lines

Examples:

!apsort            " Sort paragraph
!5jsort            " Sort next 5 lines
:%!python -m json.tool   " Format entire file as JSON
:'<,'>!column -t   " Align visual selection as columns

3.14 Working with Registers

Register Types

"           " Unnamed register (default)
0-9         " Numbered registers (yank and delete history)
a-z         " Named registers (user-defined)
A-Z         " Append to named registers

-           " Small delete register (< 1 line)

+           " System clipboard

*           " Primary selection (X11)
/           " Last search pattern
:           " Last command
.           " Last inserted text
%           " Current filename
#           " Alternate filename
=           " Expression register
_           " Black hole register

Using Named Registers

"ayy       " Yank line to register 'a'
"bdd       " Delete line to register 'b'
"ap        " Paste from register 'a'
"bp        " Paste from register 'b'

Appending to Registers

"ayy       " Yank to register 'a'
j
"Ayy       " Append next line to register 'a' (uppercase A)
"ap        " Paste both lines

Black Hole Register

"_d        " Delete to black hole (doesn't overwrite other registers)
"_dd       " Delete line to black hole
"_x        " Delete character to black hole

Use case: You want to delete something without affecting your yank register:

yiw        " Yank word
/other     " Find other location
diw        " This would overwrite your yank!

" Instead:
yiw
/other
"_diw      " Delete to black hole
p          " Paste your original yank

Expression Register

"=         " Access expression register (in insert mode: <C-r>=)
<C-r>=5*8  " Insert result of 5*8

In normal mode:

"=5*8<CR>p  " Calculate 5*8 and paste result

View Register Contents

:reg       " View all registers
:reg a b   " View registers a and b
:reg "     " View unnamed register
:reg +     " View clipboard register

Last Inserted Text

.          " Repeat last change
".p        " Paste last inserted text

3.15 Recording Macros (Detailed)

Basic Macro Recording

q{register}   " Start recording to {register}
# Perform actions
q             " Stop recording
@{register}   " Play back macro
@@            " Repeat last played macro
5@{register}  " Play macro 5 times

Example - Add quotes around words:

apple banana cherry

1. Position cursor on ‘a’ in ‘apple’

2. qa - start recording to register ‘a’

3. i"<Esc> - insert quote before

4. ea"<Esc> - append quote after

5. j0 - move to next line, column 0

6. q - stop recording

Now execute:

2@a        " Run on next 2 lines

Result: “apple” “banana” “cherry”

Recursive Macros

qaq        " Clear register a
qa         " Start recording
# Perform action
@a         " Call macro recursively
q          " Stop recording
@a         " Execute (will run until it fails)

Example - Process until end of file:

qaq        " Clear a
qa
dd         " Delete line
j          " Move down
@a         " Recursive call
q

@a         " Runs on all lines until end

Editing Macros

" View macro content:
:reg a

" Paste macro to edit:
"ap

" Edit the line
# Make changes

" Yank back to register:
"add

" Or directly:
:let @a = 'i"<Esc>ea"<Esc>j0'

Parallel Macro Execution

Run macro on multiple lines:

:5,10normal @a    " Run macro 'a' on lines 5-10
:%normal @a       " Run on all lines
:'<,'>normal @a   " Run on visual selection

Macro Best Practices

1. Start from known position (e.g., 0 for beginning of line)

2. End in a repeatable position (e.g., j0 to move to next line start)

3. Use motions, not counts when possible (more robust)

4. Test on a few lines first

5. Use recursive macros for unknown quantity of items

Example of robust vs fragile:

Fragile:

qa
3l        " Move right 3 times (fails if line is shorter)
x
q

Robust:

qa
f,        " Find comma (more reliable)
x
j0        " Next line, start
q

3.16 Advanced Text Objects (with Plugins)

Targets.vim Extended Text Objects

If you install targets.vim plugin, you get many more text objects:

" Pair text objects work with:
da)    " Delete around ) even when not inside
di)    " Delete inside )
dI)    " Delete inside ) excluding whitespace
dA)    " Delete around ) including whitespace

" Work with: () {} [] <> `` '' "" 

" Separator text objects:
di,    " Delete inside commas
da,    " Delete around commas (including separators)
dI,    " Delete inside, skip boundaries
dA,    " Delete around, including boundaries

" Work with: , . ; : + - = ~ _ * # / | \ & $

" Argument text objects:
cia    " Change inner argument
daa    " Delete an argument (including comma)

Example:

function example(arg1, arg2, arg3) {

Cursor anywhere in arg2:

daa    " Deletes ', arg2'

Tree-sitter Text Objects

With nvim-treesitter-textobjects:

require'nvim-treesitter.configs'.setup {
  textobjects = {
    select = {
      enable = true,
      keymaps = {
        ["af"] = "@function.outer",
        ["if"] = "@function.inner",
        ["ac"] = "@class.outer",
        ["ic"] = "@class.inner",
        ["aa"] = "@parameter.outer",
        ["ia"] = "@parameter.inner",
      },
    },
  },
}

Now you have:

daf    " Delete a function
cif    " Change inside function
vac    " Visual select a class
daa    " Delete a parameter/argument

These work across multiple programming languages!

3.17 Editing Best Practices

1. Prefer Text Objects Over Motions

Instead of:

dw     " Delete word (leaves trailing space)

Use:

daw    " Delete a word (cleaner)

Instead of:

f"     " Find quote
dt"    " Delete till quote

Use:

di"    " Delete inside quotes

2. Make Changes Repeatable

Structure edits so . works effectively:

Example - Replace multiple words:

/old_name<CR>   " Find first occurrence
cwnew_name<Esc> " Change word
n.              " Next occurrence, repeat
n.              " Continue

3. Use Macros for Complex Repetitions

If . isn’t enough, record a macro:

qa              " Start recording
# Complex multi-step edit
q               " Stop
@a              " Replay

4. Minimize Mode Switching

Instead of:

A<space><Esc>   " Append space, exit
A;<Esc>         " Append semicolon, exit (separate action)

Do:

A ;<Esc>        " Append both in one insert session

This makes . repeat both actions.

5. Use Composability

Combine operators and motions creatively:

c3w            " Change 3 words
d/end<CR>      " Delete to 'end'
y}             " Yank to end of paragraph
gU4j           " Uppercase 4 lines

6. Keep Register Hygiene

Use specific registers to avoid conflicts:

"ay            " Important yank to register 'a'
# Do other work
"ap            " Still have it

Use black hole register for throwaway deletes:

"_dd           " Delete without polluting registers

3.18 Editing Exercises

Exercise 1: Text Object Mastery

Open a code file and practice:

1. Position cursor in a function

2. Try: dif (delete inside function)

3. Undo: u

4. Try: vif (visual select inside function)

5. Try: yaf (yank around function)

Repeat with:

- di" and da" (quotes)

- di( and da( (parentheses)

- di{ and da{ (braces)

- diw and daw (word)

- dip and dap (paragraph)

Exercise 2: Dot Command Practice

// Original text (3 lines): const oldName = value const oldName = value const oldName = value

// Goal: Change all ‘oldName’ to ‘newName’

Solution:

/oldName<CR>    " Find first
ciwnewName<Esc> " Change it
n.              " Next and repeat
n.              " Next and repeat

Exercise 3: Visual Block Magic

// Original: Item 1 Item 1 Item 1 Item 1

// Goal: Item 1 Item 2 Item 3 Item 4

Solution:

<C-v>           " Block mode
3j              " Select down
$               " To end of lines
A<Backspace><Esc> " Delete the '1'
gv              " Reselect
g<C-a>          " Sequential increment

Exercise 4: Macro Recording

// Original (lines of words): apple banana cherry date

// Goal (wrap in array): [“apple”], [“banana”], [“cherry”], [“date”]

Solution:

qa              " Start recording to 'a'
I["<Esc>        " Insert '["' at beginning
A"],<Esc>       " Append '"],' at end
j0              " Next line, column 0
q               " Stop recording
3@a             " Repeat on remaining 3 lines

Exercise 5: Search and Replace

// Original: function calculate(x, y, z) result = calculate(a, b, c) value = calculate(1, 2, 3)

// Goal: Change ‘calculate’ to ‘compute’

Solution:

:%s/\<calculate\>/compute/g

Or with confirmation:

:%s/\<calculate\>/compute/gc

Exercise 6: Complex Deletion

Delete all lines containing “TODO” and “FIXME”:

:g/TODO\|FIXME/d

Or delete all empty lines:

:g/^$/d

Exercise 7: Indentation Challenge

# Badly indented:
def example():
print("hello")
if True:
print("world")
return

Fix it:

vi{     " Visual select inside function
=       " Auto-indent

Or entire file:

gg=G    " From top to bottom, indent

Chapter Summary

In this chapter, you learned:

• Vim’s editing grammar: Operators + Motions + Text Objects forming a composable language

• Complete operator set: d, c, y, ~, gu, gU, >, <, =, and more

• All text objects: iw/aw, i"/a", i(/a(, it/at, ip/ap, etc.

• Insert mode commands: i, I, a, A, o, O, gi

• Deletion techniques: x, dd, D, d{motion}, text object deletion

• Yank and paste: Registers, system clipboard integration, paste modes

• Undo/redo system: Linear undo, undo branches, time-based undo, persistent undo

• Dot command: The most powerful editing tool for repeating changes

• Visual modes: Character, line, and block-wise editing

• Search and replace: Substitution, ranges, capture groups, global commands

• Case conversion: ~, gu, gU with motions and text objects

• Indentation: Manual and automatic, with LSP formatting

• Joining and splitting: J, gJ, and techniques for line manipulation

• Increment/decrement: <C-a>, <C-x>, sequential incrementing in visual block

• Text formatting: gq, gw, external formatters

• Registers: Named, special, system clipboard, black hole

• Macro recording: Basic, recursive, editing macros, parallel execution

• Advanced text objects: Plugin-enhanced with targets.vim and tree-sitter

• Best practices: Repeatability, composability, efficiency

You now have a complete editing vocabulary. The key to mastery is practice—these commands need to become muscle memory. In the next chapter, we’ll explore Visual Mode in depth, including advanced selection techniques and visual mode operators that weren’t covered here.

Chapter 4: Search and Replace

Search and replace is where Vim’s modal editing and powerful pattern matching converge. While we touched on basic substitution in Chapter 3, this chapter dives deep into Vim’s search capabilities, regular expressions, the substitution command, and advanced pattern-matching techniques that make complex text transformations trivial.

4.1 Search Fundamentals

Basic Search Commands

/{pattern}       " Search forward for pattern
?{pattern}       " Search backward for pattern
n                " Repeat search in same direction
N                " Repeat search in opposite direction

*                " Search forward for word under cursor
#                " Search backward for word under cursor
g*               " Search forward for word under cursor (partial match)
g#               " Search backward for word under cursor (partial match)

Examples:

/function        " Search forward for "function"
n                " Next occurrence
N                " Previous occurrence

?return          " Search backward for "return"
n                " Next (backward)
N                " Previous (forward)


*                " Search for exact word under cursor
#                " Search backward for word under cursor

Case Sensitivity

/pattern         " Case sensitivity depends on 'ignorecase' setting
/pattern\c       " Force case-insensitive search
/pattern\C       " Force case-sensitive search

Configuration:

vim.opt.ignorecase = true      -- Ignore case in searches
vim.opt.smartcase = true       -- Override ignorecase if pattern has uppercase

With smartcase:

/hello           " Matches: hello, Hello, HELLO
/Hello           " Matches: Hello only (uppercase present)

Search Highlighting

vim.opt.hlsearch = true        -- Highlight all matches
vim.opt.incsearch = true       -- Show matches as you type

Clear highlighting:

:noh             " Or :nohlsearch - clear search highlighting

Better: Map a key to clear:

vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>', { desc = 'Clear search highlighting' })

Search History

/{up-arrow}      " Cycle through previous search patterns
/{down-arrow}    " Cycle forward
/<C-r>/          " Insert last search pattern
q/               " Open search history window (editable)

Search history window (q/):

• Edit any previous search

• Press <CR> to execute

• Press <C-c> to cancel

Search Offsets

Position cursor relative to match:

/pattern/        " Cursor at start of match
/pattern/e       " Cursor at end of match
/pattern/+2      " 2 lines below match
/pattern/-1      " 1 line above match
/pattern/e+1     " 1 character after end of match
/pattern/e-2     " 2 characters before end of match
/pattern/b+3     " 3 characters after beginning of match

Examples:

def calculate_total(price, quantity):
    return price * quantity

/def/e           " Cursor on 'f' (end of 'def')
/def/+1          " Cursor on line below
/price/e+2       " Cursor 2 chars after 'price' (on 'c' in 'calculate')

Search Under Cursor

*                " Search for exact word under cursor (forward)
#                " Search backward
g*               " Search forward (partial match)
g#               " Search backward (partial match)
gd               " Go to local definition
gD               " Go to global definition

Difference between * and g*:

count = 10
account = 20

Cursor on count, press *:

• Matches: count only (exact word)

Press g*:

• Matches: count and account (partial)

Visual Search

Select text in visual mode and search for it:

Manual:

v                " Visual select
y                " Yank
/<C-r>"          " Paste into search

Better with mapping:

vim.keymap.set('v', '*', 'y/\\V<C-R>=escape(@",\'/\\\')<CR><CR>', 
  { desc = 'Search for visual selection' })

Now:

v                " Visual select

*                " Search for selection

4.2 Regular Expressions in Vim

Vim uses its own regex flavor, which differs slightly from other tools.

Magic Modes

Vim has different “magic” levels affecting which characters need escaping:

\v               " Very magic (most chars have special meaning)
\m               " Magic (default)
\M               " No magic (most chars literal)
\V               " Very no magic (all chars literal except \)

Examples:

/\vword\d+       " Very magic: word followed by digits
/word\d\+        " Magic (default): same thing
/\Mword\d\+      " No magic: same, but needs escaping
/\Vword          " Very no magic: literal 'word' search

Best practice: Use \v (very magic) for complex patterns:

/\v(foo|bar)     " Match 'foo' or 'bar'
/(foo\|bar)      " Same in default magic mode (needs escaping)

Character Classes

.                " Any character except newline
\s               " Whitespace character (space, tab, newline)
\S               " Non-whitespace
\d               " Digit [0-9]
\D               " Non-digit
\w               " Word character [a-zA-Z0-9_]
\W               " Non-word character
\h               " Head of word character [a-zA-Z_]
\a               " Alphabetic character
\l               " Lowercase letter
\u               " Uppercase letter
\x               " Hexadecimal digit [0-9a-fA-F]

\_s              " Whitespace including newline
\_^              " Start of line (in multiline pattern)
\_$              " End of line (in multiline pattern)
\_. " Any character including newline

Examples:

/\d\+            " One or more digits
/\w\+@\w\+\.\w\+ " Simple email pattern
/\s\+            " One or more whitespace chars
/\h\w*           " Identifier (letter/underscore + word chars)

Quantifiers

*                " 0 or more (greedy)
\+               " 1 or more (greedy)
\?               " 0 or 1 (optional)
\{n}             " Exactly n times
\{n,}            " At least n times
\{,m}            " At most m times
\{n,m}           " Between n and m times

\{-}             " 0 or more (non-greedy)
\{-1,}           " 1 or more (non-greedy)
\{-,1}           " 0 or 1 (non-greedy)

Examples:

/\d\{3}          " Exactly 3 digits
/\d\{3,5}        " 3 to 5 digits
/\d\{3,}         " 3 or more digits
/\w\+            " 1 or more word characters
/\s\?            " Optional whitespace

Greedy vs Non-greedy:

Text: <div>content</div>

/<.*>            " Greedy: matches '<div>content</div>' (entire string)
/<.\{-}>         " Non-greedy: matches '<div>' (first tag)

Anchors

^                " Start of line
$                " End of line
\<               " Start of word
\>               " End of word
\%^              " Start of file
\%$              " End of file
\%V              " Inside visual selection
\%#              " Cursor position

Examples:

/^import         " Lines starting with 'import'
/;$              " Lines ending with semicolon
/\<def\>         " Exact word 'def' (not 'define' or 'ifdef')
/\%^#!/          " Shebang at start of file
/\%$             " Match at end of file

Grouping and Alternation

\(pattern\)      " Capture group (default magic)
\%(pattern\)     " Non-capturing group
\|               " Alternation (OR)

" With very magic (\v):
(pattern)        " Capture group
%(pattern)       " Non-capturing group
|                " Alternation

Examples:

/\(foo\|bar\)    " Match 'foo' or 'bar'
/\v(foo|bar)     " Same with very magic

/\(Mr\|Ms\|Dr\)\. " Match 'Mr.', 'Ms.', or 'Dr.'
/\v(Mr|Ms|Dr)\.  " Same with very magic

Backreferences

\1, \2, \3...    " Reference captured groups (in pattern)
\0               " Entire match

Examples:

/\(\w\+\) \1     " Match repeated word: "the the"
/\v(\w+) \1      " Same with very magic

/\v"(.{-})"      " Match quoted string (capture content)
/\v(['"])(.\{-})\1  " Match quoted string with same quote type

Example - Find duplicate words:

/\v<(\w+)\_s+\1>  " Find duplicate words (even across lines)

Text: The the cat sat on the mat. This is is a test.

Both duplicate pairs will be found.

Character Ranges

[abc]            " Match a, b, or c
[a-z]            " Match lowercase letter
[A-Z]            " Match uppercase letter
[0-9]            " Match digit
[a-zA-Z0-9]      " Match alphanumeric
[^abc]           " Match anything except a, b, c
[^0-9]           " Match non-digit

Examples:

/[aeiou]         " Match vowel
/[^aeiou]        " Match consonant (and other chars)
/[0-9]\{3}-[0-9]\{4}  " Match phone pattern: 123-4567
/\v[A-Z][a-z]+   " Capitalized word

Lookahead and Lookbehind

\@=              " Positive lookahead
\@!              " Negative lookahead
\@<=             " Positive lookbehind
\@<!             " Negative lookbehind

Positive lookahead - Match X only if followed by Y:

/\vfoo(@=bar)    " Match 'foo' only if followed by 'bar'
/foo\(bar\)\@=   " Same in default magic

Text: foobar foobaz

• Matches: foo in foobar only

Negative lookahead - Match X only if NOT followed by Y:

/\vfoo(@!bar)    " Match 'foo' NOT followed by 'bar'

Text: foobar foobaz

• Matches: foo in foobaz only

Positive lookbehind - Match X only if preceded by Y:

/\v(@<=foo)bar   " Match 'bar' only if preceded by 'foo'
/\(foo\)\@<=bar  " Same in default magic

Negative lookbehind - Match X only if NOT preceded by Y:

/\v(@<!foo)bar   " Match 'bar' NOT preceded by 'foo'

Practical example - Match numbers not in comments:

# price = 100
total = 200

/\v^[^#]*\zs\d+  " Match numbers not in lines starting with #

Matches: 200 only (not 100 because that line starts with #)

Zero-width Assertions

\zs              " Start of match (ignore everything before)
\ze              " End of match (ignore everything after)

Examples:

/foo\zsbar       " Match 'bar' (in 'foobar'), but highlight only 'bar'
/foo\zebar       " Match 'foo' (in 'foobar'), but highlight only 'foo'

Text: foobar

/foo\zsbar       " Cursor on 'b' (match starts at 'b')
/foo\zebar       " Cursor on 'f' (match ends before 'b')

Practical use - Extract URL path:

https://example.com/path/to/file.html

/\v\.com\/\zs.*  " Match everything after '.com/'

Match highlighted: path/to/file.html

4.3 Search Configuration

Essential Search Settings

-- Case handling
vim.opt.ignorecase = true      -- Ignore case by default
vim.opt.smartcase = true       -- Case-sensitive if uppercase present


-- Highlighting
vim.opt.hlsearch = true        -- Highlight matches
vim.opt.incsearch = true       -- Incremental search (show as you type)


-- Wrapping
vim.opt.wrapscan = true        -- Wrap around end of file


-- Show match count
vim.opt.shortmess:append("S")  -- Don't show "search hit BOTTOM"

Advanced Search Options

-- Show search count in command line
vim.opt.shortmess:remove("S")  -- Shows [1/5] when searching


-- Center screen on search
vim.keymap.set('n', 'n', 'nzz', { desc = 'Next search result (centered)' })
vim.keymap.set('n', 'N', 'Nzz', { desc = 'Previous search result (centered)' })


-- Clear search with Escape
vim.keymap.set('n', '<Esc>', '<cmd>nohlsearch<CR>', { desc = 'Clear search highlight' })


-- Use ripgrep for :grep if available
if vim.fn.executable('rg') == 1 then
  vim.opt.grepprg = 'rg --vimgrep --smart-case --follow'
  vim.opt.grepformat = '%f:%l:%c:%m'
end

Search-Related Keymaps

-- Keep cursor centered when searching
vim.keymap.set('n', 'n', 'nzzzv', { desc = 'Next result (centered, unfold)' })
vim.keymap.set('n', 'N', 'Nzzzv', { desc = 'Previous result (centered, unfold)' })


-- Better star command (don't move on first *)
vim.keymap.set('n', '*', '*N', { desc = 'Search word under cursor (stay)' })
vim.keymap.set('n', '#', '#N', { desc = 'Search word backward (stay)' })


-- Visual mode search
vim.keymap.set('v', '*', 'y/\\V<C-R>=escape(@",\'/\\\')<CR><CR>',
  { desc = 'Search for visual selection' })

4.4 The Substitute Command

Basic Syntax

:[range]s/{pattern}/{replacement}/{flags}

Components:

• [range]: Lines to operate on (optional, defaults to current line)

• {pattern}: What to search for (regex)

• {replacement}: What to replace with

• {flags}: Modifiers (g, c, i, etc.)

Common Ranges

:s/old/new/          " Current line only
:%s/old/new/         " Entire file
:5,10s/old/new/      " Lines 5 to 10
:'<,'>s/old/new/     " Visual selection
:.,$s/old/new/       " Current line to end of file
:.,+5s/old/new/      " Current line plus 5 lines
:.-3,.+3s/old/new/   " 3 lines before to 3 after current
:1,$s/old/new/       " Line 1 to last line (same as %)

Mark-based ranges:

:'a,'bs/old/new/     " From mark a to mark b
:'{,'}s/old/new/     " Last visual selection (same as '<,'>)

Substitute Flags

g                " Global (all occurrences in line)
c                " Confirm each substitution
i                " Case insensitive
I                " Case sensitive
n                " Report count without substituting
e                " No error if pattern not found
&                " Reuse flags from previous substitute

Examples:

:%s/foo/bar/g        " Replace all 'foo' with 'bar'
:%s/foo/bar/gc       " Same, but ask for confirmation
:%s/foo/bar/gi       " Case-insensitive replacement
:%s/foo/bar/gn       " Count matches without replacing
:%s/foo/bar/ge       " No error if no matches found

Confirmation prompts: When using c flag: y - Yes, substitute this match n - No, skip this match a - All, substitute all remaining matches q - Quit, stop substituting l - Last, substitute this match and quit ^E - Scroll up ^Y - Scroll down

Special Characters in Replacement

\r               " Insert newline
\n               " Insert null byte (appears as ^@)
\t               " Insert tab
&                " Insert entire matched pattern
~                " Use replacement from previous substitute
\L               " Make following characters lowercase
\U               " Make following characters uppercase
\E               " End \L or \U
\l               " Make next character lowercase
\u               " Make next character uppercase
\0               " Insert entire match (same as &)
\1, \2, etc.     " Insert captured groups

Examples:

:%s/foo/& bar/       " Replace 'foo' with 'foo bar'
:%s/\(.*\)/[\1]/     " Wrap each line in brackets
:%s/\w\+/\u&/g       " Capitalize first letter of each word
:%s/\(.\)/\U\1/g     " Uppercase entire file
:%s/\(\w\)/\L\1/g    " Lowercase first letter of each word

Replace with Newline

:%s/, /,\r/g         " Replace comma-space with comma-newline

Example:

Text: apple, banana, cherry

After :s/, /,\r/g: apple, banana, cherry

Using Captured Groups

:\%s/\(\w\+\) \(\w\+\)/\2, \1/    " Swap first two words

Example:

Text: John Doe Jane Smith

After :%s/\(\w\+\) \(\w\+\)/\2, \1/: Doe, John Smith, Jane

Multiple Captures

:%s/\v(\d+)-(\d+)-(\d+)/\3\/\2\/\1/   " Date format: YYYY-MM-DD → DD/MM/YYYY

Example:

Text: 2024-10-19

After substitution: 19/10/2024

Expression Register in Replacement

Use \= to evaluate expressions:

:%s/\d\+/\=submatch(0) * 2/      " Double all numbers
:%s/$/\=line('.')/               " Append line number to each line
:%s/\d\+/\=printf('%03d', submatch(0))/  " Zero-pad numbers to 3 digits

Examples:

Text: Price: 10 Price: 25 Price: 100

After :%s/\d\+/\=submatch(0) * 2/g: Price: 20 Price: 50 Price: 200

Functions available in expression:

• submatch(0) - entire match

• submatch(1) - first capture group

• line('.') - current line number

• strlen() - string length

• strftime() - date/time formatting

• Any Vimscript/Lua function

Conditional Replacement

:%s/foo/\=submatch(0) == 'FOO' ? 'bar' : 'baz'/g

Replace ‘FOO’ with ‘bar’, other matches with ‘baz’.

Case-Aware Replacement

:%s/old/new/g        " Literal replacement
:%s/old/new/gi       " Case-insensitive search, literal replace

Smart case replacement (preserve original case):

:%s/\<old\>/new/gi   " Case-insensitive, but...

This doesn’t preserve case. For that, use a plugin or expression:

:%s/\c\<old\>/\=submatch(0) =~ '\u' ? 'New' : 'new'/g

This checks if match starts with uppercase, and adjusts replacement.

4.5 Global Command

The global command executes commands on lines matching a pattern.

Basic Syntax

:[range]g/{pattern}/{command}
:[range]g!/{pattern}/{command}    " Inverse (lines NOT matching)
:[range]v/{pattern}/{command}     " Same as g! (v = inverse)

Common Global Commands

:g/pattern/d         " Delete all lines matching pattern
:g!/pattern/d        " Delete lines NOT matching (keep matching)
:v/pattern/d         " Same as g! (keep matching lines)
:g/pattern/p         " Print matching lines
:g/pattern/m$        " Move matching lines to end
:g/pattern/t$        " Copy matching lines to end
:g/pattern/normal @a " Execute macro 'a' on matching lines

Examples:

:g/TODO/d            " Delete all TODO lines
:g/^$/d              " Delete empty lines
:g/^\s*$/d           " Delete blank lines (including whitespace-only)
:v/import/d          " Delete lines that don't contain 'import'
:g/debug/normal gcc  " Comment out lines with 'debug' (with commentary.vim)

Multiple Commands

:g/pattern/cmd1 | cmd2 | cmd3

Example:

:g/function/normal A {<CR><Esc>  " Append ' {' and newline to function declarations

Global with Ranges

:g/class/+1,/^}/d    " Delete content of all classes
:g/TODO/.+1d         " Delete line after each TODO
:g/START/,/END/s/foo/bar/g   " Replace in blocks between START and END

Example - Delete function bodies:

def func1():
    pass

def func2():
    pass

:g/^def/+1,/^$/d     " Delete from line after 'def' to next empty line

Inverse Global

:v/pattern/d         " Keep only matching lines (delete non-matching)
:v/^#/d              " Delete lines not starting with #
:g!/import/d         " Same as above (using g!)

Global with Substitute

:g/class/s/def/function/g    " In lines with 'class', replace 'def' with 'function'
:v/^#/.s/^/# /               " Comment non-comment lines

Collect Matching Lines

Copy to register:

qaq                  " Clear register a
:g/pattern/y A       " Append matching lines to register a

Copy to end of file:

:g/pattern/t$        " Copy matching lines to end

Move to new buffer:

:g/pattern/d A       " Delete matching lines, append to register a
:new                 " New buffer
"aP                  " Paste collected lines

Global Across Multiple Files

:args *.js           " Load all .js files
:argdo %s/var/let/ge | update   " Replace in all files and save

Or with buffers:

:bufdo %s/old/new/ge | w   " Replace in all buffers and save

Negated Patterns

:g!/import/d         " Delete lines without 'import'
:v/export/d          " Delete lines without 'export' (same as above)
:g!/^\s*#/d          " Delete lines that aren't comments

4.6 Advanced Search Techniques

Multi-line Search

/foo\_sbar           " Match 'foo' and 'bar' with any whitespace between (including newline)
/foo\_.bar           " Match 'foo' and 'bar' with any characters between (including newline)
/foo\(\n.*\)*bar     " Match 'foo' and 'bar' on different lines

Example:

Text:

def calculate(
    price,
    quantity
):

/def\_s*calculate\_s*\(    " Find function definition across lines

Search in Folds

vim.opt.foldopen:append('search')  -- Automatically open folds when searching

Or manually:

zn               " Disable folding temporarily
/pattern         " Search
zN               " Restore folding

Search in Visual Selection

\%V              " Inside visual selection atom

First visually select, then:

:'<,'>s/\%Vpattern/replacement/g   " Only in selection

Or use the visual selection range:

v                " Visual select
:'<,'>s/old/new/g   " Substitute only in selection

Search History Management

:history /       " Show search history
q/               " Open search history window (editable)
/<C-r>/          " Insert last search pattern
/<Up>            " Navigate search history

Clear search history:

:call histdel('search')     " Clear all search history
:call histdel('search', -1) " Remove last entry

Search with Very Magic

Always use very magic for complex patterns:

/\v(foo|bar)\d+  " Very magic: easier syntax

Configure default:

-- Make search use very magic by default
vim.keymap.set('n', '/', '/\\v', { desc = 'Search (very magic)' })
vim.keymap.set('n', '?', '?\\v', { desc = 'Backward search (very magic)' })

Now:

/(foo|bar)\d+    " No need for \v prefix

Search with Offset and Command

/pattern/+2      " Jump 2 lines below match
/pattern/e       " Jump to end of match

Combine with command:

/pattern/+1|d    " Find pattern, go 1 line down, delete it

4.7 Search and Replace Patterns Cookbook

Remove Trailing Whitespace

:%s/\s\+$//e     " Remove trailing whitespace from all lines

Remove All Empty Lines

:g/^$/d          " Using global command
:%s/\n\n/\r/g    " Or using substitute (collapse double newlines)

Remove Blank Lines (Including Whitespace)

:g/^\s*$/d       " Delete lines with only whitespace

Swap Two Words

:%s/\v(\w+)(\s+)(\w+)/\3\2\1/   " Swap word1 and word2

Add Line Numbers

:%s/^/\=line('.') . '. '/   " Prepend line number

Convert Tabs to Spaces

:%s/\t/    /g    " Replace tabs with 4 spaces

Or use retab:

:set expandtab
:retab           " Convert all tabs based on tabstop setting

Convert Spaces to Tabs

:set noexpandtab
:retab!          " Convert spaces to tabs

Remove Duplicate Lines

:sort u          " Sort and remove duplicates

Or without sorting:

:g/^\(.*\)$\n\1$/d   " Remove consecutive duplicates

Increment All Numbers

:%s/\d\+/\=submatch(0) + 1/g   " Increment all numbers by 1

Zero-Pad Numbers

:%s/\d\+/\=printf('%03d', submatch(0))/g   " Pad to 3 digits: 1 → 001

Extract URLs

:g/https\?:\/\//t$   " Copy all lines with URLs to end of file

Comment/Uncomment Lines

:g/pattern/s/^/# /        " Add # comment to matching lines
:g/pattern/s/^# //        " Remove # comment
:'<,'>s/^/# /             " Comment visual selection
:'<,'>s/^# //             " Uncomment visual selection

Convert CamelCase to snake_case

:%s/\v([a-z])([A-Z])/\1_\l\2/g   " camelCase → camel_case

Example:

myVariableName anotherExample

After: my_variable_name another_example

Convert snake_case to CamelCase

:%s/_\(\w\)/\u\1/g      " snake_case → snakeCase
:%s/\v_(.)/\u\1/g       " Same with very magic

Example:

my_variable_name another_example

After: myVariableName anotherExample

Extract Email Addresses

:g/\v\w+@\w+\.\w+/t$    " Copy lines with emails to end

Remove HTML Tags

:%s/<[^>]*>//g          " Remove all HTML tags
:%s/<\_.\{-}>//g        " Remove tags across lines (non-greedy)

Wrap Long Lines

:g/./ normal gqq        " Wrap all non-empty lines
:%normal gqq            " Wrap all lines

Or set textwidth:

vim.opt.textwidth = 80

Then:

gqG                     " Wrap from cursor to end

Add Semicolons to Lines

:g/^[^#]/s/$/;/         " Add ; to non-comment lines
:v/;$/normal A;         " Add ; to lines without it

Replace Smart Quotes

:%s/[""]/"/g            " Replace smart quotes with straight quotes
:%s/['']/'/g            " Replace smart single quotes

Convert Windows Line Endings to Unix

:%s/\r$//               " Remove carriage returns
:set ff=unix            " Set file format to Unix
:w                      " Save

Match Whole Words Only

:%s/\<word\>/replacement/g   " Match 'word' but not 'words' or 'password'

Case-Insensitive Whole Word Match

:%s/\c\<word\>/replacement/g   " Case-insensitive whole word

4.8 Working with Multiple Files

Search in Multiple Files (Vimgrep)

:vim /pattern/ **/*.js       " Search in all .js files recursively
:vim /pattern/ %             " Search in current file
:vim /pattern/ `find . -name '*.py'`  " Search in result of shell command

Navigate results:

:cn                          " Next match
:cp                          " Previous match
:copen                       " Open quickfix window
:cclose                      " Close quickfix window
:cfirst                      " First match
:clast                       " Last match

Quickfix list:

:clist                       " List all matches
:cc 5                        " Jump to 5th match

Search with External Tools

Using ripgrep:

:grep pattern **/*.js        " If grepprg is set to ripgrep
:grep! pattern **/*.js       " Don't jump to first match

Configuration:

if vim.fn.executable('rg') == 1 then
  vim.opt.grepprg = 'rg --vimgrep --smart-case --follow'
  vim.opt.grepformat = '%f:%l:%c:%m'
end

Replace in Multiple Files

:args **/*.js                " Load all .js files
:argdo %s/old/new/ge | update   " Replace and save each

Explanation:

• args **/*.js - Load files into argument list

• argdo - Execute command on each file in args

• %s/old/new/ge - Substitute (e flag: no error if not found)

• | - Command separator

• update - Save only if modified

With confirmation:

:argdo %s/old/new/gce | update   " Confirm each replacement

Search and Replace with Quickfix

:vim /old/ **/*.js           " Find all occurrences
:cdo s/old/new/gc | update   " Replace in each file (with confirmation)

Difference between cdo and cfdo:

• cdo - Execute on each quickfix entry

• cfdo - Execute once per file in quickfix

:cfdo %s/old/new/ge | update  " Replace in each file (once per file)

Populate Quickfix from Search

:vimgrep /{pattern}/ %       " Search in current file, populate quickfix

Or use location list:

:lvim /pattern/ %            " Search, populate location list
:lopen                       " Open location list

4.9 Search and Replace Best Practices

1. Test Patterns First

Before replacing:

/pattern             " Test your pattern
:%s/pattern/replacement/gn   " Count matches without replacing

2. Use Confirmation for Important Changes

:%s/old/new/gc       " Confirm each change

3. Save Before Mass Replace

:w                   " Save first
:%s/old/new/g        " Replace
u                    " Undo if needed

Or use undo branches:

:%s/old/new/g
:earlier 1f          " Go back to before last file write

4. Use Very Magic for Complex Patterns

/\v(foo|bar)\d+      " Clearer than /\(foo\|bar\)\d\+

5. Capture Groups for Rearranging

:%s/\v(\w+) (\w+)/\2, \1/   " Swap words

6. Check Range Before Substituting

:5,10s/old/new/g     " Only lines 5-10
:'<,'>s/old/new/g    " Visual selection

7. Use Global Command for Line Operations

:g/pattern/d         " Delete matching lines
:g/pattern/normal @a " Execute macro on matches

8. Preserve Original in Register

let @a = @/          " Save search pattern to register a
:%s/old/new/g
let @/ = @a          " Restore search pattern

9. Use :help pattern for Reference

:help pattern        " Complete regex reference
:help sub-replace-expression  " Expression replacement
:help :substitute    " Substitute command details

10. Combine Search with Marks

/pattern<CR>         " Find pattern
ma                   " Mark position
# Navigate elsewhere
`a                   " Return to mark

4.10 Search Integration with Plugins

Telescope (Fuzzy Finder)

require('telescope.builtin').live_grep()      -- Search in files
require('telescope.builtin').grep_string()    -- Search word under cursor
require('telescope.builtin').search_history() -- Search history

Keymaps:

vim.keymap.set('n', '<leader>fg', ':Telescope live_grep<CR>', 
  { desc = 'Live grep' })
vim.keymap.set('n', '<leader>fw', ':Telescope grep_string<CR>',
  { desc = 'Grep word under cursor' })
vim.keymap.set('n', '<leader>fo', ':Telescope oldfiles<CR>',
  { desc = 'Recent files' })

Hop / Flash (Quick Navigation)

require('hop').hint_patterns({ current_line_only = true })  -- Search on line
require('hop').hint_patterns()                               -- Search in buffer

Keymaps:

vim.keymap.set('n', 's', ':HopPattern<CR>', { desc = 'Hop to pattern' })
vim.keymap.set('n', 'S', ':HopChar2<CR>', { desc = 'Hop to 2 chars' })

nvim-hlslens (Enhanced Search)

Shows search count and positions in virtual text:

require('hlslens').setup({
  calm_down = true,
  nearest_only = true,
})

vim.keymap.set('n', 'n', [[<Cmd>execute('normal! ' . v:count1 . 'n')<CR><Cmd>lua require('hlslens').start()<CR>]])
vim.keymap.set('n', 'N', [[<Cmd>execute('normal! ' . v:count1 . 'N')<CR><Cmd>lua require('hlslens').start()<CR>]])

Searchbox.nvim (Better Search UI)

require('searchbox').setup({
  popup = {
    border = { style = 'rounded' },
  },
})

vim.keymap.set('n', '/', ':SearchBoxIncSearch<CR>', { desc = 'Incremental search' })
vim.keymap.set('n', '?', ':SearchBoxIncSearch reverse=true<CR>', { desc = 'Reverse search' })

4.11 Practical Search and Replace Scenarios

Scenario 1: Refactoring Function Names

Task: Rename calculateTotal to computeTotal across multiple files.

:args **/*.js                              " Load all JS files
:argdo %s/\<calculateTotal\>/computeTotal/ge | update

Scenario 2: Update Import Paths

Task: Change import from '../utils' to import from '@/utils'.

:args src/**/*.js
:argdo %s/from ['"]\.\.\/utils['"]/from '@\/utils'/ge | update

Scenario 3: Add Type Annotations

Task: Add TypeScript type to function parameters.

Before:

function process(data) {

After:

function process(data: any) {

Command:

:%s/\vfunction (\w+)\((\w+)\)/function \1(\2: any)/g

Scenario 4: Format JSON

Task: Pretty-print JSON data.

:%!python -m json.tool     " Use external formatter

Or with jq:

:%!jq .                    " Format with jq

Scenario 5: Extract Configuration Values

Task: Find all hardcoded API URLs.

:vimgrep /https:\/\/api\./ **/*.js
:copen                     " Open quickfix to review all

Scenario 6: Batch Comment

Task: Comment out all console.log statements.

:g/console\.log/s/^/\/\/ /    " Add // comment

Or with visual block:

/console\.log<CR>         " Find first
<C-v>                      " Block mode
# Select multiple lines
I// <Esc>                 " Comment

Scenario 7: Clean Up Logs

Task: Remove all debug print statements.

:g/print.*debug/d          " Delete debug prints
:g/console\.debug/d        " Delete console.debug

Scenario 8: Normalize Whitespace

Task: Ensure consistent spacing around operators.

:%s/\s*=\s*/ = /g          " Space around =
:%s/\s*+\s*/ + /g          " Space around +
:%s/\s*,\s*/, /g           " Space after comma

Scenario 9: Extract TODO Comments

Task: Collect all TODO comments to end of file.

:g/TODO/t$                 " Copy to end

Or to a new buffer:

qaq                        " Clear register a
:g/TODO/y A                " Append to register a
:new                       " New buffer
"aP                        " Paste

Scenario 10: Version Number Update

Task: Increment version numbers.

Before:

"version": "1.2.3"

After:

"version": "1.2.4"

Command:

:g/version/s/\d\+$/\=submatch(0) + 1/

4.12 Search and Replace Exercises

Exercise 1: Basic Pattern Matching

Text: Contact: john@example.com Email: jane@test.org Reach us: support@company.net

Task: Extract all email addresses.

Solution:

:g/\v\w+@\w+\.\w+/t$

Exercise 2: Swap Date Format

Text: 2024-10-19 2024-11-25 2024-12-31

Task: Convert to DD/MM/YYYY.

Solution:

:%s/\v(\d{4})-(\d{2})-(\d{2})/\3\/\2\/\1/

Exercise 3: Remove Code Comments

Text:

x = 10  # This is a comment
y = 20  # Another comment
z = x + y

Task: Remove inline comments.

Solution:

:%s/\s*#.*$//

Exercise 4: Capitalize First Letter

Text: hello world welcome to vim happy coding

Task: Capitalize first letter of each line.

Solution:

:%s/\v^(\w)/\u\1/

Exercise 5: Create Numbered List

Text: apple banana cherry date

Task: Convert to numbered list.

Solution:

:%s/^/\=line('.') . '. '/

Result:

1. apple

2. banana

3. cherry

4. date

Exercise 6: Complex Refactoring

Text:

var name = "John";
var age = 30;
var city = "NYC";

Task: Convert var to const and add type annotations.

Solution:

:%s/\vvar (\w+) = (.+);/const \1: string = \2;/

For numbers, you’d need multiple passes or more complex pattern.

Chapter Summary

In this chapter, you mastered:

• Search fundamentals: /, ?, *, #, n, N, search offsets

• Regular expressions: Magic modes, character classes, quantifiers, anchors

• Advanced regex: Grouping, backreferences, lookahead/lookbehind, \zs, \ze

• Search configuration: Case sensitivity, highlighting, incremental search

• Substitute command: Full syntax, ranges, flags, special replacements

• Captured groups: Using \1, \2 for rearranging text

• Expression replacement: \= for calculations and transformations

• Global command: :g, :v for line-based operations

• Multi-line search: \_s, \_. for patterns across lines

• Search history: q/, command history, clearing highlights

• Very magic mode: \v for cleaner complex patterns

• Pattern cookbook: Common search/replace patterns for real tasks

• Multiple files: vimgrep, grep, args, argdo, cdo, cfdo

• Quickfix integration: Navigate search results across files

• Best practices: Testing patterns, using confirmation, saving state

• Plugin integration: Telescope, Hop, hlslens for enhanced search

• Real-world scenarios: Refactoring, formatting, extracting data