Search and Replace

Searching is one of the fastest ways to navigate and edit files. Vim's search features go far beyond a simple "Find and Replace" dialog — you can search with patterns, replace text across an entire file in one command, and run commands on every matching line.

Basic Searching

Searching Forward

To search for text in Vim, press / (forward slash) from Normal mode, type what you're looking for, and press Enter:

/hello        " Search forward for the text "hello"

Here's what happens step by step:

1. Press / — a cursor appears at the bottom of the screen
2. Type the text you want to find (e.g., hello)
3. Press Enter — your cursor jumps to the first match
4. If there are multiple matches, keep reading to learn how to cycle through them

Searching Backward

Use ? instead of / to search backward (toward the beginning of the file):

?hello        " Search backward for "hello"

Moving Between Matches

After you've searched for something, use these keys to jump between matches:

So if you searched forward with /hello:

• n moves forward to the next "hello"
• N moves backward to the previous "hello"

If you searched backward with ?hello:

• n moves backward (the direction of your search)
• N moves forward

Search Settings (Make Searching Easier)

Add these settings to your ~/.vimrc file to make searching much more pleasant. If you followed the installation tutorial, you may already have some of these:

set incsearch      " Show matches as you type (don't wait for Enter)
set hlsearch       " Highlight ALL matches in the file
set ignorecase     " Searches are case-insensitive by default
set smartcase       " ...BUT become case-sensitive if you type a capital letter

What do these do?

• incsearch (incremental search): As you type /hel, Vim immediately jumps to the first match for "hel" — you don't have to press Enter first. This lets you see results live as you type.
• hlsearch (highlight search): Every match in the file gets highlighted in yellow (or your theme's highlight color). Very helpful for seeing how many matches exist.
• ignorecase: Searching for /hello will match "hello", "Hello", "HELLO", etc.
• smartcase: If you search for /hello (all lowercase), it matches everything. But if you search for /Hello (with a capital), it only matches "Hello" exactly. This gives you the best of both worlds.

nnoremap <leader>h :nohlsearch<CR>

Search and Replace (The Substitute Command)

The substitute command is Vim's equivalent of "Find and Replace." It uses this format:

:s/old/new/

Let's break that down:

• : — enters Command-line mode
• s — the substitute command
• /old/ — the text you want to find (the "search pattern")
• /new/ — the text you want to replace it with

Replace One Occurrence on the Current Line

:s/hello/world/

This finds the first occurrence of "hello" on the current line and replaces it with "world." It only changes one match on one line.

Replace ALL Occurrences on the Current Line

Add the g flag (which stands for global — meaning "all matches"):

:s/hello/world/g

Now it replaces every "hello" on the current line, not just the first one.

Replace in the Entire File

Add % before the s to apply the command to every line in the file:

:%s/hello/world/g

This is the most common form. It means: "On every line (%) in the file, substitute (s) every occurrence (g) of hello with world."

Ask for Confirmation Before Each Replace

Add the c flag to get a confirmation prompt for each match:

:%s/hello/world/gc

For each match, Vim will ask: replace with world (y/n/a/q/l/^E/^Y)?

Case-Insensitive Replace

Add the i flag or use \c in yor pattern:

:%s/hello/world/gi      " The 'i' flag makes it case-insensitive
:%s/\chello/world/g     " \c in the pattern does the same thing

Both of these will match "hello", "Hello", "HELLO", etc.

Substitute Command Cheat Sheet

Here's a summary of all the forms:

Replacing on Specific Lines

You can specify exactly which lines to search:

:5,10s/old/new/g       " Only on lines 5 through 10
:.,+5s/old/new/g       " From the current line (.) to 5 lines below
:.,$ s/old/new/g       " From the current line to the end of the file

What do the symbols mean?

• . means "the current line" (where your cursor is)
• $ means "the last line in the file"
• +5 means "5 lines after"
• 5,10 means "lines 5 through 10"

Special Characters in Replacements

Some characters have special meaning in the replacement part of the substitute command:

Example — changing case:

:%s/hello/\U&/g        " Replace "hello" with "HELLO" (\U makes it uppercase, & is the match)
:%s/HELLO/\L&/g        " Replace "HELLO" with "hello" (\L makes it lowercase)

Simple Patterns (Regular Expressions)

Sometimes you need to search for a pattern rather than exact text. For example, "find any number" or "find any word that starts with get."

Vim supports regular expressions (often called "regex") — a way to describe text patterns. Here are the most useful basics:

Practical Search Pattern Examples

/\d\+                   " Find any number (one or more digits)
/\<function\>           " Find the exact word "function" (not "dysfunction")
/^import                " Find lines that start with "import"
/;$                     " Find lines that end with a semicolon
/TODO\|FIXME\|HACK      " Find any of these words (\| means "or")

Practical Replace Pattern Examples

" Remove trailing whitespace from every line
:%s/\s\+$//g
 
" Add a semicolon to lines that don't already end with one
:%s/[^;]$/&;/g
 
" Convert snake_case to camelCase (basic version)
:%s/_\(\w\)/\u\1/g

Let's break down that last one:

• _\(\w\) — finds an underscore followed by a word character and captures that character in \(\).
• \u\1 — replaces with that captured character, but in uppercase (\u).
• So my_variable becomes myVariable.

The Global Command

The :global command (:g) lets you run a command on every line that matches a pattern. It's extremely powerful:

:g/pattern/command

This means: "Find every line matching pattern, and run command on each of those lines."

Common Uses

:g/TODO/p               " Print all lines containing "TODO"
:g/^$/d                 " Delete all blank lines (^$ matches empty lines)
:g/console.log/d        " Delete all lines with "console.log"
:g/^#/d                 " Delete all comment lines (starting with #)
:g!/pattern/d           " Delete all lines that do NOT match the pattern

Moving Matching Lines

You can also move or copy matching lines:

:g/TODO/m$              " Move all TODO lines to the end of the file
:g/TODO/t0              " Copy (t = transcript) all TODO lines to the top
:g/function/yank A      " Yank all lines with "function" into register a

Searching Across Multiple Files

To search for text across multiple files, you can use Vim's :vimgrep command:

:vimgrep /pattern/ **/*.js      " Search all .js files recursively
:copen                           " Open the results list

This opens a "quickfix list" — a window showing all matches. You can:

• Press Enter on a line to jump to that match
• Type :cnext (or :cn) to go to the next match
• Type :cprev (or :cp) to go to the previous match

Summary

Here's what you've learned:

• Search forward with /pattern, backward with ?pattern
• Navigate matches with n (next) and N (previous)
• * searches for the word under the cursor
• Substitute (find & replace): :%s/old/new/g for the whole file
• Add c flag for confirmation: :%s/old/new/gc
• Range substitution: :5,10s/old/new/g for specific lines
• Special characters: . (any char), * (zero or more), ^ (line start), $ (line end)
• Word boundaries: \<word\> matches whole words only
• Global command: :g/pattern/command runs a command on all matching lines
• :g/^$/d deletes blank lines, :g/pattern/d deletes matching lines
• Set incsearch, hlsearch, ignorecase, smartcase in your vimrc for better searching

vim search-practice.txt

Hello World
hello world
HELLO WORLD
The function getData gets data from the server.
The function getUser gets user info.
TODO: fix this bug
TODO: add error handling
This line has   extra   spaces   in it.
var count = 0;
var name = "John";
var age = 25;

" 1. Search for "hello"
/hello
" With ignorecase: matches on lines 1 (Hello), 2 (hello), and 3 (HELLO) = 3 matches
" Without ignorecase: matches only line 2 (hello) = 1 match
" Press n to go to next match, N for previous
 
" 2. Search and cycle through matches
/function
" Cursor jumps to first "function" on line 4
n         " Jumps to "function" on line 5
N         " Jumps back to line 4
 
" 3. Replace TODO with DONE globally
:%s/TODO/DONE/g
" Both TODO lines now say DONE
 
" 4. Replace var with let on specific lines
:9,11s/var/let/g
" Lines 9-11 now start with "let" instead of "var"
 
" 5. Delete blank lines
:g/^$/d
" All empty/blank lines are removed
 
" 6. Remove extra spaces
:%s/ \+/ /g
" "extra   spaces" becomes "extra spaces"
 
" 7. Find lines starting with "The"
/^The
" Cursor jumps to the first line starting with "The"
n        " Jumps to the next such line
 
" 8. Delete lines containing DONE
:g/DONE/d
" The two "DONE:" lines are gone
 
:q!      " Quit without saving when done