Vim Search & Quickfix

/pattern                                 " Search forward

?pattern                                 " Search backward

n                                        " Next match (same direction)
N                                        " Previous match (opposite direction)

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

/pattern\c                               " Case insensitive
/pattern\C                               " Case sensitive
:set ignorecase                          " Always ignore case
:set smartcase                           " Ignore case unless uppercase used

:set hlsearch                            " Highlight matches
:nohlsearch                              " Clear highlight (temporary)
:noh                                     " Short form

:set incsearch                           " Show matches as you type

/<Up>                                    " Previous search
/<Down>                                  " Next search
q/                                       " Open search history window

//                                       " Repeat last search
??                                       " Repeat last backward search

/^pattern                                " Start of line
/pattern$                                " End of line
/^pattern$                               " Exact line

/\<word\>                                " Exact word
/\<word                                  " Word start
/word\>                                  " Word end

/\d                                      " Digit [0-9]
/\D                                      " Non-digit
/\w                                      " Word char [a-zA-Z0-9_]
/\W                                      " Non-word char
/\s                                      " Whitespace
/\S                                      " Non-whitespace
/\a                                      " Alphabetic [a-zA-Z]
/\l                                      " Lowercase [a-z]
/\u                                      " Uppercase [A-Z]
/\x                                      " Hex digit [0-9A-Fa-f]

/[aeiou]                                 " Any vowel
/[^aeiou]                                " Not a vowel
/[0-9]                                   " Any digit
/[a-zA-Z]                                " Any letter

/x*                                      " Zero or more x
/x\+                                     " One or more x
/x\?                                     " Zero or one x
/x\{3}                                   " Exactly 3 x
/x\{3,5}                                 " 3 to 5 x
/x\{3,}                                  " 3 or more x
/x\{,5}                                  " Up to 5 x

/x\{-}                                   " Non-greedy (as few as possible)
/.\{-}pattern                            " Match shortest to pattern

/\(pattern\)                             " Group (for backreference)
/\%(pattern\)                            " Non-capturing group

/cat\|dog                                " cat or dog
/\(cat\|dog\)s                           " cats or dogs

/\(word\).*\1                            " word appears twice
/\(\w\+\)\s\+\1                          " Repeated word

/\v                                      " Very magic (regex-like)
/\V                                      " Very nomagic (literal)
/\m                                      " Magic (default)
/\M                                      " Nomagic

/\v(cat|dog)s?                           " No escaping needed
/\(cat\|dog\)s\?                         " Normal magic (escaped)

/.                                       " Any single character
/\_s                                     " Whitespace including newline
/\_.                                     " Any character including newline

/\%3l                                    " Match on line 3
/\%5c                                    " Match at column 5
/\%>10l\%<20l                            " Lines 11-19

/\%V                                     " Inside visual selection
/\%Vpattern\%V                           " Pattern in visual area

/\d\{1,3}\.\d\{1,3}\.\d\{1,3}\.\d\{1,3}

/\w\+@\w\+\.\w\+

/https\?:\/\/\S\+

/\s\+$

/^$

/^\s*$

/\v<(\w+)\s+\1>

:g/pattern/command                       " Run command on matching lines
:v/pattern/command                       " Run on non-matching lines

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

:g/pattern/p                             " Print matching lines
:g/pattern/#                             " Print with line numbers

/pattern/+2                              " 2 lines below match
/pattern/-1                              " 1 line above match
/pattern/e                               " End of match
/pattern/b+3                             " 3 chars from start of match

:copen                                   " Open quickfix window
:cclose                                  " Close quickfix window
:cwindow                                 " Open if errors, close if none

:cnext                                   " Next error
:cprev                                   " Previous error
:cfirst                                  " First error
:clast                                   " Last error
:cc 5                                    " Go to error 5

]q                                       " Next quickfix (with vim-unimpaired)
[q                                       " Previous quickfix

:vimgrep /pattern/ **/*.adoc             " Search all adoc files
:vimgrep /pattern/g %                    " Search current file (all matches)
:vimgrep /pattern/j **/*.adoc            " Don't jump to first match

:grep pattern **/*.adoc                  " Use external grep
:grep -r pattern .                       " Recursive grep

:set grepprg=rg\ --vimgrep               " Use ripgrep
:set grepprg=ag\ --vimgrep               " Use silver searcher

:make                                    " Run make, populate quickfix
:make test                               " Run make test

:compiler python                         " Set compiler for python
:compiler gcc                            " Set compiler for gcc

:lopen                                   " Open location list
:lclose                                  " Close location list
:lnext                                   " Next location
:lprev                                   " Previous location
:lfirst                                  " First location
:llast                                   " Last location

:lvimgrep /pattern/ **/*.adoc            " Populate location list
:lgrep pattern **/*.adoc                 " External grep to location list

:colder                                  " Older quickfix list
:cnewer                                  " Newer quickfix list
:chi                                     " Show quickfix history

:Cfilter /pattern/                       " Keep matching (needs plugin or custom)
:packadd cfilter                         " Load cfilter plugin (Vim 8.1+)
:Cfilter /error/                         " Keep only errors
:Cfilter! /warning/                      " Remove warnings

:cdo s/old/new/g                         " Substitute in each file
:cdo update                              " Save each file
:cfdo %s/old/new/g | update              " Per-file substitute and save

:ldo s/old/new/g                         " Substitute in each location
:lfdo %s/old/new/g | update              " Per-file

:cbuffer                                 " Read errors from current buffer
:cgetbuffer                              " Same, don't jump
:caddexpr "file.txt:10:error message"    " Add single entry

:cfile errors.txt                        " Read errors from file
:cgetfile errors.txt                     " Same, don't jump

:cexpr system('grep -rn pattern .')      " From command output

:grep -r TODO . | copen

:vimgrep /oldpattern/ **/*.py
:cfdo %s/oldpattern/newpattern/gc | update

:make
:copen
:cnext                                   " Fix each error

nnoremap <leader>co :copen<CR>
nnoremap <leader>cc :cclose<CR>
nnoremap ]q :cnext<CR>
nnoremap [q :cprev<CR>
nnoremap ]Q :clast<CR>
nnoremap [Q :cfirst<CR>