Начало работы
Режимы и базовое движение
Vim модальный: разные режимы служат разным целям. Esc возвращает в Normal mode из любого другого режима. Клавиши hjkl держат руки на домашнем ряду. w/b двигаются по словам, 0/$ — к границам строки, gg/G прыгают к началу и концу файла, :N переходит к строке N.
# Vim Modes
# Normal mode (Esc) - default, for navigation
# Insert mode (i) - for typing text
# Visual mode (v) - for selecting text
# Command mode (:) - for Ex commands
# Basic movement (Normal mode)
h # left
j # down
k # up
l # right
w # next word start
b # previous word start
0 # beginning of line
$ # end of line
gg # first line
G # last line
:42 # go to line 42Выход и сохранение
ZZ и ZQ — самые быстрые способы выйти: не нужно тянуться к двоеточию. :x записывает, только есл и файл изменился (сохраняет mtime), в отличие от :wq, который пишет всегда. :w! обходит флаг read-only, если позволяют права файловой системы. Используйте :qa!, чтобы выйти из нескольких изменённых буферов.
:w # write (save) file
:w! # force write (override read-only)
:q # quit
:q! # force quit (discard changes)
:wq # write and quit
:x # write only if changed, then quit
ZZ # same as :x (write if changed, quit)
ZQ # quit without saving (like :q!)
:w newfile.txt # save as new file
:sav newfile.txt # save as new file and switch to it
:wa # write all buffers
:xa # write all changed buffers and exit
:qa! # force quit all (discard everything)Система справки
Справка Vim исчерпывающая и гиперссылочная. Ctrl-] переходит по тегу (ссылке), Ctrl-T возвращается назад. Обозначения в справке: i_CTRL-N означает Ctrl-N в режиме вставки, 'number' (в кавычках) означает опцию. :helpgrep ищет по всем файлам справки сразу — используйте :cn/:cp для навигации по совпадениям. K вызывает man для слова под курсором (настраивается через 'keywordprg').
:help # main help
:help subject # help on subject (e.g. :help insert)
:help i_CTRL-N # help on Ctrl-N in insert mode
:help 'number' # help on the 'number' option (quotes)
:helpgrep pattern # search all help files for pattern
:cn / :cp # next/prev helpgrep match
K # man page for word under cursor (Normal mode)
Ctrl-] # jump to tag under cursor (follow link)
Ctrl-T # jump back from tag (pop tag stack)
:helptags ~/.vim/doc # regenerate help tags for a doc directoryДвижение по словам и символам
Строчные движения (w/b/e) считают пунктуацию разделителями слов — полезно для кода. Заглавные (W/B/E) считают разделителем только пробелы — полезно для прозы. e/E переходят к концу следующего слова; ge/gE — к концу предыдущего (редко, но удобно).
# Word motions (punctuation-aware)
w # next word start
b # previous word start
e # end of next word
ge # end of previous word
# WORD motions (whitespace-only delimiters, uppercase)
W # next WORD start
B # previous WORD start
E # end of next WORD
gE # end of previous WORD
# Word boundaries:
# word: sequence of word-characters OR sequence of punctuation
# WORD: anything separated by whitespace
# Examples (cursor on 'a' in "foo.bar baz"):
# w -> 'bar' (punctuation splits words)
# W -> 'baz' (only whitespace splits WORDS)Движение по строке
0 и $ идут к абсолютному началу и концу строки (включая пробелы). ^ и g_ пропускают ведущие и хвостовые пробелы — обычно это и нужно. Когда включён 'wrap', g0/g$ работают с экранными строками, а 0/$ — с логическими. | переходит к конкретному номеру колонки.
0 # first column (absolute start)
^ # first non-blank character
$ # end of line (last character)
g_ # last non-blank character
g0 # start of screen line (with wrap)
g$ # end of screen line (with wrap)
gm # middle of screen line
gM # middle of text line
| # column N (e.g. 10| = column 10)
+ # first non-blank of next line
- # first non-blank of previous line
_ # first non-blank of current line [count down]Движение по файлу и экрану
H/M/L прыгают в пределах видимого экрана. Ctrl-d/u прокручивают полстраницы (меньше дезориентирует, чем целая страница Ctrl-f/b). zz/zt/zb прокручивают текущую строку в середину, верх или низ экрана, не двигая курсор, — крайне полезно, чтобы держать контекст при редактировании. N% переходит к проценту файла.
gg # go to first line
G # go to last line
Ngg / NG # go to line N (e.g. 50gg or 50G)
:N # go to line N (Ex command)
H # top of screen (High)
M # middle of screen
L # bottom of screen (Low)
N% # jump to N% of the file
Ctrl-f # scroll forward (full page)
Ctrl-b # scroll backward (full page)
Ctrl-d # scroll down (half page)
Ctrl-u # scroll up (half page)
zz # scroll current line to middle
zt # scroll current line to top
zb # scroll current line to bottomВставка текста
Базовая вставка (i, I)
i/I вставляют перед курсором или в начале строки. a/A вставляют после курсора или в конце строки. gi возвращает к последней позиции вставки (метка '^) — удобно, когда вышли из insert, чтобы что-то сделать, а потом хочется продолжить печатать. gI идёт к абсолютной колонке 1, игнорируя ведущие пробелы.
i # insert before cursor
I # insert at first non-blank (same as ^i)
gi # insert at last insert position (also sets mark)
gI # insert at column 1 (same as 0i)
a # insert after cursor
A # insert at end of line (same as $a)
# Examples:
# foo|bar + i -> foo|bar (cursor stays, type before)
# foo|bar + I -> |foobar (cursor at first non-blank)
# foo|bar + A -> foobar| (cursor at end)
# gi returns to where you last left insert mode —
# very useful after escaping to run a Normal-mode command.Новые строки (o, O)
o и O открывают новую строку ниже или выше курсора и входят в режим вставки. Это самый быстрый способ добавить строку — не нужно ставить курсор в конец строки. Отступ автоматически копируется у окружающих строк (управляется 'autoindent').
o # open new line BELOW cursor, enter insert
O # open new line ABOVE cursor, enter insert
# Before (cursor on middle line):
# line one
# li|ne two
# line three
# After 'o':
# line one
# line two
# | <- new blank line, insert mode
# line three
# After 'O':
# line one
# | <- new blank line, insert mode
# line two
# line threeКоманды изменения (c, C, s, S)
c{motion} удаляет цель движения и входит в режим вставки — самая гибкая команда редактирования. C это c$ (изменить до конца строки), S это cc (изменить всю строку). s удаляет один символ и входит в insert; комбинируйте со счётчиками вроде 3s. ciw/caw используют текстовые объекты (см. отдельный раздел).
cw / ce # change to end of word
cb # change backward to word start
c$ / C # change to end of line
cc / S # change entire line
c0 # change to beginning of line
c^ # change to first non-blank
ct, # change up to (but not including) next ','
cfx # change up to and including next 'x'
ciw # change inner word (no surrounding whitespace)
caw # change a word (with surrounding whitespace)
cap # change around paragraph
s # substitute: delete char under cursor, insert
S # substitute: delete entire line, insert (like cc)Режим замены (r, R, gr)
r заменяет один символ и сразу возвращается в Normal mode (без смены режима). R входит в Replace mode, где ввод перезаписывает символы, — Backspace их восстанавливает, в отличие от Insert mode, который просто удаляет. Используйте gr/gR (виртуальная замена) при работе с табами: она сохраняет выравнивание табов, а не сдвигает текст.
r{x} # replace single char under cursor with x
gr{x} # virtual replace (doesn't shift tabs)
R # enter Replace mode (overwrite until Esc)
gR # virtual Replace mode (tabs stay aligned)
3r{x} # replace 3 chars with x (single char only)
# In Replace mode, typing overwrites existing text
# but Backspace restores the original characters.
# Tabs are preserved with virtual replace (gr/gR).
# Examples:
# abc|def + rx -> abc|xef (cursor advances)
# abc|def + R -> enter Replace mode
# type 'XYZ' -> abcXYZ|f
# Backspace -> abcXY|def (original restored)Особые вставки
:r !cmd вставляет вывод shell-команды в буфер — отлично для вставки вывода команд, дат, списков файлов. В режиме вставки Ctrl-r и имя регистра вставляют этот регистр; Ctrl-r = вычисляет выражение Vimscript и вставляет результат. Ctrl-k вставляет диграф (спецсимвол), если набрать два ASCII-символа.
:r file.txt # insert contents of file below cursor
:r !command # insert output of shell command
:0r !date # insert date at top of file
:r !ls -la # insert directory listing
# Insert with special registers
Ctrl-r = # expression register: evaluate, insert result
Ctrl-r " # insert unnamed register
Ctrl-r % # insert current filename
# Insert from current file path
:i! !pwd # insert pwd output (no autoindent)
# Non-ASCII / digraphs (in insert mode)
Ctrl-k {ch1}{ch2} # digraph: e.g. Ctrl-k e' produces é
:digraphs # list available digraphsСокращения в режиме вставки
Ctrl-h/w/u работают как Backspace, удалить слово и удалить строку внутри режима вставки. Ctrl-t/Ctrl-d меняют отступ, не выходя из режима вставки, — бесценно для кода. Ctrl-n/Ctrl-p делают дополнение по ключевым словам из буферов и тегов. Ctrl-o выполняет одну Normal-команду и возвращает в insert (например, Ctrl-o zz для центрирования). Ctrl-g u разрывает цепочку undo, чтобы длинную вставку можно было отменять частями.
# In insert mode:
Ctrl-h # delete char before cursor (Backspace)
Ctrl-w # delete word before cursor
Ctrl-u # delete to start of line
Ctrl-t # indent current line (one shiftwidth)
Ctrl-d # dedent current line (one shiftwidth)
Ctrl-n # keyword completion (forward)
Ctrl-p # keyword completion (backward)
Ctrl-o # execute one Normal command, return to insert
Ctrl-r {reg} # insert register contents
Ctrl-a # insert text typed in last insert mode
Ctrl-@ # insert last text + Esc (like Ctrl-a then Esc)
Ctrl-g u # break undo sequence (start new undo block)
Ctrl-] # trigger abbreviation without insertingКоманды редактирования (delete/yank/paste)
Команды удаления
d{motion} — универсальный оператор удаления, комбинируется с любым движением. dd удаляет всю строку. x — сокращение для dl (удалить символ). Удалённый текст попадает в безымянный регистр (и регистр 1). Используйте d с текстовыми объектами (ciw, dib) для мощных правок. J присоединяет следующую строку к текущей через один пробел.
x # delete char under cursor (also 'dl')
X # delete char before cursor (also 'dh')
dd # delete current line
dw # delete to next word start
de # delete to end of word
d$ / D # delete to end of line
d0 # delete to beginning of line
d^ # delete to first non-blank
dgg # delete from cursor to first line
dG # delete from cursor to last line
J # join next line (removes leading whitespace, inserts space)
gJ # join next line without inserting space
3dd # delete 3 lines
dW # delete WORD (whitespace-separated)Yank (копирование)
y{motion} копирует текст без удаления. yy копирует строку. В отличие от d (у которого есть x как сокращение), у y нет односимвольного сокращения — нужно движение. Yank всегда обновляет регистр 0, что помогает отличать его от удалений. Используйте те кстовые объекты: ya( копирует вместе со скобками, yi" копирует внутри кавычек.
y # yank {motion} (no character shortcut)
yy / Y # yank current line
yw # yank to next word start
ye # yank to end of word
y$ # yank to end of line
y0 # yank to beginning of line
yG # yank to end of file
ygg # yank to beginning of file
5yy # yank 5 lines
ya( # yank around parentheses
yi" # yank inside double quotes
yt, # yank up to (not including) next comma
# Yanked text goes to:
# " (unnamed register)
# 0 (yank register, only updated by y)Put (вставка)
p вставляет после курсора (или под строкой для строчных данных); P вставляет перед. gp/gP ставят курсор в конец вставленного текста — удобно при цепочке операций. ]p/[p переотступают вставленные строки под окружение. Регистр буфера обмена (+) связан с системным буфером, если 'clipboard' настроен правильно.
p # paste after cursor (linewise: line below)
P # paste before cursor (linewise: line above)
gp # paste after, leave cursor on last pasted char
gP # paste before, leave cursor on last pasted char
]p # paste after, reindent to match
[p # paste before, reindent to match
"+p # paste from system clipboard
"*p # paste from primary selection (X11)
# Linewise vs charwise:
# yy + p -> pasted as a new line below
# y$ + p -> pasted after cursor on same line
# Counts: 3p pastes the register 3 times.Смена регистра
~ переключает регистр одного символа и сдвигает курсор. g~/gu/gU — операторы, работающие с движениями или текстовыми объектами. В визуальном режиме U/u/~ действуют на выделение. gUiw делает текущее слово заглавными, gUU — всю строку. Эти операции недеструктивны — меняется только регистр.
~ # toggle case of char under cursor (advances)
3~ # toggle case of next 3 chars
g~{motion} # toggle case of motion
gu{motion} # lowercase motion
gU{motion} # uppercase motion
g~~ # toggle case of current line
guu # lowercase current line
gUU # uppercase current line
g~~gg # toggle case to first line
# Visual mode:
# U # uppercase selection
# u # lowercase selection
# ~ # toggle case of selection
# Examples:
# hello + gUw -> HELLO
# HELLO + guw -> hello
# hello + g~w -> HELLOОбъединение и разбиение строк
J объединяет строки через один пробел; gJ объединяет без вставки. :join работает по диапазону. gq — оператор форматирования: переносит строки по 'textwidth' (обычно 80), соблюдая 'formatoptions'. gqip переформатирует абзац, gqq — одну строку. Установите 'textwidth=80', чтобы включить автоперенос.
J # join next line with current (inserts space)
gJ # join next line without inserting space
3J # join next 3 lines into one
:[range]join # join lines in range (also :j)
:[range]join! # join without inserting space
# Splitting a line:
# In insert mode, press Enter (autoindent applies)
# In normal mode: r<Enter> replaces char with newline
# Break a long line at column 80 (with 'textwidth'):
gq{motion} # format motion text to 'textwidth'
gqq # format current line
gqip # format paragraph
gvgq # format visual selection
# Set text width:
:set textwidth=80Повтор и отмена
. повторяет последнее изменение — самая полезная клавиша в Vim. u/Ctrl-r — undo/redo. U отменяет все изменения в текущей строке. :earlier/:later позволяют путешествовать по времени или счётчику, даже по веткам (Vim хранит дерево undo). :undolist показывает ветки. @: повторяет последнюю Ex-команду, & повторяет последнюю substitute.
. # repeat last change (most powerful key in Vim)
u # undo
Ctrl-r # redo
U # undo all changes on current line
:Nu # undo N changes
:earlier 10m # revert to state 10 minutes ago
:later 5 # redo 5 changes
:undolist # show undo tree branches
# Repeat with counts:
5. # repeat last change 5 times
# Repeat Ex commands:
@: # repeat last :command
& # repeat last :s (substitute)
# Repeat macros/marks across files:
:& # repeat last substitute on current lineПоиск и замена
Базовый поиск
/ и ? ищут вперёд и назад; n/N повторяют. * ищет целое слово под курсором (с границами слова), g* ищет любое вхождение подстроки. :noh снимает текущую подсветку до следующего поиска. 'hlsearch' постоянно подсвечивает все совпадения, 'incsearch' показывает совпадения по мере ввода.
/pattern # search forward for pattern
?pattern # search backward
n # repeat search (same direction)
N # repeat search (opposite direction)
* # search forward for word under cursor
# # search backward for word under cursor
g* # search forward (loose, matches substring)
g# # search backward (loose)
# Search history:
# Press / then Up/Down to recall previous searches
# Clear search highlighting:
:nohlsearch # or :noh
# Toggle 'hlsearch' permanently:
:set hlsearch!Опции поиска
'ignorecase' + 'smartcase' — рекомендуемая комбинация: без учёта регистра, пока в шаблоне нет заглавной буквы. \c/\C переопределяют регистр для конкретного поиска. \v включает режим 'very magic', где многие символы становятся особыми без экранирования, — более чистый синтаксис regex. Смещения поиска (e, b) ставят курсор относительно совпадения.
:set ignorecase # case-insensitive search (ic)
:set smartcase # case-sensitive if pattern has uppercase
:set hlsearch # highlight all matches (hls)
:set incsearch # show match as you type (is)
:set wrapscan # wrap around end of file (ws)
:set gdefault # add 'g' flag to all :s by default
# Per-search case override:
/foo\c # case-insensitive search for foo
/foo\C # case-sensitive search for foo
# Use very-magic mode (less escaping):
/foo\v(.+)@<=(bar) # very magic regex
# Search offsets:
/foo/e # cursor on last char of match
/foo/e+2 # cursor 2 chars past match
/foo/b-1 # cursor 1 char before matchШаблоны поиска (regex)
Regex в Vim отличается от PCRE: обратные слэши нужны для +, =, {, (, |. Используйте префикс \v для режима 'very magic', где они становятся особыми без экранирования (ближе к PCRE). \< и \> обозначают границы слов. \d/\w/\s — классы символов. Используйте \(...\) для захватывающих групп, \1/\2 для обратных ссылок.
# Standard Vim regex (default magic mode)
. # any char
* # zero or more (preceding atom)
\+ # one or more
\= # zero or one (optional)
\{n,m} # between n and m
^ $ # start/end of line
\< \> # word boundaries
[abc] # char class (a, b, or c)
[^abc] # negated char class
\( \) # group
\1 \2 # backreference
\| # or
# Predefined classes:
\d \D # digit / non-digit
\w \W # word char / non-word
\s \S # whitespace / non-whitespace
# Very magic (\v prefix) — less escaping:
/\v\w+\s+\w+ # word, spaces, word (no backslashes needed)
/\v(%d+) # capture one-or-more digitsКоманда substitute
:[range]s/pattern/replacement/flags — команда замены. :% означает весь файл. Без флага 'g' заменяется только первое совпадение в строке; 'g' заменяет все. 'c' спрашивает подтверждение (y/n/a/q/l). Используйте \v для very-magic, чтобы упростить синтаксис групп. Захватывающие группы в замене обозначаются \1, \2.
:[range]s/old/new/[flags]
# Basic:
:s/old/new/ # replace first 'old' on current line
:s/old/new/g # replace all 'old' on current line
:%s/old/new/g # replace all in whole file
:%s/old/new/gc # confirm each replacement
:%s/old/new/gi # case-insensitive
# Range examples:
:5,10s/old/new/g # lines 5-10
:.,$s/old/new/g # current line to end
:'a,'bs/old/new/g # from mark a to mark b
:'<,'>s/old/new/g # visual selection
:1,$s/old/new/g # whole file (same as %)
# Replace with capture groups:
:%s/\(\w\+\),\(\w\+)/\2,\1/ # swap two comma-separated words
:%s/\v(\w+),(\w+)/\2,\1/ # same with very-magicФлаги замены и особая замена
Частые флаги: g (все), c (подтверждение), i (без учёта регистра), n (только подсчёт). & в замене вставляет совпавший текст. \u/\U/\l/\L меняют регистр замены. Используйте \r для вставки перевода строки (\n в замене — нулевой байт). Флаг 'n' отлично подходит для подсчёта совпадений без изменений.
# Flags:
g # all occurrences on each line (not just first)
c # confirm each substitution
i # ignore case
I # don't ignore case
e # don't error if no match
p # print last substituted line
n # count matches, don't substitute
# Special chars in replacement:
& # the matched text
\0 # the matched text (same as &)
\1..\9 # capture groups
\u # next char uppercase
\U # rest of string uppercase (until \e or \E)
\l \L # lowercase (single / until \e)
\r # split into new line
\n # null byte (use \r for newline)
# Examples:
:%s/foo/&bar/g # foo -> foobar
:%s/\v(\w+)/\U\1/g # uppercase every word
:%s/, /,\r/g # split lines on ', '
:%s/old/new/gn # count matches onlyГлобальная команда (:g)
:g выполняет Ex-команду в каждой строке, совпавшей с шаблоном, — мощный 'глобальный' редактор. :v (или :g!) работает по несовпавшим строкам. Комбинируйте с любой Ex-командой: d (удалить), m (переместить), t (копировать), s (заменить), normal (выполнить normal-команду). Полезно для пакетных операций по помеченным строкам. Порядок важен: :g по умолчанию обрабатывает сверху вниз.
:[range]g/pattern/cmd # run cmd on each matching line
:[range]g!/pattern/cmd # run cmd on NON-matching lines
:v/pattern/cmd # same as :g! (inverse)
# Common uses:
:g/^$/d # delete all blank lines
:g/TODO/d # delete all lines with TODO
:g/pattern/p # print all matching lines
:g/pattern/normal @a # run macro a on each matching line
:g/pattern/m0 # move matching lines to top (reverse order)
:g/pattern/t$ # copy matching lines to end
:g/pattern/s/old/new/g # substitute on matching lines only
# Combined with Ex range:
:g/^#/s/foo/bar/g # in lines starting with #, replace foo with bar
# Multiple commands per match:
:g/pattern/d|t0 # delete then copy (chained with |)Визуальный режим
Типы визуального режима
v/V/Ctrl-v выделяют символы, строки и блок. gv повторно выделяет последнее визуальное выделение — удобно для повторного применения операции. o переходит к другому концу выделения (чтобы расширять в любую сторону). Для блочного O переходит к другому углу той же строки.
v # charwise visual (select characters)
V # linewise visual (select whole lines)
Ctrl-v # blockwise visual (select rectangle)
gv # reselect last visual selection
# In visual mode:
o / O # move cursor to other end of selection (corner for block)
Esc / v # exit visual mode (toggle)
# Quick selections from normal mode:
vap # select around paragraph
vip # select inside paragraph
i" # then press v... actually ciw etc. work directly
# Switching between types:
# v then V -> linewise (extends to whole lines)
# V then v -> charwise
# Ctrl-v -> blockwiseВизуальные операции
Когда выделение есть, d/c/y/x работают как ожидается. = автоматически форматирует отступы (отлично для переформатирования кода). >/< увеличивают и уменьшают отступ на один shiftwidth. ! пропускает выделение через shell-команду и заменяет его выводом. Нажатие : в визуальном режиме автоматически подставляет '<,'> как диапазон, поэтому :s/old/new/g выполнится только по выделению.
# In visual mode, press:
d / x # delete selection
c / s # change selection (delete, enter insert)
y # yank (copy) selection
~ # toggle case of selection
u / U # lowercase / uppercase selection
> # indent selection
< # dedent selection
= # auto-indent selection (reformat)
!cmd # filter through external command
:r !cmd # (after yank) paste command output
# Replace entire selection with a char:
r{x} # replace every char with x
# Print line numbers of selection:
g Ctrl-g # count words/chars/lines in selection
# Search within selection (after selecting, type :):
# '<,'>s/old/new/g -- range auto-filledПриёмы визуального блока
Визуальный блок (Ctrl-v) — одна из самых мощных возможностей Vim. I и A вставляют до и после блока — после Esc текст дублируется на каждой строке. Это самый простой способ добавить префикс комментария к нескольким строкам или дописать суффикс. c меняет весь блок; r{x} заменяет каждый символ на x. Блочные правки аккуратно работают, когда строки примерно одинаковой длины.
# Enter block visual: Ctrl-v
# Select a column rectangle, then:
I # insert BEFORE block (text typed appears in front)
# Type text, then Esc -> inserted on every line of block
A # insert AFTER block (text appears at end of each line)
# Esc propagates the insert to all lines
c # change block (delete, enter insert; Esc propagates)
r{x} # replace every char in block with x
# Common use cases:
# 1. Add a comment to a column of lines:
# Ctrl-v select first column, I, type '# ', Esc
# 2. Add semicolons at end of selected lines:
# Ctrl-v select end column, $A;, Esc
# 3. Delete a column:
# Ctrl-v select, d
# 4. Replace a column with same char:
# Ctrl-v select, r;Визуальный строчный режим
V выделяет целые строки. После V типичные операции — d/y/>/</= для работы с ними. :m перемещает выделение (например, :'<,'>m0 переносит его в начало). :t дублирует. '< и '> — метки начала и конца последнего визуального выделения, полезны в скриптах. gv повторно выделяет последний визуальный диапазон.
V # enter linewise visual
5V # select 5 lines (current + 4 below)
ggVG # select entire file
:'<,'> # range referring to last visual selection
# After selecting lines (V), useful commands:
d # delete lines
y # yank lines (linewise)
> # indent lines
< # dedent lines
= # auto-indent lines
:m +2 # move selection down 2 lines
:m -3 # move selection up 3 lines
:t . # duplicate lines (copy below selection)
:g/^/m0 # reverse line order (whole file)
# Reselect last visual:
gv # reselect last visual selection
'< # mark: start of last visual
'> # mark: end of last visualВизуальный режим с текстовыми объектами
Текстовые объекты работают и в визуальном режиме — они расширяют текущее выделение. vi( выделяет внутри скобок; va( включает скобки. Повтор объекта (vawaw) расширяет дальше. Это часто быстрее ручного позиционирования курсора. Комбинируйте с операторами: ciw меняет внутреннее слово независимо от позиции курсора в нём.
# In visual mode, text objects EXTEND the selection:
# After pressing v (charwise), type:
aw # extend selection to include next 'a word'
iw # extend selection to inner word
ab # around brackets ()
ib # inside brackets ()
aB # around braces {}
iB # inside braces {}
a" # around double-quoted string
i" # inside double-quoted string
ap # around paragraph
ip # inside paragraph
# Repeated text objects extend selection:
# vaw -> select word + trailing space
# vawaw -> extend to next word + space
# Switch between inner and around:
# vi( -> select inside parens
# va( -> extend to include the parensВизуальный поиск и нумерация
Нажатие : в визуальном режиме подставляет '<,'> как диапазон — замены выполняются только по выделению. Чтобы искать по визуальному выделению, используйте y/ затем Ctrl-r " Enter (вставить регистр в поиск). g Ctrl-a в визуальном блоке создаёт нарастающую последовательность — бесценно для генерации нумерованных списков (1, 2, 3, ...) из столбца одинаковых чисел.
# Search within visual selection:
# 1. Visually select (v/V/Ctrl-v)
# 2. Press : -> :'<,'> appears
# 3. Type s/old/new/g -> substitute only in selection
# Search for current visual selection (forward):
# In visual mode, type:
# \V then / (very-nomagic, escapes regex chars)
# Or use a plugin (e.g. vim-visual-star-search)
# Manual method:
# y/ then Ctrl-r " Enter -> search for selection
# Increment/decrement numbers (visual block):
# Select a column of numbers (Ctrl-v)
Ctrl-a # increment every number in selection by 1
Ctrl-x # decrement every number in selection by 1
g Ctrl-a # increment with running counter (1,2,3,...)
g Ctrl-x # decrement with running counter
# Example: turn 0,0,0,0 into 1,2,3,4:
# Ctrl-v select column, g Ctrl-aБуферы
Основы буферов
Буферы — файлы в памяти. :e открывает файл в новом буфере. :ls перечисляет все буферы с флагами статуса (% = текущий, # = альтернативный, + = изменён, h = скрытый). :b N переключает по номеру; :b name по уникальному префиксу. Ctrl-6 (или :b#) переключает между текущим и альтернативным буфером — крайне часто.
:e file.txt # open file in new buffer (current window)
:enew # new empty buffer
:ls / :buffers # list all buffers
:b N # go to buffer N (by number from :ls)
:b name # go to buffer by name (unique prefix)
:bn # next buffer
:bp # previous buffer
:b# / Ctrl-6 # alternate buffer (last edited)
:ball # open all buffers in horizontal splits
:vertical ball # open all buffers in vertical splits
# Buffer list symbols:
# % current window's buffer
# # alternate buffer
# a active (loaded and visible)
# h hidden (loaded but not visible)
# - not modifiable
# = read-only
# + modifiedНавигация по буферам
:bn/:bp перебирают буферы. Ctrl-6 переключает между двумя последними — самый быстрый способ туда-обратно. С 'hidden' переход с изменённого буфера не требует сохранения: Vim его скрывает. Если забыли но мера буферов, используйте :ls затем :b N. Плагины вроде fzf.vim делают нечёткое переключение буферов намного быстрее.
:bn / :bnext # next buffer (wraps around)
:bp / :bprev # previous buffer
:bf / :bfirst # first buffer
:bl / :blast # last buffer
:b# # alternate buffer (Ctrl-6)
:N b # go to buffer number N (e.g. 3b)
:b name<tab> # tab-complete buffer name
:ls then :b N # two-step navigation
# Faster navigation (set in vimrc):
:nmap <C-n> :bn<CR>
:nmap <C-p> :bp<CR>
# Jump to a buffer with fuzzy matching (with fzf.vim):
:Buffers # fuzzy-select from buffer list
# Hide current buffer without saving (if 'hidden' is set):
:hide # or :bn with 'set hidden'Операции с буферами
:bd убирает буфер из списка (файл закрывается). :bw также стирает метки и буферные переменные. :%bd | e# удаляет все буферы, кроме текущего, — частый паттерн очистки. :bufdo выполняет Ex-команду в каждом буфере — мощно для глобальных замен, но следите за ошибками (используйте ! или флаг 'e' у :s).
:bd / :bdelete # delete current buffer
:bd N # delete buffer N
:bd name # delete buffer by name
:bw / :bwipeout # wipe buffer (also clears marks, vars)
:N,N bd # delete buffers in range
:%bd # delete all buffers
:%bd | e# # delete all but current
:bn! # force switch (don't save current)
:wall # write all buffers
:bufdo cmd # run cmd in every buffer
:bufdo! cmd # same but ignore errors
# Useful patterns:
:bufdo %s/old/new/ge # substitute in all buffers
:bufdo setlocal nowrap # apply setting to all buffers
# Save and quit current buffer:
:wq # write current and quit (closes window)Скрытые буферы
С 'set hidden' (настоятельно рекомендуется) можно уходить от изменённых буферов без сохранения — Vim держит их в памяти. Без 'hidden' Vim блокирует переключение, пока вы не сохраните или не используете ! для отказа. :ls показывает 'h' для скрытых буферов и '+' при изменениях. Эта настройка необходима для продуктивной работы с несколькими файлами.
:set hidden # allow switching from modified buffers
:set nohidden # force save/abandon when switching
# With 'hidden' set:
# :bn # switch even if current is modified (no save)
# :q # if buffer is modified, prompts to save
# :qa! # quit all without saving
# :wa # write all (hidden + visible)
# Buffer with changes still in memory:
:ls # shows 'h' flag for hidden, '+' for modified
# Recover list of hidden buffers:
:ls h # only hidden buffers
# Save a hidden buffer:
:w # save current (if visible)
:N w # save buffer N
:wall # save all buffers
# Common workflow with hidden:
# :e file1 -> make changes -> :e file2 -> :e file1 (changes preserved)Список аргументов
Arglist — отдельный от списка буферов список: это набор файлов, переданных в командной строке или заданных :args. :n/:prev навигируют по нему. :argdo выполняет Ex-команду в каждом файле arglist — идеально для пакетной обработки вроде :argdo %s/foo/bar/ge | update. Arglist часто более сфокусирован, чем список буферов.
# Open files in arglist:
vim file1.txt file2.txt # initial args
:args file1 file2 file3 # replace arglist
:argadd file4 # add to arglist
:arga *.py # add all Python files
:argdelete file2 # remove from arglist
# Navigate arglist:
:n / :next # next file in arglist
:prev / :Next # previous file
:first # first file
:last # last file
:rewind # rewind to first file
# Process all files:
:argdo %s/old/new/ge # substitute in every arg file
:argdo set ff=unix | w # convert line endings in all
# Show current arglist:
:args # show files (current marked with [ ])Управление списком буферов
:ls перечисляет буферы, :ls! включает и те, что убраны из списка, но запомнены. :sb открывает буфер в сплите, не меняя буфер текущего окна. Встроенной отмены «недавно закрытого буфера» нет, но плагины существуют. :bufdo vimgrepadd с последующим :copen позволяет искать по всем открытым буферам через quickfix.
:ls # list all buffers
:ls! # list including unlisted buffers
:files # alias for :ls
# Move current buffer to a specific position:
:N b N # buffer number N
# Quickly inspect related files:
:b <tab> # tab-complete buffer names
:b #<tab> # buffers matching '#'
# Find buffer containing a pattern:
:vimgrep /pattern/ % # current buffer only
:bufdo vimgrepadd /pattern/ % # all buffers (then :copen)
# Open buffer in a specific window:
:sb N # open buffer N in horizontal split
:vertical sb N # open buffer N in vertical split
:tab split +b N # open buffer N in new tab
# Restore closed buffers:
# (No built-in, but plugins like vim-molten or
# vim-restore-buffers can help)Метки и переходы
Установка меток
Метки — именованные позиции в файлах. Строчные (a-z) локальны для буфера; заглавные (A-Z) — файловые метки, сохраняющиеся между сессиями Vim. Нумерованные метки (0-9) ставятся автоматически: 0 — позиция при последнем закрытии Vim, 1-9 — недавно закрытые файлы. :marks перечисляет их, :delm удаляет.
m{a-zA-Z} # set mark at cursor position
ma # set mark 'a' (lowercase, buffer-local)
mA # set mark 'A' (uppercase, file mark)
m' # set the unnamed mark (jump before/after)
# Lowercase marks (a-z):
# Local to current buffer
# Lost when buffer is unloaded
# Uppercase marks (A-Z):
# File marks — preserved across sessions
# Work even after the file is closed
# Numbered marks (0-9):
# Set automatically by Vim
# 0 = position when Vim was last closed
# 1-9 = positions of last 9 closed files
# View marks:
:marks # list all marks
:marks a b c # specific marks
:delm! a # delete mark 'a' (force)Переход к меткам
` (обратная кавычка) переходит к точной позиции (строка и колонка); ' (апостроф) — к первому непробельному символу помеченной строки. `A открывает файл с меткой A, даже если он был закрыт. `. переходит туда, где вы последний раз меняли текст, `[ и `] ограничивают последний скопированный или удалённый регион, `< и `> — последнее визуальное выделение.
\`{a-zA-Z} # jump to mark (line AND column)
'{a-zA-Z} # jump to mark (line only, column 1)
\`a # jump to mark 'a' (exact position)
'a # jump to line of mark 'a'
\`A # jump to file mark 'A' (opens file if closed)
\`. # jump to position of last change in this buffer
\`" # jump to position when file was last closed
\`[ # jump to start of last yanked/changed text
\`] # jump to end of last yanked/changed text
\`< # jump to start of last visual selection
\`> # jump to end of last visual selection
\`^ # jump to last insert position (also gi)
# Jump to next/prev mark in alphabetical order:
:[count]next # (no built-in, requires plugin)Jumplist
Vim ведёт jumplist значимых перемещений курсора. Ctrl-o/Ctrl-i двигаются назад и вперёд по нему. «Значимые» — это переходы (G, gg, поиск, переходы к меткам и тегам), а не обычные движения вроде j/k/w. :jumps показывает список. Jumplist свой для окна и сохраняется между сессиями в viminfo/shada.
Ctrl-o # jump BACK in jumplist (older positions)
Ctrl-i # jump FORWARD in jumplist (newer positions)
Tab # same as Ctrl-i
:ju # show jumplist (:jumps)
# What counts as a jump?
# - Movement commands: G, gg, H, M, L, %
# - Search: /, ?, n, N, *, #
# - Mark jumps: 'x, `x (NOT mm)
# - Buffer switch: Ctrl-6, :b, :e
# - Tag jumps: Ctrl-]
# NOT counted: j, k, w, b, h, l (regular motions)
# Max jumplist size: 100 entries by default
:set jumpoptions=stack # treat jumplist like a stack
# Clear jumplist:
:clearjumps # or :cljChangelist
Changelist отслеживает позиции правок (не навигации). g; переходит к предыдущей правке, g, — к следующей. Полезно, чтобы пройти назад по своим изменениям и понять, где вы только что работали. :changes показывает список. В отличие от jumplist, changelist свой для буфера. В сочетании с `.` для самой последней правки в текущем буфере.
g; # go to OLDER position of last change
g, # go to NEWER position of last change
:changes # list changelist
# Each entry shows:
# change number, line, column, text of change
# What counts as a change?
# - Any insertion, deletion, or substitution
# - Records the position BEFORE the change
# Differences from jumplist:
# - Changelist tracks EDITS, not movements
# - Per-buffer (not per-window)
# - Limited to 100 entries
# Combine with marks:
\`. # last change position in current buffer
g; # previous change position
# Common pattern: g;g;g; to walk back through editsФайловые метки (A-Z)
Заглавные метки (A-Z) — файловые: они помнят файл И позицию и сохраняются между сессиями Vim (в viminfo). Поставив mA в foo.txt, вы можете вернуться туда откуда угодно через `A, даже после перезапуска Vim. Используйте их как закладки для важных файлов и позиций в проекте.
# Setting a file mark:
mA # set mark 'A' at cursor (in current file)
mB # set mark 'B' (in current file)
# Jumping to a file mark:
\`A # if file is open: jump to position
\`A # if file is closed: open it, then jump
'A # jump to first non-blank of mark's line
# File marks persist across Vim sessions:
# Stored in viminfo (or shada in Neovim)
# Restored on next Vim launch
# Use cases:
# 1. Bookmark a function: mA in function definition
# 2. Quick jump between files: `A, `B
# 3. Project navigation: set marks in important files
# Listing file marks:
:marks A-Z # show only file marks
# Deleting:
:delm A # delete file mark A (must be in its file)Встроенные специальные метки
Vim ставит специальные метки автоматически. `. — последнее изменение, `[ и `] ограничивают последний скопированный или удалённый регион, `< и `> — последнее визуальное выделение, `^ — где последний раз закончился режим вставки (gi переходит туда и снова входит в insert). `" — позиция при последнем закрытии файла, полезно для продолжения работы.
\`. # position of last change in current buffer
\`" # position when file was last exited
\`[ # start of last yanked/changed text
\`] # end of last yanked/changed text
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # position where insert mode was last stopped
\`' # position before latest jump (where you came FROM)
# Common uses:
\`[\`] # operate on last yanked range: \`[v\`]U (uppercase it)
\`<\`> # re-select last visual: \`<v\`> or gv
# Re-select last visual selection:
gv # easier than \`<v\`>
# Re-select last pasted text:
\`]v\`[ # or use a mapping: nnoremap gp \`]v\`[
# Return to last insert position:
gi # jump to `^ and enter insert modeТекстовые объекты
Объекты слов и предложений
Текстовые объекты позволяют работать со смысловыми единицами. 'aw' (around word) включает хвостовые пробелы — daw закрывает разрыв. 'iw' (inner word) оставляет пробелы — diw оставляет пустое место. as/ap — версии для предложения и абзаца. Повтор объекта (dawaw) расширяет выделение. Чаще всего полезны с операторами d/c/y/v.
# Operators (d/c/y/v) + text object:
aw # 'a word' - word + trailing whitespace
iw # 'inner word' - word only (no whitespace)
aW # 'a WORD' - WORD + trailing whitespace
iW # 'inner WORD' - WORD only
as # 'a sentence' - sentence + trailing space
is # 'inner sentence' - sentence only
ap # 'a paragraph' - paragraph + trailing blank line
ip # 'inner paragraph' - paragraph only
# Examples:
daw # delete word + trailing space (closes gap)
diw # delete word only (leaves whitespace)
cas # change sentence (with trailing space)
yap # yank paragraph (with trailing blank line)
gqip # format (wrap) inner paragraph
# Repeated: dawaw extends to next wordОбъекты скобок
Объекты скобок работают с (), [], {}, <>. a (around) включает скобки; i (inner) их исключает. ci( меняет содержимое скобок, не удаляя их, — идеально для правки аргументов функции. При вложенности работает с самой внутренней парой. at/it работают с HTML/XML-тегами (например, cit меняет содержимое тега).
# Brackets (any of ( [ { <):
ab / ib # around / inside ()
aB / iB # around / inside {} (also a{ / i{)
a( / i( # same as ab / ib
a[ / i[ # around / inside []
a{ / i{ # same as aB / iB
a< / i< # around / inside <>
# Examples:
ci( # change text inside ( ... )
daB # delete {...} block including braces
yi[ # yank text inside [...]
vaB # visually select around {...}
# Special: 'tag' objects (HTML/XML):
at / it # around / inside <tag>...</tag>
# Tip: works with mismatched brackets too:
# ci) on (foo bar) changes 'foo bar'
# Nested: ci( in ((a)(b)) changes innermostОбъекты кавычек
Объекты кавычек (a"/i", a'/i', a`/i`) работают со строками в кавычках. Курсору не нужно быть внутри кавычек — Vim находит ближайшую пару. ci" меняет содержимое строки, не удаляя кавычки, — бесценно для правки строковых литералов. Включает кавычки с 'a', исключает с 'i'.
a" # around double-quoted string (includes quotes)
i" # inside double-quoted string (no quotes)
a' # around single-quoted string
i' # inside single-quoted string
a\` # around backtick-quoted string
i\` # inside backtick-quoted string
# Examples:
ci" # change text inside "..."
da" # delete "..." (including quotes)
yi' # yank text inside '...'
va\` # visually select around \`...\`
# Cursor can be ANYWHERE on the line — Vim finds the
# nearest quote pair containing or following the cursor.
# Special: with counts
3a" # around 3 consecutive quoted strings
# Tip: ci" when cursor is on the quote itself works tooОбъекты предложений и абзацев
Предложения заканчиваются на . ! ? и пробел (или разрыв абзаца). Абзацы — блоки, разделённые пустыми строками. 'a' включает хвостовые пробелы, 'i' исключает. Полезно с операторами: gqap переформатирует абзац, >ip делает отступ, das удаляет предложение. Движения ( и ) прыгают между предложениями.
# Sentence: ends with . ! ? followed by whitespace
as / is # around / inner sentence
# Paragraph: blocks of text separated by blank lines
ap / ip # around / inner paragraph
# Examples:
das # delete a sentence
cip # change inside paragraph
vap # select around paragraph (with trailing blank)
# Differences:
# 'a' (around): includes trailing whitespace/blank line
# 'i' (inner): no trailing whitespace
# Use cases:
# gqap # reformat (wrap) the paragraph
# >ap # indent the paragraph
# vip # select inside paragraph
# :'<,'>s/old/new/g # substitute in selected paragraph
# Sentence motion commands (not objects):
( # previous sentence start
) # next sentence startОбъекты тегов и URL (с плагинами)
Встроенные at/it работают с HTML/XML-тегами. cit меняет содержимое тега, dat удаляет весь тег вместе с открывающим и закрывающим. Для вложенных тегов it выбирает самый внутренний, затем vat расширяет наружу. Плагины добавляют объекты: vim-textobj-url (au/iu), vim-indent-object (ai/ii для блоков с одинаковым отступом — отлично для кода).
# Built-in tag object (HTML/XML):
at / it # around / inside <tag>...</tag>
# Examples:
cit # change inner tag text: <p>text</p> -> <p>|</p>
dat # delete entire tag: <p>text</p> -> (gone)
vit # visually select inner tag text
yat # yank entire tag including <tag>...</tag>
# For nested tags, 'it' selects the innermost:
# <div><p>text</p></div>
# cit on 'text' changes 'text' only
# vat extends selection outward
# URL objects (require a plugin like vim-textobj-url):
# au / iu # around / inside URL
# Indent objects (require vim-indent-object):
# ai / ii # around / inside same-indent block
# aI / iI # entire indentation level
# Common plugin combos:
# vai # select around indent block (great for code)Использование текстовых объектов (рецепты)
Текстовые объекты комбинируются с любым оператором (d/c/y/v/>/</=) для мощных правок. ciw меняет слово, не требуя точного позиционирования курсора. ci"/ci(/ci[ меняют внутри кавычек и скобок. gqip переформатирует абзацы. Освоение этого — ключ к редактированию со скоростью мысли в Vim.
# Common editing recipes using text objects:
# Word:
ciw # change word (regardless of cursor position in it)
daw # delete word + space (closes gap)
yiw # yank inner word (no whitespace)
# Quotes:
ci" # change inside "..."
ci'\` # change inside '...' or \`...\`
da" # delete the entire string (with quotes)
# Brackets:
ci( # change inside (...) -- great for args
daB # delete {...} block (function body)
ci[ # change inside [...]
# Sentences & paragraphs:
cas # change a sentence
dap # delete a paragraph
gqip # reformat paragraph
# HTML tags:
cit # change tag content
vat # select tag, then vat again to extend
# Combos with counts:
2daw # delete two words
c2aw # change two wordsРегистры
Основы регистров
Регистры — буферы обмена Vim. "ayy копирует строку в регистр a, "ap вставляет из a. Регистров много: именованные (a-z), добавляющие (A-Z), нумерованные (1-9) и специальные (безымянный ", yank 0, буфер обмена + и др.). :reg перечисляет их. В режиме вставки Ctrl-r {reg} вставляет регистр. Заглавная буква ДОПИСЫВАЕТ в регистр.
# Registers store text. 10 named (a-z), 10 append (A-Z),
# 9 numbered (1-9), and several special ones.
"ay # yank into register 'a' (then motion: "ayy, "ayw)
"ap # paste from register 'a'
"ad # delete into register 'a' (e.g. "add)
"Ay # APPEND to register 'a' (uppercase = append)
# View all registers:
:reg # list all registers
:reg a b c # list specific registers
:reg + # show clipboard register
# Use a register with operators:
"aD # delete to end of line into 'a'
"byy # yank line into 'b'
"cp # paste register 'c'
# Insert mode: Ctrl-r + register
Ctrl-r a # insert contents of register 'a'
Ctrl-r = # expression register (compute, insert)
# Search from a register:
/ then Ctrl-r a # search register 'a' contentsИменованные и нумерованные регистры
Именованные регистры (a-z) под контролем пользователя; A-Z дописывают в a-z. Нумерованные (1-9) автоматически отслеживают недавние удаления: 1 — самое свежее, каждое новое удаление сдвигает их. Регистр 0 хранит только последний YANK (удаления его не перезаписывают) — полезно для сценариев «скопировать, потом удалить». "- хранит небольшие (внутристрочные) удаления.
# Named registers (a-z, A-Z):
"ayy # yank line into 'a'
"byiw # yank inner word into 'b'
"Ayy # append yanked line to 'a' (uppercase)
# Numbered registers (1-9) — auto-filled by deletes:
"1 # last delete (largest)
"2 # second-to-last delete
... # shift older with each new delete
"9 # oldest tracked delete
# Small delete register:
"- # stores deletes < 1 line (e.g. dw)
# Yank register (separate from deletes):
"0 # last YANK only (not affected by deletes)
# Examples:
"0p # paste last yank (won't paste a delete)
"1p # paste last delete
". # last inserted text (read-only)
"% # current file name (read-only)Специальные регистры
Специальные регистры: ". = последний вставленный текст, "% = текущий файл, "/ = последний поиск, ": = последняя команда. "_ — чёрная дыра: запись в неё отбрасывает текст (полезно для удалений, которые не должны засорять другие регистры). "+ — системный буфер обмена, "* — primary selection X11. "= вычисляет выражение Vimscript и вставляет результат.
# Read-only registers:
". # last inserted text
"% # current file name
"# # alternate file name
": # last Ex command
"/ # last search pattern
# Read/write registers:
"0 # last yank (not overwritten by deletes)
"- # last small delete (less than one line)
"_ # black hole register (discard, like /dev/null)
"= # expression register (evaluate Vimscript)
# Clipboard / selection:
"+ # system clipboard (Ctrl-C / Ctrl-V)
"* # primary selection (X11 middle-click)
# Examples:
"_dd # delete line without saving to register
"+y # yank to system clipboard (then Ctrl-V elsewhere)
"*p # paste from X11 primary selection
# Expression register (in insert mode):
Ctrl-r =strftime('%Y-%m-%d')<CR>
# inserts today's date
# Black hole: "_ prevents updating other registers.Макросы в регистрах
Макросы живут в регистрах: запись через qa пишет нажатия в регистр a, @a воспроизводит. Поскольку это регистры, их можно посмотреть (:reg a), отредактировать (вставить, изменить, скопировать обратно) или сохранить в vimrc через :let @a = '...'. Экранируйте специальные клавиши как \<Esc> в строковых литералах.
# Macros are stored in registers, just like yanked text.
# Record a macro into register 'a':
qa # start recording into 'a'
... # perform actions
q # stop recording
# Play back the macro:
@a # play macro 'a' once
@@ # play last macro again (the one just played)
5@a # play macro 'a' 5 times
:reg a # view the recorded keystrokes
# Edit a macro:
:let @a = "..." # set register 'a' directly
# Or: paste the register, edit, yank back:
"ap # paste macro keystrokes
# ... edit the text ...
"ayy # yank edited version back into 'a'
# Save a macro to vimrc:
:let @a = "0iHello \<Esc>" # escaped special keys
# Apply macro to a range:
:%normal @a # run macro 'a' on every lineДописывание и чёрная дыра
Заглавные буквы регистров ДОПИСЫВАЮТ: "Ayy дописывает в регистр a (очень полезно для накопления текста или многошаговых макросов). Регистр-чёрная дыра "_ отбрасывает всё записанное — удаления не обновляют нумерованные, безымянный и yank-регистры. Используйте, когда нужно удалить текст, не затирая последний yank.
# Append to a register (use UPPERCASE letter):
"ayy # yank line into 'a'
"Ayy # APPEND another line to 'a'
"Ayiw # APPEND a word to 'a'
# After: register 'a' contains both.
# Black hole register "_:
"_d # delete without affecting other registers
"_dd # delete line, doesn't update "1, "0, "-
"_c # change without saving deleted text
"_x # delete char, nothing saved
# Why use black hole?
# - Keep your yank register ("0) intact while deleting
# - Avoid polluting numbered registers
# Example: yank a line, then delete another (without
# losing the yank):
"ayy # yank into 'a'
"_dd # delete line WITHOUT touching 'a' or '0
"ap # paste the original yank
# When clipboard=unnamed, "_d still bypasses clipboard.Буфер обмена и выделение
"+ — системный буфер обмена (Ctrl-C/Ctrl-V в GUI-приложениях), "* — primary selection X11 (вставка средней кнопкой). С :set clipboard=unnamedplus yank и paste идут напрямую в системный буфер — префикс "+ не нужен. В Linux может понадобиться установить xclip/xsel (X11) или wl-clipboard (Wayland).
# System clipboard register:
"+y # yank to system clipboard
"+p # paste from system clipboard
"+dd # delete line to clipboard
"+P # paste before cursor from clipboard
# X11 primary selection (Linux, middle-click):
"*y # yank to primary selection
"*p # paste from primary selection
# Make the system clipboard the default:
:set clipboard=unnamedplus # use '+ for unnamed register
:set clipboard=unnamed # use '* for unnamed register
# Then yank/paste go to clipboard automatically:
yy # yanks to system clipboard (with above setting)
p # pastes from system clipboard
# Check what's in the clipboard:
:reg + # show clipboard contents
# On Linux, install a clipboard tool if missing:
# xclip or xsel for X11
# wl-clipboard for WaylandМакросы
Запись макросов
q{letter} начинает запись в регистр; нажмите q снова, чтобы остановить. Записанные нажатия воспроизводятся через @{letter}. При записи используйте движения, работающие стабильно: предпочитайте 0, ^, $, w, e вместо j/k, зависящих от колонки. Проверьте на нескольких строках перед массовым применением.
q{a-z} # start recording into register {a-z}
... # perform actions (keystrokes recorded)
q # stop recording
# Example: wrap each word in quotes on a line:
qa # start recording into 'a'
0 # go to first column
i" # insert opening quote
Esc
e # go to end of word
a" # append closing quote
Esc
w # move to next word
q # stop recording
# Now @a will wrap one more word.
# Recording tips:
# - Use 0/^-positioned motions (not j/k)
# - Use commands that work regardless of line length
# - Test on a few lines before applying broadly
# View the recorded macro:
:reg a # see keystrokes in register 'a'Воспроизведение макросов
@a воспроизводит макрос один раз, @@ повторяет последний, N@a — N раз. Чтобы применить макрос ко многим строкам, выделите их визуально и выполните :normal @a или :%normal @a для всего файла. Макросы останавливаются на ошибке (например, когда поиск не удался), поэтому 999@a безопасно обрабатывает до конца файла. :g/pattern/normal @a работает только по совпавшим строкам.
@a # play macro 'a' once (in current buffer)
@@ # replay the LAST macro played
5@a # play macro 'a' 5 times
100@a # play 'a' up to 100 times (stops on error)
# Play across multiple lines:
# 1. Visually select lines (V)
# 2. :normal @a # play 'a' on each selected line
# Or:
:%normal @a # play on every line in file
:5,20normal @a # play on lines 5-20
:g/pattern/normal @a # play on lines matching pattern
# Recursive macros:
# If macro 'a' contains @a, it'll recurse.
# Add a 'j' at the end to move to next line.
# Common pattern: process all matching lines:
# qa0f:x...jq # record macro moving down 1 line
# :%s/pattern//gn # count matches
# 100@a # play up to 100 timesРедактирование макросов
Поскольку макросы хранятся в регистрах, их можно редактировать. Вставьте регистр ("ap), измените текст, затем скопируйте обратно ("ay$ или "ayy). Или используйте :let @a = '...' с экранированием клавиш (\<Esc>, \<CR>). Это намного проще, чем записывать сложный макрос заново при небольшой ошибке.
# Macros are just text in registers — you can edit them.
# Method 1: paste, edit, yank back:
"ap # paste register 'a' into buffer
# ... edit the pasted text (modify keystrokes) ...
0"ay$ # yank the line back into 'a'
# Method 2: set the register directly with :let
:let @a = "0iHello \<Esc>"
# Note: special keys need \<Esc> notation in strings
# Method 3: edit in a scratch buffer:
:edit
"ap # paste macro
# edit
"ayy # yank back to 'a'
:bdelete
# Common edits:
# - Add 'j' at the end to advance to next line
# - Remove a step that you don't need
# - Replace a hard-coded search with a generic one
# Show the macro as keystrokes:
:reg a # view current 'a' contentsРекурсивные макросы
Рекурсивные макросы вызывают себя, пока не произойдёт ошибка, — обычно когда поиск не удался. КРИТИЧНО: сначала очистите регистр (let @a = ''), иначе первый вызов @a внутри макроса воспроизведёт СТАРОЕ содержимое. Макрос сам завершается, когда сбойный поиск останавливает рекурсию. Отлично для глобальных паттернов поиска и замены.
# A macro can call itself, enabling recursion.
# Example: change every 'foo' to 'bar' in a column:
# (search-based macro)
# Steps to set up recursive macro 'a':
# 1. Clear register 'a':
:let @a = ''
# 2. Start recording:
qa
# 3. Search for 'foo':
/foo<CR>
# 4. Replace with 'bar' (ciwbar<Esc>):
ciwbar<Esc>
# 5. Call itself:
@a
# 6. Stop recording:
q
# Now @a runs until search fails (no more 'foo').
# The recursion stops automatically on the first error
# (when /foo finds nothing).
# Tip: clear the register first, otherwise the FIRST
# call also replays the old contents of 'a'.
# Run:
@a # processes all 'foo' in fileМакросы со счётчиками
N@a воспроизводит макрос N раз, но останавливается раньше при любой ошибке, поэтому 999@a безопасно обрабатывает до конца файла. :bufdo normal @a выполняет макрос в каждом буфере, :argdo — в каждом файле arglist. :g/pattern/normal @a выполняет только по совпавшим строкам. Счётчики ВНУТРИ макроса (например, 5j) повторяются при каждом воспроизведении, а не на макрос.
# Apply a count to a macro:
5@a # play macro 'a' 5 times
N@a # play up to N times (stops on error)
# Useful: large count to process until end-of-file
999@a # play 'a' up to 999 times (errors stop it)
# Macros with counts INSIDE:
# If your macro starts with '5j', each play jumps 5 lines
# Combine with visual selection (block):
# Ctrl-v to select, then :normal @a
# plays 'a' on each line in the block
# Process every Nth line:
:let i = 0
:g/^/if i % 3 == 0 | normal @a | endif
# (plays 'a' on every 3rd line)
# Apply with a delay (avoid blocking):
# No built-in, but plugins can defer
# Repeat across buffers:
:bufdo normal @a # play 'a' in every buffer
:argdo normal @a # play 'a' in every arg fileМакросы по файлам и строкам
:[range]normal @a выполняет макрос на каждой строке диапазона — самый частый способ применить макрос ко многим строкам. Завершайте макрос 'j', чтобы каждая итерация переходила к следующей строке. :bufdo/:argdo выполняют его по буферам и файлам. Добавьте | update, чтобы сохранять каждый изменённый файл. Используйте ! чтобы продолжать после ошибок (например, :bufdo!).
# Apply a macro to every line in a range:
:[range]normal @a
:%normal @a # whole file
:5,20normal @a # lines 5-20
:'<,'>normal @a # visual selection
:g/pattern/normal @a # only matching lines
# Apply across buffers:
:bufdo normal @a # every buffer
:argdo normal @a # every arglist file
# Save modified buffers after macro run:
:argdo normal @a | update # save each that changed
# Best practice: include 'j' (move down) at end of macro
# so it advances to the next line for :normal usage.
# Example macro for processing CSV rows:
# qa 0f,dt,j q # cut field at comma, move down
# :%normal @a # apply to every line
# Abort on error vs. continue:
:bufdo! normal @a # continue even if a buffer errors
# Debug: play macro step-by-step (no built-in, but
# :set lazyredraw off + slow key timing helps).Сворачивание (folding)
Методы сворачивания
foldmethod управляет тем, как создаются фолды. 'manual' позволяет создавать фолды через zf. 'indent' автоматически сворачивает по отступам (отлично для кода). 'syntax' использует правила синтаксиса (с учётом языка). 'marker' использует {{{ }}} в тексте файла. 'expr' для своей логики. Ручные фолды теряются при закрытии файла, если не сделать :mkview для их сохранения.
:set foldmethod=manual # fold by hand (zf)
:set foldmethod=indent # fold by indent level
:set foldmethod=expr # fold by 'foldexpr'
:set foldmethod=syntax # fold by syntax rules
:set foldmethod=marker # fold by {{{ }}} markers
:set foldmethod=diff # fold unchanged text in diff
# Recommended defaults:
:set foldmethod=indent # great for code
:set foldlevel=2 # show first 2 levels
# Per-method notes:
# manual - zf to create, zd to delete
# indent - automatic, based on shiftwidth
# syntax - automatic, requires syntax file support
# marker - persistent (saved in file as {{{ }}})
# expr - custom logic via 'foldexpr'
# Persistent manual folds across sessions:
:mkview # save folds (and other view state)
:loadview # restore them
# Or set:
:set viewoptions=folds # what :mkview savesРучное сворачивание
В ручном режиме zf создаёт фолд (например, zf3j сворачивает следующие 3 строки). zd удаляет один фолд, zD удаляет рекурсивно, zE убирает все фолды в окне. Визуальный режим и zf сворачивают выделение. С foldmethod=marker вы ставите {{{ и }}} в комментариях, создавая постоянные фолды в файле, — полезно для передачи структуры фолдов через систему контроля версий.
# Manual fold commands (foldmethod=manual):
zf{motion} # create fold over motion (e.g. zf3j)
zF # create fold over current line(s)
zd # delete fold at cursor
zD # delete fold recursively (nested)
zE # eliminate ALL folds in window
zj / zk # move to next/prev fold start
[z / ]z # move to fold start/end
# Select then fold (visual):
V zf # visually select lines, then fold
# Create fold for a range:
:5,20fold # fold lines 5-20
# Fold using a marker (manual mode):
# Place markers in the file (with foldmethod=marker):
function Foo() " {{{
echo "hi"
endfunction " }}}
# When foldmethod=marker, the {{{ }}} create persistent
# folds stored in the file text itself.Открытие и закрытие фолдов
zo/zc открывают и закрывают фолд; za переключает. zO/zC/zA действуют рекурсивно на вложенные фолды. zr/zm глобально меняют уровень сворачивания (на один уровень за раз). zR открывает всё, zM закрывает всё — быстрые способы сброса. zj/zk прыгают между фолдами, [z/]z — к началу и концу текущего фолда.
zo # open fold (one level)
zc # close fold (one level)
za # toggle fold (open <-> closed)
zO # open fold recursively (all levels)
zC # close fold recursively (all levels)
zA # toggle fold recursively
zr # reduce fold level by 1 (open one level everywhere)
zm # increase fold level by 1 (close one level everywhere)
zR # open ALL folds (reduce to level 0)
zM # close ALL folds (fold everything)
# Navigation in/around folds:
zj # next fold start (down)
zk # previous fold end (up)
[z # start of current open fold
]z # end of current open fold
# Move with folds intact (don't open):
# Use j/k normally — they may skip closed folds
# Set 'foldopen' to control what opens foldsНавигация и редактирование фолдов
j/k могут пропускать закрытые фолды в зависимости от 'foldopen'. zj/zk навигируют между границами фолдов. yy/dd на свёрнутой строке работают со ВСЕМИ свёрнутыми строками как с единицей (построчно). Ввод внутри закрытого фолда открывает его. Настройте 'foldopen', чтобы управлять тем, какие движения открывают фолды (например, уберите 'search', чтобы поиск не раскрывал фолды).
# Fold-related motions:
zj # next fold start (move down)
zk # previous fold end (move up)
[z # start of current open fold
]z # end of current open fold
# What opens a fold when triggered?
:set foldopen=block,hor,mark,percent,quickfix,
search,tag,undo
# Defaults open folds on most motions.
# To make j/k NOT open folds:
:set foldopen-=block
# Editing a closed fold:
# Typing inside a closed fold opens it.
# 'o' or 'O' on a fold line opens a new line.
# Search inside closed folds:
# Default behavior depends on 'foldopen'.
# :set foldopen-=search # don't open on search
# Yank/paste on folded lines:
# yy yanks ALL lines in the fold (linewise)
# dd deletes ALL lines in the fold
# Paste over a fold:
# p with a linewise register replaces the folded regionОпции фолдов
foldlevel управляет тем, насколько глубоко фолды остаются открытыми (больше = более открыто). foldlevelstart=99 стартует со всем открытым. foldcolumn показывает боковую панель с индикаторами состояния фолдов. foldminlines предотвращает крошечные фолды. Чтобы сохранять фолды между сессиями, :mkview на BufWinLeave и :loadview на BufWinEnter — частый паттерн autocmd.
:set foldmethod=indent # folding method
:set foldlevel=2 # show folds deeper than this
:set foldlevelstart=99 # start with all folds open
:set foldminlines=3 # min lines to form a fold
:set foldcolumn=4 # 4-char column showing fold state
:set foldenable # enable folding (default on)
:set foldclose=all # auto-close folds when cursor leaves
:set foldopen=block,hor,mark,percent,quickfix,search,tag,undo
:set foldtext=foldtext() # text to show on a closed fold
:set fillchars=fold:\ , # chars for fold display
# Common combo for code:
:set foldmethod=indent
:set foldlevelstart=10
:set foldnestmax=10 # max nesting depth
# Custom fold text:
:set foldtext=MyFoldText()
function MyFoldText()
return '+++ ' . (v:foldend - v:foldstart + 1) . ' lines +++'
endfunction
# Persistent folds across sessions:
:set viewoptions=folds,cursor
:autocmd BufWinLeave * mkview
:autocmd BufWinEnter * silent loadviewВложенные фолды и уровень
Фолды вкладываются иерархически. 'foldlevel' задаёт самый глубокий уровень, который остаётся открытым: foldlevel=0 закрывает всё, 99 открывает всё. zr/zm меняют на 1, zR/zM — крайности. 'foldnestmax' ограничивает глубину вложенности, чтобы избежать лавины фолдов в глубоко вложенном коде. Свои foldtext-функции позволяют управлять тем, что показывается на закрытом фолде.
# Folds can nest. 'foldlevel' controls which are open:
:set foldlevel=0 # all folds closed
:set foldlevel=1 # only top-level open
:set foldlevel=99 # all open
# Display current fold level:
:echo &foldlevel
# Increase/decrease by 1:
zr # reduce (open one level everywhere)
zm # more (close one level everywhere)
zR # open ALL folds (set foldlevel to 99)
zM # close ALL folds (set foldlevel to 0)
# Limit nesting:
:set foldnestmax=10
# Each indent level adds a fold level.
# Useful for deeply-nested code:
# function outer() {
# function inner() { <- foldlevel 2
# function deep() { <- foldlevel 3
# }
# }
# }
# Custom foldtext for nested folds:
:set foldtext=NeatFoldText()
function! NeatFoldText()
let line = getline(v:foldstart)
let n = v:foldend - v:foldstart + 1
return line . ' (' . n . ' lines)'
endfunctionСплиты окон
Разделение окон
:split/:vsplit делят текущее окно — оба по умолчанию показывают один буфер (изменения синхронизируются). :split file открывает файл в новом сплите. :new/:vnew создают пустые буферы. Ctrl-w s/v — клавиатурные сокращения. Числовой префикс задаёт размер нового окна (:10split создаёт окно в 10 строк).
:split / :sp # horizontal split (current file)
:vsplit / :vs # vertical split (current file)
:split file.txt # split + open file
:vsplit file.txt # vsplit + open file
:new # horizontal split with empty buffer
:vnew # vertical split with empty buffer
:5split / :5vsplit # split with 5 rows/cols
# Quick splits (Normal mode):
Ctrl-w s # split horizontally (same as :split)
Ctrl-w v # split vertically (same as :vsplit)
Ctrl-w n # new horizontal split (empty)
Ctrl-w q # close window (same as :q)
# Split with size hints:
:10split file.txt # split with height 10
:vert 30split file # vertical split with width 30
# Reopen current file in a new split:
Ctrl-w s # same buffer, two views (sync scroll optional)Навигация по окнам
Ctrl-w затем h/j/k/l навигирует между окнами (мнемоника: hjkl как движение). Ctrl-w w переходит к следующему окну. Для скорости многие маппят Ctrl-h/j/k/l прямо на навигацию по окнам. Ctrl-w p возвращает к предыдущему окну — полезно при переключении между двумя окнами.
Ctrl-w h # left window
Ctrl-w j # below window
Ctrl-w k # above window
Ctrl-w l # right window
Ctrl-w w # cycle to next window (wraps)
Ctrl-w W # cycle to previous window
Ctrl-w t # top-left window
Ctrl-w b # bottom-right window
Ctrl-w p # previous (last accessed) window
# Faster (with mapping):
:nmap <C-h> <C-w>h
:nmap <C-j> <C-w>j
:nmap <C-k> <C-w>k
:nmap <C-l> <C-w>l
# In terminal mode:
Ctrl-w N # exit terminal mode (to Normal)
Ctrl-w h/j/k/l # navigate (after exiting terminal mode)
# List windows in current tab:
:ls # also shows windows' buffersИзменение размера окон
Ctrl-w +/-/</> меняют размер на 1; с префиксом-счётчиком (10 Ctrl-w +) шаг больше. Ctrl-w _ максимизирует высоту, Ctrl-w | — ширину. Ctrl-w = выравнивает все окна. Для точности используйте :resize N (высота) и :vertical resize N (ширина). С 'mouse=a' можно тянуть строки статуса и разделители напрямую.
Ctrl-w = # equalize all window sizes
Ctrl-w + # increase height by 1
Ctrl-w - # decrease height by 1
Ctrl-w > # increase width by 1
Ctrl-w < # decrease width by 1
Ctrl-w _ # maximize height (current window)
Ctrl-w | # maximize width (current window)
10 Ctrl-w + # increase height by 10
# Ex commands for precise resize:
:resize 20 # set height to 20 (horizontal split)
:resize +5 # increase height by 5
:resize -5 # decrease height by 5
:vertical resize 80 # set width to 80 (vertical split)
:vertical resize +10 # increase width by 10
# Mouse: drag the status line / vertical separator
# (with :set mouse=a)
# Auto-resize on split:
:set equalalways # default: auto-equalize on split/close
:set noequalalways # don't auto-resizeПеремещение окон
Ctrl-w H/J/K/L перемещают текущее окно к дальним краям (заглавная = на всю сторону). Ctrl-w r/R вращают окна в раскладке. Ctrl-w x меняется местами со следующим окном. Ctrl-w T переносит окно в новую вкладку. Аккуратный трюк: Ctrl-w K/H также переключают горизонтальную и вертикальную ориентацию.
Ctrl-w H # move current window to far LEFT (full height)
Ctrl-w J # move current window to BOTTOM (full width)
Ctrl-w K # move current window to TOP (full width)
Ctrl-w L # move current window to far RIGHT (full height)
Ctrl-w r # rotate windows DOWN/RIGHT
Ctrl-w R # rotate windows UP/LEFT
Ctrl-w x # exchange current window with next
Ctrl-w T # move current window to a NEW tab page
# Move split orientation:
Ctrl-w K # if vertical, become horizontal (and move to top)
Ctrl-w H # if horizontal, become vertical (and move to left)
# Example: convert a vertical split to horizontal:
:vsplit # creates vertical split
Ctrl-w H # moves it to the left, becoming horizontal
# Reopen current buffer in a new tab:
Ctrl-w T # current window moves to a new tabРаскладка окон
Ctrl-w = выравнивает размеры окон. :ball открывает по окну на буфер — удобно, чтобы увидеть всё сразу. Ctrl-w r/R вращают окна в раскладке. Чтобы сохранить и восстановить полную раскладку окон (включая буферы, фолды и т. д.), используйте :mksession и :source. Каждая вкладка поддерживает свою раскладку окон.
# Equalize window sizes:
Ctrl-w = # equalize height and width
# Stack layouts:
# Vertical splits side by side, horizontal splits stacked
# Example setup:
# :vsplit -> | win1 | win2 |
# :split -> | win1 | win3 |
# | | win2 |
# Cycle through layouts (with plugins like golden-ratio,
# or use built-in rotation):
Ctrl-w r # rotate down/right
Ctrl-w R # rotate up/left
# Distribute buffers across windows:
:ball # one window per buffer (horizontal)
:vertical ball # one window per buffer (vertical)
# Layouts persist within a tab page.
# Save current layout to a session:
:mksession mylayout.vim
# Restore:
:source mylayout.vim
# Tab page = a collection of windows
:tabnew # new tab with one windowЗакрытие окон
:q закрывает окно (и выходит из Vim, если оно последнее). :close (или Ctrl-w c) закрывает окно, но не самое последнее. :only (Ctrl-w o) закрывает все остальные окна. С 'hidden' закрытие окна с изменённым буфером скрывает его вместо принудительного решения о сохранении. :only! принудительно закрывает остальные, даже изменённые.
:q / :quit # close current window (errors if last)
:q! # close without saving
:wq # save and close
:close / Ctrl-w c # close window (won't close last)
:only / Ctrl-w o # close all OTHER windows
:hide # hide current buffer in window (close window)
# Save and close splits:
:xa # save all and exit (close all windows)
:wqa # same as :xa
# Closing a window with modified buffer:
# - :q prompts: "Save changes?"
# - :q! discards
# - :wq saves and closes
# - :hide (with 'hidden' set) keeps buffer in memory
# Close every window except the current:
:only # or Ctrl-w o
# Errors if other windows have unsaved changes:
:only! # force-close other windows
# When you close the last window, Vim exits.
# To prevent accidental exit:
:q! on last window still exits Vim.Вкладки
Создание вкладок
:tabnew/:tabedit создают новую вкладку. vim -p file1 file2 открывает каждый файл в своей вкладке при старте. Каждая вкладка содержит одно или несколько окон — вкладка это раскладка, а не один файл. Ctrl-w T переносит текущее окно в новую вкладку. Вкладки хороши для разделения несвязанных рабочих контекстов (например, по вкладке на область проекта).
:tabnew # new tab with empty buffer
:tabedit file.txt # new tab opening file
:tab split # new tab with current buffer in a split
:tabfind file.txt # new tab, find file in 'path'
# Open multiple files in tabs at startup:
vim -p file1.txt file2.txt file3.txt
# From inside Vim, open files in tabs:
:args *.py | argdo tabe %
# Or one-by-one:
:tabe file1.txt
:tabe file2.txt
# Keyboard shortcut (common mapping):
:nmap <C-t> :tabnew<CR>
# Open current buffer in a new tab (move window):
# Ctrl-w T (move current window to a new tab page)
# Each tab page has its own window layout
# (multiple splits/windows per tab allowed)Навигация по вкладкам
gt/gT переключают вкладки (Normal mode). Ngt переходит сразу к вкладке N (с 1). :tabs перечисляет все вкладки и их окна. Часто маппят Ctrl-Tab/Ctrl-S-Tab или <leader>1/2/3 для быстрого переключения. Вкладки переходят по кругу. Каждая вкладка держит свою раскладку окон (сплиты и т. д.).
:tabnext / :tabn # next tab
:tabprevious / :tabp # previous tab
:tabfirst / :tabr # first tab
:tablast / :tabl # last tab
gt # next tab (Normal mode)
gT # previous tab
3gt # go to tab 3
:tabn 3 # go to tab 3 (Ex command)
# Common mappings (Vim default):
:nmap <C-Tab> :tabnext<CR>
:nmap <C-S-Tab> :tabprevious<CR>
# Or use leader keys:
:nmap <leader>1 1gt
:nmap <leader>2 2gt
:nmap <leader>3 3gt
# Cycle behavior:
# gt at last tab wraps to first
# gT at first tab wraps to last
# To disable wrap:
:set tabpagemax=50 # max tabs (not wrap-related)
# Show all tabs:
:tabs # list tabs with their windowsОперации с вкладками
:tabc закрывает текущую вкладку; :tabo закрывает все остальные. :tabm N перемещает текущую вкладку на позицию N (0 = первая). :tabdo выполняет Ex-команду в каждой вкладке — полезно для глобальных операций по разделённым вкладкам рабочим пространствам. Закрытие вкладки закрывает все её окна; изменённые буферы сохраняются, если задан 'hidden'.
:tabclose / :tabc # close current tab
:tabclose! / :tabc! # force close (discard changes)
:tabonly / :tabo # close all OTHER tabs
:tabonly! / :tabo! # force close others
# Reorder tabs:
:tabmove / :tabm 0 # move current tab to position 0 (first)
:tabm # move to last position
:tabm 2 # move to position 2
:tabm +1 # move right by 1
:tabm -1 # move left by 1
# Quick keyboard reordering (no default, common mapping):
:nmap <leader>tm :tabmove<Space>
# Run a command in every tab:
:tabdo cmd # run cmd in every tab page
# Example:
:tabdo %s/old/new/ge # substitute in every tab's first window
# Each tab can hold multiple windows/splits.
# 'Tabclose' closes all windows in the tab.Раскладка вкладок и несколько окон
Каждая вкладка поддерживает независимую раскладку окон (сплиты, размеры, позиции). В одной вкладке может быть несколько окон. Ctrl-w T переносит окно в новую вкладку. :set showtabline=2 всегда показывает панель вкладок. Вкладки лучше всего использовать как разделители рабочих пространств (например, по вкладке на область проекта), каждая со своей раскладкой.
# Each tab page has its own window layout.
# Create a tab with a 3-window layout:
:tabnew # new tab
:vsplit # split vertically (2 windows)
:split # split horizontally (3 windows)
# Now tab has: [win1] [win2]
# [win3]
# Add a buffer to current tab:
:e file.txt # replaces current window's buffer
# Move a window to its own tab:
Ctrl-w T # window becomes a new tab page
# Show tab line (always):
:set showtabline=2 # 0=never, 1=multi-tab, 2=always
# Tab page-local options:
:setlocal ... # option applies only to current tab's windows
:tabdo setlocal ... # apply across all tabs
# Tab label customization (status line):
:set guitablabel=%t # show filename in GUI tab label
# Common use case: one tab per project area:
# Tab 1: source files
# Tab 2: tests
# Tab 3: docs
# Each with its own split layout.Опции и подписи вкладок
showtabline управляет панелью вкладок (0 — никогда, 1 — только при нескольких вкладках, 2 — всегда). Панель вкладок можно полностью настроить функцией, возвращающей строку формата, — удобно для показа статуса изменений, имён буферов и номеров вкладок. guitablabel/guitabtooltip настраивают GUI Vim. Вкладки нумеруются с 1.
:set showtabline=2 # always show tab bar (0=never, 1=auto)
:set tabpagemax=50 # max tabs creatable
:set hidden # allow switching tabs with unsaved changes
# Custom tab labels (terminal Vim):
:set tabline=%!MyTabLine()
function! MyTabLine()
let s = ''
for i in range(tabpagenr('$'))
let n = i + 1
let s .= '%' . n . 'T'
let s .= (n == tabpagenr() ? '%#TabLineSel#' : '%#TabLine#')
let s .= ' [' . n . '] '
let buflist = tabpagebuflist(n)
let bufname = bufname(buflist[0])
let s .= empty(bufname) ? '[No Name]' : fnamemodify(bufname, ':t')
let s .= ' '
endfor
let s .= '%T%#TabLineFill#'
return s
endfunction
# GUI tab labels:
:set guitablabel=%t # show filename
:set guitabtooltip=%f # show full path on hover
# Quickly switch with number:
:nmap <leader>t :tabs<CR>Команды вкладок
:tabs перечисляет вкладки и их окна. :tabdo выполняет Ex-команду в каждой вкладке. :tab ball открывает каждый буфер в своей вкладке. <C-w>gf открывает файл под курсором в новой вкладке. Используйте вкладки, чтобы группировать связанные файлы (по вкладке на функцию или область). Для операций между вкладками :tabdo — рабочая лошадка, в паре с windo для многовкладочных окон.
:tabs # list all tabs and their windows
:tabdo cmd # run cmd in every tab
:tab ball # open each buffer in its own tab
:tab help subject # open help in a new tab
:tab split # split current window into new tab
# Quickly duplicate a tab's layout:
# (no built-in, but possible with sessions)
# Or manually: create a new tab, re-open buffers
# Open file under cursor in a new tab:
:nmap gf :tabe <cfile><CR>
# (or use the built-in <C-w>gf)
# Common workflow:
# 1. Group related files in tabs
# 2. Use gt/gT to switch
# 3. Use :tabdo for cross-tab operations
# Save all tabs' buffers:
:tabdo windo w # write every window in every tab
# (or simpler)
:wall # write all buffers (across all tabs)
# Close all tabs but keep buffers:
# (no single command — use :tabo + :b then :bd)Конфигурация (.vimrc)
Основы vimrc
$MYVIMRC — путь к вашему vimrc: :edit $MYVIMRC открывает его, :source $MYVIMRC перезагружает после правок. runtimepath управляет тем, где Vim ищет файлы синтаксиса, плагины и т. д. Используйте :verbose set option?, чтобы увидеть, где опция была задана последний раз, — бесценно для отладки конфликтующих плагинов.
# vimrc location:
# Unix: ~/.vimrc (or ~/.vim/vimrc)
# Windows: ~/_vimrc (or ~/vimfiles/vimrc)
# Neovim: ~/.config/nvim/init.vim
# Reload vimrc after editing:
:source $MYVIMRC # or :so %
# Edit vimrc quickly:
:edit $MYVIMRC # $MYVIMRC = path to your vimrc
# Runtime path (where Vim looks for scripts):
:set runtimepath?
# Add a custom path:
:set runtimepath+=~/.vim/custom
# Conditional config (only in terminal Vim):
if !has('gui_running')
set mouse=a
endif
# Per-filetype settings (in vimrc or ftplugin/):
:autocmd FileType python setlocal expandtab shiftwidth=4
# Check where an option was set:
:verbose set tabstop?Базовые настройки
Это частые настройки для удобства. relativenumber + number дают гибридную нумерацию: номера относительно курсора для лёгких прыжков, абсолютный на текущей строке. showmatch мигает парные скобки. wildmenu улучшает дополнение :command меню. scrolloff держит контекст видимым вокруг курсора — никогда не редактируйте на краю экрана.
set nocompatible # Vim mode (not Vi)
set number # show line numbers
set relativenumber # relative line numbers (great for jumps)
set cursorline # highlight current line
set cursorcolumn # highlight current column
set showcmd # show partial commands in status
set showmode # show current mode (insert, visual...)
set showmatch # highlight matching brackets
set wildmenu # better command-line completion
set wildmode=longest:full,full # completion style
set laststatus=2 # always show status line
set ruler # show cursor position
set backspace=indent,eol,start # backspace through everything
set encoding=utf-8 # default encoding
set scrolloff=5 # keep 5 lines above/below cursor
set sidescrolloff=5 # keep 5 cols left/right of cursor
set mouse=a # enable mouse (all modes)Отступы
tabstop управляет тем, сколько колонок отображает символ таба. shiftwidth — величина отступа для <<, >> и autoindent. softtabstop заставляет Backspace удалять правильное число колонок, даже когда expandtab выключен. expandtab превращает табы в пробелы — рекомендуется для единообразия. :retab конвертирует существующие табы и пробелы после изменения настроек.
set autoindent # copy indent from previous line
set smartindent # smart auto-indent for code (basic)
set cindent # C-style indenting (more language-aware)
set expandtab # use spaces instead of tabs
set tabstop=4 # tab key inserts 4-column tabs visually
set shiftwidth=4 # indent/outdent amount (<<, >>, autoindent)
set softtabstop=4 # backspace removes 4 cols even with tabs
set shiftround # round indent to multiple of shiftwidth
set smarttab # tab key respects shiftwidth at line start
# Toggle tabs vs spaces:
:set expandtab! # toggle
:retab # convert existing tabs<->spaces
# Filetype-specific indent:
:filetype plugin indent on
# Then in ~/.vim/ftplugin/python.vim:
# setlocal expandtab shiftwidth=4
# Quick indent/dedent in Normal mode:
>> # indent current line
<< # dedent current line
5>> # indent 5 linesНастройки поиска
ignorecase + smartcase — рекомендуемая комбинация: без учёта регистра, пока в шаблоне нет заглавной буквы. hlsearch подсвечивает все совпадения; incsearch показывает совпадения по мере ввода. Частое маппирование: <leader>h переключает hlsearch, или :noh снимает текущую подсветку. Vim 8.2+ может показывать количество совпадений через shortmess.
set ignorecase # case-insensitive search
set smartcase # case-sensitive if pattern has uppercase
set hlsearch # highlight all matches (hls)
set incsearch # show match as you type (is)
set wrapscan # wrap search around end of file (ws)
# Toggle search highlight:
:nmap <leader>h :set hlsearch!<CR>
# Or clear current highlight:
:nmap <leader>nh :nohlsearch<CR>
# Show search count (Vim 8.2+):
:set shortmess-=S
:set shortmess+=S # search stats in command line
# Search in visual selection:
:vmap * y/\V<C-R>"<CR>
# Use very-magic mode by default (advanced):
# No built-in, but a search mapping can prepend \v
# Improved '*' (don't jump on first press):
:nmap * *N
# Disable highlighting until next search:
:nohlsearchНастройки отображения
wrap + linebreak переносят длинные строки по границам слов (а не посреди слова) для читаемости. list + listchars показывают табы, хвостовые пробелы и неразрывные пробелы. colorcolumn отмечает колонку (например, 80 для ограничения длины строки). termguicolors включает настоящий 24-битный цвет в современных терминалах. splitright/splitbelow управляют тем, где появляются новые сплиты.
set wrap # wrap long lines
set linebreak # wrap at word boundaries (not mid-word)
set textwidth=80 # auto-wrap at 80 chars when typing
set showbreak=+++ # marker for wrapped lines
set list # show invisible chars
set listchars=tab:>-,trail:.,extends:>,precedes:<
set fillchars=fold:-,vert:\| # chars for folds/vsplits
set colorcolumn=80 # highlight column 80
set signcolumn=yes # always show sign column (LSP)
set conceallevel=0 # don't conceal chars
set splitright # new vsplit on the right
set splitbelow # new split below
set termguicolors # 24-bit color (if terminal supports)
set background=dark # or 'light' — adjusts color scheme
# Color scheme:
:colorscheme desert
# Or with a plugin (e.g. vim-colors-solarized):
:colorscheme solarizedМаппинг клавиш
ВСЕГДА используйте варианты *noremap (nnoremap, vnoremap и т. д.) для своих маппингов — они не рекурсивны, что избегает неожиданного поведения. <leader> — настраиваемый префикс (по умолчанию обратный слэш; многие ставят запятую или пробел). <CR> — Enter, <Esc> — escape, <C-x> — Ctrl-X. Маппьте leader-сокращения для частых команд вроде сохранения и выхода.
# Map families:
:map # normal, visual, select, operator-pending
:nmap # normal mode only
:imap # insert mode only
:vmap # visual + select mode
:xmap # visual mode only
:smap # select mode only
:omap # operator-pending mode only
:cmap # command-line mode only
:tmap # terminal mode only
# Non-recursive (RECOMMENDED):
:nnoremap # normal mode, non-recursive
:vnoremap # visual mode, non-recursive
:inoremap # insert mode, non-recursive
:cnoremap # command-line mode, non-recursive
# Examples:
nnoremap <leader>w :w<CR> # save with leader-w
nnoremap <leader>q :q<CR> # quit
inoremap jk <Esc> # Esc with jk
nnoremap <C-h> <C-w>h # window nav
# Leader key (default is \):
:let mapleader = ','
:let maplocalleader = '\\'
# Special keys:
# <CR> <Esc> <Tab> <Space> <C-x> <A-x> <M-x> <F1>-<F12>
# <Up> <Down> <Left> <Right> <leader> <localleader>Плагины (vim-plug)
Основы vim-plug
vim-plug — самый популярный современный менеджер плагинов. Объявляйте плагины между call plug#begin и plug#end. Каждая строка Plug задаёт GitHub-репозиторий (user/repo). После добавления плагинов :source $MYVIMRC, затем :PlugInstall скачает их. Можно закрепить тег, ветку или коммит ради стабильности. Плагины ставятся в каталог 'plugged'.
# Installation (Unix):
# curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
# https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# In vimrc:
call plug#begin('~/.vim/plugged')
Plug 'junegunn/fzf.vim' " GitHub repo: user/repo
Plug 'tpope/vim-surround' " another plugin
Plug 'morhetz/gruvbox' " colorscheme
Plug 'preservim/nerdtree' " file explorer
call plug#end()
# After editing vimrc:
:source $MYVIMRC # or restart Vim
:PlugInstall # install all declared plugins
# Plugin directory structure:
# ~/.vim/plugged/<plugin-name>/
# Pin to a specific commit/tag/branch:
Plug 'tpope/vim-fugitive', { 'tag': 'v3.0' }
Plug 'user/repo', { 'branch': 'dev' }
Plug 'user/repo', { 'commit': 'abc123' }Команды управления плагинами
:PlugInstall ставит новые плагины, :PlugUpdate обновляет все, :PlugClean удаляет убранные из конфига, :PlugStatus показывает состояние. Хук 'do' выполняет команду после установки — полезно для плагинов, которым нужно собрать или установить бинарники. Опции 'on'/'for' включают ленивую загрузку (загружать только по команде или типу файла) — улучшает время старта.
:PlugInstall # install newly added plugins
:PlugUpdate # update all plugins
:PlugClean # remove plugins no longer in vimrc
:PlugStatus # show plugin status (loaded, errored)
:PlugUpgrade # update vim-plug itself
:PlugDiff # review changes from last update
:PlugSnapshot # generate a snapshot of plugin versions
# Post-install hooks:
Plug 'user/repo', { 'do': ':GoInstallBinaries' }
Plug 'user/repo', { 'do': './install.sh' }
Plug 'user/repo', { 'do': 'npm install' }
# Lazy loading (load only when needed):
Plug 'user/repo', { 'on': 'CommandName' } " on command
Plug 'user/repo', { 'for': 'python' } " for filetype
Plug 'user/repo', { 'on': ['Cmd1', 'Cmd2'] }
# Frozen plugin (don't update):
Plug 'user/repo', { 'frozen': 1 }
# Disable a plugin temporarily:
# (no built-in, but comment out the Plug line and :PlugClean)Частые необходимые плагины
Частые essentials: fzf для нечёткого поиска файлов, буферов и текста (намного быстрее :find), vim-surround для правки кавычек, скобок и тегов вокруг текста, vim-fugitive для интеграции с Git, vim-commentary для быстрого комментирования (оператор gc), NERDTree для бокового файлового дерева, vim-airline для более красивой строки статуса и хорошая цветовая схема вроде gruvbox.
" Fuzzy finder (requires fzf binary):
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
" :Files :GFiles :Buffers :Rg
" Surround (cs/ds/ys for surroundings):
Plug 'tpope/vim-surround'
" cs"' change " to '
" ds" delete surrounding "
" ysiw) surround word with ()
" Fugitive (Git integration):
Plug 'tpope/vim-fugitive'
" :G :Gstatus :Gcommit :Gpush
" Commentary (gc to toggle comments):
Plug 'tpope/vim-commentary'
" gcc comment line
" gc{motion} comment motion
" NERDTree (file explorer sidebar):
Plug 'preservim/nerdtree'
" :NERDTree :NERDTreeToggle
" Airline (status line):
Plug 'vim-airline/vim-airline'
" Gruvbox (colorscheme):
Plug 'morhetz/gruvbox'Конфигурация плагинов
Используйте 'on'/'for' для ленивой загрузки плагинов — они загружаются только при срабатывании триггера, улучшая время старта. Конфигурация конкретного плагина обычно использует переменные g:pluginname_var, заданные в vimrc, ИЛИ файлы в ~/.vim/after/plugin/. Хук 'do' выполняется после установки и обновления для шагов сборки. Установка g:loaded_pluginname=1 в vimrc полностью предотвращает загрузку плагина.
" Lazy load on command:
Plug 'tpope/vim-fugitive', { 'on': 'Git' }
" Lazy load on filetype:
Plug 'fatih/vim-go', { 'for': 'go' }
" Multiple triggers:
Plug 'junegunn/fzf.vim', { 'on': ['Files', 'Buffers', 'Rg'] }
" Post-install hook:
Plug 'dense-analysis/ale', { 'do': 'npm install' }
" Configuration AFTER plugin loads:
Plug 'preservim/nerdtree'
let g:NERDTreeShowHidden = 1
let g:NERDTreeWinSize = 30
nmap <leader>n :NERDTreeToggle<CR>
" Configuration in AFTER/plugin-name.vim:
" (alternative to setting g: vars in vimrc)
" ~/.vim/after/plugin/nerdtree.vim:
" let g:NERDTreeShowHidden = 1
" Disable plugin entirely:
let g:loaded_nerdtree = 1 " prevent loadingЗагрузка плагинов и runtime
Vim подключает файлы plugin/*.vim при старте в порядке каталогов, затем after/plugin/*.vim последними (для переопределений). :scriptnames перечисляет всё подключённое — бесценно для отладки. :verbose map <key> показывает, где был задан маппинг; :verbose set option? делает то же для опций. Файлы autoload/ загружаются лениво при первом вызове их функций.
" Plugin loading sequence:
" 1. Vim starts, reads vimrc
" 2. plug#begin / plug#end registers plugins
" 3. Runtime path is updated to include plugin dirs
" 4. plugin/*.vim files are sourced (in directory order)
" 5. after/plugin/*.vim files are sourced last
" Check if a plugin is loaded:
:echo exists('g:loaded_fugitive')
:scriptnames # list all sourced scripts in order
" Manually source a plugin:
:source ~/.vim/plugged/foo/plugin/foo.vim
" Find where a mapping was defined:
:verbose map <leader>w
" Find where an option was set:
:verbose set formatprg?
" Plugin runtime files:
" plugin/ - loaded at startup
" ftplugin/ - loaded for specific filetypes
" syntax/ - syntax highlighting
" indent/ - indentation rules
" autoload/ - lazily-loaded functions
" after/ - sourced last (overrides)
" Helptags for plugin docs:
:Helptags (vim-plug generates these on install)Альтернативные менеджеры плагинов
Помимо vim-plug есть Vundle (похожий API, меньше возможностей), Pathogen (простейший — просто добавляет каталоги bundle в runtimepath), Dein.vim (быстрый, с фокусом на ленивую загрузку) и встроенные пакеты Vim 8+ (менеджер не нужен: кладите плагины в pack/<name>/start/). Для Neovim популярен Packer (на Lua). Встроенные пакеты отлично подходят минималистам.
" 1. Vundle (older, similar to vim-plug):
" set rtp+=~/.vim/bundle/Vundle.vim
" call vundle#begin()
" Plugin 'tpope/vim-surround'
" call vundle#end()
" 2. Pathogen (just adds dirs to runtimepath):
" Execute:
" git clone https://github.com/tpope/vim-pathogen ~/.vim/bundle
" In vimrc:
" execute pathogen#infect()
" Then clone plugins into ~/.vim/bundle/
" 3. Dein.vim (modern, lazy-loading focused):
" set runtimepath+=~/.cache/dein/repos/github.com/Shougo/dein.vim
" if dein#load_state('~/.cache/dein')
" call dein#begin('~/.cache/dein')
" call dein#add('tpope/vim-surround')
" call dein#end()
" call dein#save_state()
" endif
" 4. Vim 8+ built-in packages (NO plugin manager needed):
" Place plugins in:
" ~/.vim/pack/<name>/start/<plugin>/ " loaded at startup
" ~/.vim/pack/<name>/opt/<plugin>/ " loaded on demand
" Load an opt plugin: :packadd <plugin>
" 5. Packer (Neovim Lua):
" require('packer').startup(function()
" use 'tpope/vim-surround'
" end)Продвинутое движение
Поиск символа (f/F/t/T)
f/F находят следующий или предыдущий символ в текущей строке (курсор встаёт на него); t/T двигают до позиции прямо перед ним или после. ; повторяет последний f/F/t/T в том же направлении, , — в обратном. Комбинируйте с операторами: dt, удаляет до (не включая) следующей запятой, df. удаляет включая следующую точку. Быстро и точно для навигации внутри строки.
f{x} # find next char 'x' on line (cursor ON x)
F{x} # find previous char 'x' (cursor ON x)
t{x} # till next char 'x' (cursor BEFORE x)
T{x} # till previous char 'x' (cursor AFTER x)
; # repeat last f/F/t/T (same direction)
, # repeat last f/F/t/T (opposite direction)
# Examples (cursor on 'a' in "hello world abc"):
# fw -> cursor on 'w' (world)
# tw -> cursor on space before 'w'
# Fo -> cursor on 'o' (hello) - backwards
# ; -> next 'w'... or next match of last
# Combined with operators:
dt, # delete up to (not including) next ','
df. # delete up to AND including next '.'
ct; # change up to next ';'
yt: # yank up to next ':'
# Find on a long line (no built-in multi-line f):
# Use :s or search for multi-line patterns.
# Set 'hlsearch' to highlight f/F/t/T targets:
:set hlsearch " doesn't highlight f, but / does.Движение по предложениям и абзацам
( и ) двигаются по предложениям (предложения заканчиваются на . ! ? и пробел); { и } — по абзацам (разделённым пустыми строками). Для перенесённых строк gj/gk/g0/g$ работают с визуальными экранными строками, а j/k/0/$ — с логическими: это важно при 'wrap'. Комбинируйте ( ) { } с операторами: das удаляет предложение, yap копирует абзац.
( # previous sentence start
) # next sentence start
{ # previous paragraph start (blank-line delimited)
} # next paragraph start
# Sentence boundaries: ends with . ! ? followed by
# whitespace or end of paragraph.
# Paragraph: block of lines separated by blank lines.
# Examples:
# Hello world. This is a sentence.
# ^ ^ ^
# ( ) ( moves to sentence starts
# Combine with operators:
das # delete a sentence
cis # change inside sentence
yap # yank a paragraph
dip # delete inside paragraph
# Move by visual line (with 'wrap' on):
gj # down one screen line (wrap-aware)
gk # up one screen line
g0 # start of screen line
g$ # end of screen line
g_ # last non-blank of screen line
# These respect wrapping where j/k don't.Парные скобки (%)
% прыгает между парными скобками (по умолчанию: (), [], {}). Он также работает с #if/#endif и /* */, если 'matchpairs' настроен соответственно. Комбинируйте с операторами: d% удаляет от курсора до пары, v% выделяет её. [( [{ ]) ]} прыгают к непарным скобкам — полезно, чтобы найти охватывающий блок функции или класса.
% # jump to matching bracket: ( ) [ ] { }
# also works on #if/#endif, /* */ with matching pairs
# In Normal mode:
% # if cursor on (, jumps to matching )
% # if cursor on ), jumps to matching (
# Combine with operators:
d% # delete from cursor to matching bracket
c% # change from cursor to matching bracket
y% # yank from cursor to matching bracket
v% # visually select from cursor to matching bracket
# Extend matching to other pairs:
:set matchpairs+=<:>
:set matchpairs+=«:»
# Default: (:),[:],{:}
# Move to enclosing bracket:
# [( # back to unmatched (
# ]) # forward to unmatched )
# [{ # back to unmatched {
# ]} # forward to unmatched }
# [} / ]{ similar for braces
# Example: jump to outer function's opening brace:
[{ " previous unmatched {Движение по экрану
H/M/L прыгают в верх, середину и низ видимого экрана. Ctrl-f/b прокручивают целыми страницами; Ctrl-d/u — половинами (меньше дезориентирует); Ctrl-e/y прокручивают одну строку, не двигая курсор. zz/zt/zb переставляют строку с курсором в середину, верх или низ экрана — важно для сохранения контекста. 'scrolloff' гарантирует, что курсор не доходит до края экрана.
H # top of screen (High) — first non-blank
M # middle of screen
L # bottom of screen (Low) — first non-blank
N H # Nth line from top (e.g. 5H = 5 lines from top)
N L # Nth line from bottom
# Scrolling:
Ctrl-f # forward (down) full screen
Ctrl-b # backward (up) full screen
Ctrl-d # down half screen
Ctrl-u # up half screen
Ctrl-e # scroll down 1 line (cursor stays)
Ctrl-y # scroll up 1 line (cursor stays)
# Reposition cursor on screen:
zz # cursor line to middle of screen
zt # cursor line to top of screen
zb # cursor line to bottom of screen
z. # cursor to middle, first non-blank
z+ # cursor to bottom, scroll up (like zb but accepts count)
# Keep cursor off edges:
:set scrolloff=5 # always 5 lines above/below cursor
:set sidescrolloff=5 # 5 cols left/right of cursorScroll bind и синхронизация
:set scrollbind синхронизирует прокрутку между окнами — задайте его в каждом окне, которое хотите синхронизировать. :vimdiff открывает два файла в режиме diff со scrollbind, подсветкой различий и [c/]c для навигации по ханкам. do (diff obtain) забирает изменения из другого окна, dp (diff put) отправляет их. Отлично для сравнения версий файла.
# Bind windows to scroll together:
:set scrollbind # current window syncs scroll
:set syncbind # force immediate sync
:scrollbind # same as :set scrollbind
# In each window you want synced:
# :set scrollbind
# Unbind:
:set noscrollbind
# Common use: diff two files side by side
:vimdiff file1 file2 # opens both, scrollbound, diff highlighted
:diffthis # mark current window as a diff
:diffoff # turn off diff mode for current window
:diffupdate # refresh diff highlighting
# Vertical diff split:
:vert diffsplit file2.txt
# In diff mode:
[c # previous diff hunk
]c # next diff hunk
do # diff obtain (pull from other window)
dp # diff put (push to other window)
# Bind but at different starting positions:
# Set scrollbind AFTER scrolling to desired positions.Переход к позициям
Много способов позиционировать курсор: :N к строке N, N% к проценту, `.`/`"`/[`]/`</`> для специальных меток (последнее изменение, последний выход, последний yank, последнее выделение). Ctrl-o/Ctrl-i навигируют по jumplist. `" восстанавливает позицию при последнем закрытии файла, — в сочетании с настройкой viminfo это сохраняется между сессиями.
:N # go to line N (e.g. :42)
Ng / N G # go to line N (e.g. 42G or 42gg)
gg # first line
G # last line
N% # go to N% of file (e.g. 50% = middle)
:-N # N lines before current (e.g. :-5)
:+N # N lines after current (e.g. :+10)
# Marks and jumps:
\`. # position of last change in this buffer
\`" # position when file was last closed
\`[ # start of last yanked/changed region
\`] # end of last yanked/changed region
\`< # start of last visual selection
\`> # end of last visual selection
\`^ # last insert position (gi goes here + insert)
# Recent jumps:
Ctrl-o # back in jumplist
Ctrl-i # forward in jumplist
\`' # position before last jump (where you came from)
# File position on save:
:set viminfo^=% # remember buffer positions across sessions
# Cursor hold (no movement for 'updatetime' ms):
# CursorHold event triggers (advanced)Режим командной строки
Команды диапазонов
Диапазоны задают, на какие строки действует команда. :% — весь файл (1,$). . — текущая строка, $ — последняя. '<,'> — последнее визуальное выделение (подставляется автоматически при нажатии : в визуальном режиме). 'a,'b — от метки a до метки b. Можно использовать шаблоны поиска как границы диапазона: :/foo/,/bar/d удалит от строки с foo до строки с bar.
# Range syntax: :{start},{end}command
# Range forms:
:% # whole file (1,$)
:1,10 # lines 1-10
:.,$ # current line to end of file
:1,. # first line to current
:'a,'b # from mark a to mark b
:'<,'> # last visual selection
:. # current line only
:N # line N only
:.,+5 # current line + 5 below
:.,-2 # current line - 2 above
# Examples:
:1,10d # delete lines 1-10
:%s/old/new/g # substitute whole file
:'<,'>s/old/new/g # substitute visual selection
:.,$j # join from current to end into one line
:5,10y a # yank lines 5-10 into register a
:g/pattern/m$ # move matching lines to end of file
# Search-based range:
:/start/,/end/d # delete from 'start' to 'end' patternsКоманды файлов
:w сохраняет, :e открывает новый файл, :r вставляет содержимое другого файла (или вывод shell-команды через :r !cmd). :saveas сохраняет и переключается на новый файл. :e! перезагружает файл, отбрасывая изменения. ++enc/++ff явно задают кодировку и концы строк — полезно для конвертации файлов. :browse e открывает GUI-диалог выбора файла (в GUI Vim).
:w / :write # save current file
:w file.txt # save as new file
:w! file.txt # overwrite existing file
:w >> file.txt # append to file
:saveas / :sav file # save as new file and switch to it
:e / :edit file # open file (replace current buffer)
:e! # reload current file (discard changes)
:e # # edit alternate file
:r / :read file # insert file below cursor
:r !command # insert command output below cursor
:0r !date # insert date at top of file
# Multiple files:
:wa / :wall # write all buffers
:xa / :xall # write all and quit
:qa! # quit all without saving
# Browse file system:
:browse e # GUI file open dialog
:Explore # Netrw file browser
# File encoding:
:w ++enc=utf-8 # save as UTF-8
:e ++enc=latin1 file # open with specific encoding
# File format (line endings):
:w ++ff=unix # save as Unix line endingsКоманды буферов и окон
У всех операций с буферами, окнами и вкладками есть Ex-формы. :b переключает буферы, :sp/:vs делят окна, :tabnew создаёт вкладки. Семейство :*do (bufdo, argdo, tabdo, windo, cdo) выполняет команду по многим целям — крайне мощно для пакетных операций. :ls показывает буферы; :tabs — вкладки; :args — arglist.
# Buffer commands:
:b N / :buffer N # switch to buffer N
:b name # switch by name (tab-completes)
:bd / :bdelete # delete buffer
:bw / :bwipeout # wipe buffer (clears marks)
:ls / :buffers # list buffers
:bn / :bp # next / previous buffer
:b# # alternate buffer
# Window commands:
:sp / :split # horizontal split
:vs / :vsplit # vertical split
:new # split with empty buffer
:close # close window
:only # close all other windows
:qa / :qa! # quit all windows
# Tab page commands:
:tabnew # new tab
:tabe file # new tab with file
:tabc # close tab
:tabo # close other tabs
:tabs # list tabs
:tabn / :tabp # next / previous tab
# Argument list commands:
:args # show arg list
:n / :next # next arg file
:prev # previous arg file
:argdo cmd # run cmd on each arg fileНастройка опций
:set переключает булевы опции через !, задаёт значения через =, добавляет и убирает через +=/-=, сбрасывает к значениям по умолчанию через &. :set option? показывает текущее значение. :setlocal задаёт локальное для буфера или окна значение (не влияет на другие буферы). :set без аргументов перечисляет все изменённые опции; :set all показывает всё. Tab дополняет имена опций.
:set option # turn boolean option on
:set nooption # turn boolean option off
:set option! # toggle boolean
:set option? # show current value
:set option=value # set value
:set option+=value # append to value
:set option-=value # remove from value
:set option& # reset to default
:set all # show all options
:set # show changed options
# Local vs global:
:setlocal option # buffer/window-local only
:setglobal option # global value
# Examples:
:set number # show line numbers
:set nonumber # hide line numbers
:set number! # toggle
:set tabstop=4 # set tabstop to 4
:set formatoptions+=r # add 'r' to formatoptions
:set ignorecase& # reset ignorecase to default
# View all set options:
:set # shows only non-default values
# Find option with substring:
:set ic<tab> # tab-complete (ignorecase)Команды маппинга
Используйте варианты *noremap для своих маппингов — они не рекурсивны, предотвращая неожиданное поведение. <leader> — настраиваемый префикс (по умолчанию обратный слэш; многие ставят пробел или запятую). <buffer> делает маппинг локальным для текущего буфера. Специальные клавиши используют <notation> вроде <CR>, <Esc>, <C-x> (Ctrl-X), <A-x> (Alt-X).
:map <key> <action> # generic map (most modes)
:nmap <key> <action> # normal mode
:imap <key> <action> # insert mode
:vmap <key> <action> # visual mode
:xmap <key> <action> # visual mode only
:smap <key> <action> # select mode
:omap <key> <action> # operator-pending mode
:cmap <key> <action> # command-line mode
:tmap <key> <action> # terminal mode
# Non-recursive (RECOMMENDED for personal mappings):
:nnoremap <key> <action> # normal mode
:vnoremap <key> <action> # visual mode
:inoremap <key> <action> # insert mode
:onoremap <key> <action> # operator-pending
:cnoremap <key> <action> # command-line
:tnoremap <key> <action> # terminal
# Buffer-local mappings:
:nnoremap <buffer> <key> <action>
# Clear a mapping:
:nunmap <key> # or :nmapclear (clears all normal maps)
# Special keys in mappings:
# <CR> <Esc> <Tab> <Space> <BS> <C-x> <A-x> <M-x>
# <F1>-<F12> <Up> <Down> <Left> <Right>
# <leader> <localleader> <C-r> <C-w>
:let mapleader = ' '
:let maplocalleader = '\\'Полезные Ex-команды
:!cmd выполняет shell-команду; :r !cmd вставляет её вывод в буфер. :sort сортирует строки (u — уникальные, n — числовые, ! — обратный порядок). :retab конвертирует между табами и пробелами. :normal выполняет normal-нажатия как Ex: добавьте ! чтобы игнорировать свои маппинги. :%!cmd пропускает весь файл через внешнюю команду и заменяет его выводом.
:!command # run shell command
:r !command # insert command output below cursor
:!! # repeat last :! command
:sh # open a shell (exit to return)
:terminal / :term # open terminal in a window
:read file # insert file contents below cursor
:sort # sort selected lines (visual mode)
:sort u # sort and remove duplicates
:sort n # numeric sort
:sort! # reverse sort
:retab # convert tabs to spaces (and vice versa)
:retab! # also convert in strings
:normal {cmds} # run normal-mode commands
:normal! {cmds} # ignore mappings (use raw keys)
# Execute Ex commands from a register:
:@a # run Ex commands in register 'a'
:@@ # repeat last :@
# Range + command examples:
:5,20s/old/new/g # substitute in lines 5-20
:%!sort # pipe whole file through sort
:'<,'>!column -t # format visual selection as columns
# Help:
:help :command # help on a specific commandОсновы Vimscript
Переменные
Vimscript использует let для присваивания и unlet для удаления. У переменных есть области, обозначаемые префиксами: g: (глобальная), b: (буфер), w: (окно), t: (вкладка), s: (скрипт), l: (локальная для функции), v: (встроенная). const создаёт неизменяемые значения (Vim 8+). exists() проверяет, определена ли переменная. Vim 8.2+ поддерживает интерполяцию строк $"...{expr}...".
let var = value # assignment
let var = "hello" # string
let var = 42 # number
let var = 3.14 # float
let var = [1, 2, 3] # list
let var = {"key": "val"} # dictionary
unlet var # delete a variable
# Variable scopes (prefix with letter + colon):
let g:global_var = 1 # global (everywhere)
let b:buffer_var = 1 # buffer-local
let w:window_var = 1 # window-local
let t:tab_var = 1 # tab-local
let s:script_var = 1 # script-local (this file only)
let l:local_var = 1 # function-local
let v:count # built-in Vim variable
# Constants (Vim 8+):
const PI = 3.14159
let g:CONFIG = #{name: "vim"} # locked dictionary
# Check if a variable exists:
if exists('var')
if exists('g:plugin_var')
# String interpolation (Vim 8.2+):
let name = "World"
echo $"Hello, {name}!"Функции
function! Name(args) ... endfunction определяет функцию — ! разрешает переопределение. a: даёт доступ к аргументам; a:000 — список вариативных аргументов. Аргументы по умолчанию (Vim 8+) задаются как =value. Лямбды (Vim 8+) — {args -> expr}. function('Name') возвращает funcref, который можно передавать. :call вызывает функцию ради побочных эффектов.
# Define a function:
function! MyFunc(arg1, arg2)
echo a:arg1 . ' ' . a:arg2
return a:arg1 + a:arg2
endfunction
# The ! in function! overrides an existing function
# (without ! Vim errors if function already exists).
# Call a function:
call MyFunc("hello", "world")
let result = MyFunc(1, 2)
# Variadic arguments (...):
function! Sum(...)
let total = 0
for i in a:000
let total += i
endfor
return total
endfunction
# Default arguments (Vim 8+):
function! Greet(name, greeting="Hello")
echo a:greeting . ', ' . a:name
endfunction
# Lambda / anonymous functions (Vim 8+):
let Square = {x -> x * x}
echo Square(5) " 25
# Function as a value:
let Fn = function('MyFunc')
echo Fn(1, 2)Условия и циклы
if/elseif/else/endif для условий. for перебирает список (range(N) генерирует 0..N-1) и может распаковывать пары [key, val] из items(). while/endwhile для циклов с условием. break/continue работают как ожидается. Частые проверки: has() для возможностей, exists() для переменных и команд, filereadable() для файлов, empty() для пустых значений, type() для сравнения типов.
# Conditionals:
if x > 10
echo "big"
elseif x > 5
echo "medium"
else
echo "small"
endif
# Ternary:
let result = (x > 0) ? "positive" : "non-positive"
# Loops:
for i in range(5) # 0,1,2,3,4
echo i
endfor
for [key, val] in items({'a': 1, 'b': 2})
echo key . '=' . val
endfor
while x > 0
let x -= 1
endwhile
# Loop control:
break # exit loop
continue # skip to next iteration
# Match-related conditionals:
if has('python3') # feature check
if exists(':Command') # command exists
if filereadable('file') # file is readable
if empty(var) # variable is empty
if type(var) == type([]) # type checkСтроки
. конкатенирует строки. Vim 8.2+ добавляет интерполяцию $"...{expr}...". len/strlen дают длину в байтах; strcharlen — число символов (важно для многобайтовых). split/join преобразуют между строками и списками. substitute() — программная :s. matchstr() извлекает совпадение regex. =~ — оператор проверки regex.
# String concatenation:
let s = "Hello" . " " . "World"
# String interpolation (Vim 8.2+):
let name = "Vim"
echo $"Welcome to {name}!"
# Common functions:
len("hello") # 5
strlen("hello") # 5 (byte length)
strcharlen("hello") # 5 (char length)
tolower("HELLO") # "hello"
toupper("hello") # "HELLO"
strpart("hello", 1, 3) # "ell" (substring)
matchstr("foo123bar", '\d\+') # "123"
substitute("foo", 'o', '0', 'g') # "f00"
split("a,b,c", ',') # ['a', 'b', 'c']
join(['a', 'b', 'c'], '-') # "a-b-c"
trim(" hello ") # "hello"
# printf-style formatting:
printf("%d + %d = %d", 1, 2, 3) # "1 + 2 = 3"
printf("%05.2f", 3.14159) # "03.14"
# Regex matching:
if "hello" =~ '^h'
echo "starts with h"
endifСписки и словари
Списки упорядочены (как массивы); словари — отображения ключ-значение. Срез списка задаётся [start:end]. add/insert/remove меняют список на месте. sort/reverse тоже мутируют. Для словарей работают и .key, и ["key"]; keys()/values()/items() возвращают списки. has_key() проверяет наличие. #{...} (Vim 8+) — более чистый литерал словаря, не требующий кавычек у ключей.
# Lists (like arrays):
let nums = [1, 2, 3, 4, 5]
echo nums[0] # 1 (first)
echo nums[-1] # 5 (last)
echo nums[1:3] # [2, 3, 4] (slice)
# List operations:
call add(nums, 6) # append 6
call insert(nums, 0, 0) # insert 0 at index 0
call remove(nums, 0) # remove index 0
echo len(nums) # length
call sort(nums) # sort in place
call reverse(nums) # reverse in place
call extend(nums, [7, 8]) # concatenate
# Iterate:
for n in nums
echo n
endfor
# Dictionaries (like hash maps / objects):
let d = {"name": "Vim", "version": 9}
echo d.name # "Vim"
echo d["version"] # 9
let d.lang = "Vimscript" # add a key
call remove(d, "version") # remove a key
echo keys(d) # ['name', 'lang']
echo values(d) # ['Vim', 'Vimscript']
echo items(d) # [['name', 'Vim'], ['lang', 'Vimscript']]
echo has_key(d, "name") # 1 (true)
# Dictionary literal (Vim 8+, cleaner):
let d2 = #{key: "value", count: 42}Autocmd и свои команды
autocmd выполняет код на события Vim (BufRead, BufWritePre, FileType, VimEnter, CursorMoved и т. д.). Всегда оборачивайте autocmd в augroup с autocmd!, чтобы очищать старые определения при перезагрузке, — это предотвращает дублирование. Свои команды задаются :command! -nargs=N -range -bang Name action. <args>, <line1>, <line2>, <bang> дают доступ к вводу пользователя в определении команды.
# Autocmds: run code on events
:autocmd BufWritePre *.md :%s/\s\+$//e " trim trailing whitespace
# Group autocmds (recommended - prevents duplicates on reload):
augroup markdown_settings
autocmd!
autocmd BufRead,BufNewFile *.md setlocal spell
autocmd FileType markdown setlocal textwidth=80
autocmd BufWritePre *.md :%s/\s\+$//e
augroup END
# Common events:
# BufReadPost - after loading a file
# BufWritePre - before saving
# BufWritePost - after saving
# FileType - when filetype is set
# VimEnter - after Vim startup
# CursorMoved - cursor moved in normal mode
# InsertEnter - entering insert mode
# Custom Ex commands:
command! -nargs=1 Grep !grep <args> %
command! -range Sum echo <line1> + <line2>
command! -bang Q quit<bang>
# Use them:
:Grep pattern
:Sum
# Show all autocmds:
:autocmd
# Show autocmds for a specific event:
:autocmd BufWritePreСвязанные сниппеты Vim
Copy-paste ready code for common tasks.
Буферы, окна и вкладки
Редактирование нескольких файлов с буферами, разделёнными окнами и вкладками.
Поиск и замена
Поиск текста через / и замена через :s с regex и диапазонами.
Регистры (мульти-буфер обмена)
Хранение yank/delete в именованных р егистрах и вставка из них.
Метки (закладки)
Возврат к позициям в файле или между файлами через marks.
Макросы (запись нажатий)
Запись последовательности нажатий и воспроизведение для автоматизации повторяющихся правок.
Сворачивание (скрытие кода)
Скрытие регионов кода для фокуса на структуре через методы fold.
Менеджеры плагинов и экосистема
Установка, настройка и обнаружение плагинов через vim-plug / packer / lazy.
LSP, Completion и диагностика
Получение IDE-возможностей (автодополнение, go-to-definition, диагностика) через LSP.
Was this helpful?