Primeiros Passos
Modos e Movimento Básico
Vim é modal — modos diferentes servem a propósitos diferentes. Esc retorna ao modo Normal de qualquer outro modo. As teclas hjkl mantêm suas mãos na fileira central. w/b movem por palavra, 0/$ vão aos limites da linha, gg/G saltam ao início/fim do arquivo, :N salta à linha 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 42Sair e Salvar
ZZ e ZQ são as formas mais rápidas de sair — não exigem alcançar os dois-pontos. :x só grava se o arquivo mudou (preserva o mtime), diferentemente de :wq, que sempre grava. :w! sobrescreve flags de somente leitura se as permissões do filesystem permitirem. Use :qa! para abandonar múltiplos buffers modificados.
: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)Sistema de Ajuda
A ajuda do Vim é abrangente e hiperligada. Ctrl-] segue uma tag (link) e Ctrl-T volta. Notação de ajuda: i_CTRL-N significa Ctrl-N no modo insert, 'number' (com aspas) significa uma opção. :helpgrep busca em cada um dos arquivos de ajuda de uma vez — use :cn/:cp para navegar pelos resultados. K invoca o man para a palavra sob o cursor (configurável via '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 directoryMovimento por Palavra e Caractere
Movimentos minúsculos (w/b/e) tratam pontuação como separador de palavra — úteis para código. Movimentos maiúsculos (W/B/E) tratam só espaço em branco como separador — úteis para prosa. e/E movem ao fim da próxima palavra; ge/gE ao fim da palavra anterior (pouco usados, mas práticos).
# 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)Movimento por Linha
0 e $ vão ao início/fim absoluto da linha (incluindo espaços em branco). ^ e g_ pulam espaços iniciais/finais — geralmente o que você quer. Com 'wrap' ativado, g0/g$ operam nas linhas da tela enquanto 0/$ operam nas linhas lógicas. | salta a um número de coluna específico.
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]Movimento por Arquivo e Tela
H/M/L saltam dentro da tela visível. Ctrl-d/u rola meia página (menos desorientador que a página inteira Ctrl-f/b). zz/zt/zb rolam a linha atual para o meio/topo/fundo da tela sem mover o cursor — extremamente útil para manter contexto enquanto edita. N% salta a uma porcentagem do arquivo.
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 bottomInserindo Texto
Insert Básico (i, I)
i/I inserem antes do cursor / no início da linha. a/A inserem depois do cursor / no fim da linha. gi retorna à última posição de insert (marca '^) — prático quando você dá Esc para fazer algo e quer continuar digitando. gI vai à coluna 1 absoluta, ignorando espaços iniciais.
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.Abrir Novas Linhas (o, O)
o e O abrem uma nova linha abaixo/acima do cursor e entram no modo insert. São a forma mais rápida de adicionar uma linha — sem precisar posicionar o cursor no fim da linha. A indentação é copiada automaticamente das linhas ao redor (controlada por '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 threeComandos de Mudança (c, C, s, S)
c{movimento} deleta o alvo do movimento e entra no modo insert — o comando de edição mais flexível. C é c$ (mudar até o fim da linha), S é cc (mudar a linha inteira). s deleta um caractere e entra no insert; combine com contagens como 3s. ciw/caw usam objetos de texto (veja a seção dedicada).
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)Modo Replace (r, R, gr)
r substitui um único caractere e volta ao modo Normal imediatamente (sem mudança de modo). R entra no modo Replace, em que digitar sobrescreve caracteres — Backspace os restaura, diferentemente do modo Insert, que apenas deleta. Use gr/gR (replace virtual) ao trabalhar com tabs — preserva o alinhamento das tabs em vez de deslocar o texto.
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)Inserts Especiais
:r !cmd insere a saída de um comando shell no buffer — ótimo para colar saídas de comando, datas, listas de arquivos. No modo insert, Ctrl-r seguido do nome de um registro insere aquele registro; Ctrl-r = avalia uma expressão Vimscript e insere o resultado. Ctrl-k insere um digrafo (caractere especial) digitando dois caracteres 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 digraphsAtalhos do Modo Insert
Ctrl-h/w/u funcionam como Backspace/Deletar-palavra/Deletar-linha dentro do modo insert. Ctrl-t/Ctrl-d ajustam a indentação sem sair do insert — inestimável para código. Ctrl-n/Ctrl-p completam palavras-chave a partir de buffers e tags. Ctrl-o roda um único comando Normal e volta ao insert (ex.: Ctrl-o zz para recentralizar). Ctrl-g u quebra a cadeia de undo, para que um insert longo possa ser desfeito em partes.
# 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 insertingComandos de Edição (Delete/Yank/Paste)
Comandos de Delete
d{movimento} é o operador universal de delete — combine com qualquer movimento. dd deleta a linha inteira. x é um atalho para dl (deletar caractere). O texto deletado vai para o registro sem nome (e para o registro 1). Use d com objetos de texto (ciw, dib) para edições poderosas. J junta a próxima linha à atual com um único espaço.
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 (Copiar)
y{movimento} copia texto sem deletar. yy copia a linha. Diferente de d (que tem x como atalho), y não tem atalho de caractere único — você precisa de um movimento. O yank sempre atualiza o registro 0, útil para distinguir dos deletes. Use objetos de texto: ya( copia ao redor dos parênteses, yi" copia dentro das aspas.
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 (Colar)
p cola depois do cursor (ou abaixo da linha, para dados por linha); P cola antes. gp/gP movem o cursor ao fim do texto colado — útil ao encadear operações. ]p/[p reindentam as linhas coladas para casar com o entorno. O registro de clipboard (+) compartilha com a área de transferência do sistema se 'clipboard' estiver configurado direito.
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.Mudando a Caixa
~ alterna um único caractere e avança. g~/gu/gU são operadores que funcionam com movimentos ou objetos de texto. No modo visual, U/u/~ agem sobre a seleção. Use gUiw para colocar a palavra atual em maiúsculas, gUU para a linha inteira. São não destrutivos — só a caixa muda.
~ # 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 -> HELLOJuntando e Dividindo Linhas
J junta linhas com um único espaço; gJ junta sem inserir nada. :join funciona num intervalo. gq é o operador de formatação — quebra linhas em 'textwidth' (comumente 80), respeitando 'formatoptions'. Use gqip para refluir um parágrafo, gqq para uma linha. Defina 'textwidth=80' para habilitar quebra automática.
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=80Repetir e Desfazer
. repete a última mudança — a tecla mais útil do Vim. u/Ctrl-r são undo/redo. U desfaz todas as mudanças na linha atual. :earlier/:later podem viajar no tempo, por tempo ou contagem, até entre ramos (o Vim mantém uma árvore de undo). Use :undolist para ver os ramos. @: repete o último comando Ex, & repete o último substituto.
. # 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 lineBusca e Substituição
Busca Básica
/ e ? buscam para frente/para trás; n/N repetem. * busca a palavra inteira sob o cursor (com fronteiras de palavra), g* busca qualquer casamento de substring. :noh limpa o realce atual até a próxima busca. Defina 'hlsearch' para realçar cada um dos matches persistentemente, 'incsearch' para casamento incremental enquanto digita.
/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!Opções de Busca
'ignorecase' + 'smartcase' é a combinação recomendada: sem diferenciar caixa, a menos que seu padrão contenha uma letra maiúscula. \c/\C sobrescrevem a caixa por busca. \v habilita o modo 'very magic', em que muitos caracteres se tornam especiais sem escape — sintaxe regex mais limpa. Deslocamentos de busca (e, b) posicionam o cursor relativamente ao match.
: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 matchPadrões de Busca (Regex)
A regex do Vim difere da PCRE — barras invertidas são necessárias para +, =, {, (, |. Use o prefixo \v para o modo 'very magic', em que esses se tornam especiais sem escape (mais próximo da PCRE). \< \> marcam fronteiras de palavra. \d/\w/\s são classes de caracteres. Use \(...\) para grupos de captura, \1/\2 para backreferences.
# 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 digitsComando Substitute
:[intervalo]s/padrão/substituição/flags é o comando substitute. :% significa o arquivo inteiro. Sem a flag 'g', só o primeiro match por linha é substituído; 'g' substitui todas as ocorrências. 'c' pede confirmação (y/n/a/q/l). Use \v para very-magic e simplificar a sintaxe de agrupamento. Grupos de captura são referenciados como \1, \2 na substituição.
:[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-magicFlags de Substituição e Replacement Especial
Flags comuns: g (todas as ocorrências), c (confirmar), i (sem diferenciar caixa), n (só contar). & na substituição insere o texto casado. \u/\U/\l/\L modificam a caixa da substituição. Use \r para inserir uma quebra de linha (\n é um byte nulo na substituição). A flag 'n' é ótima para contar matches sem mudar nada.
# 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 onlyComando Global (:g)
:g roda um comando Ex em cada linha que casa com um padrão — um 'editor global' poderoso. :v (ou :g!) roda nas linhas que não casam. Combine com qualquer comando Ex: d (deletar), m (mover), t (copiar), s (substituir), normal (rodar comando do modo normal). Útil para operações em lote em linhas marcadas. A ordem importa: :g processa de cima para baixo por padrão.
:[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 |)Modo Visual
Tipos de Modo Visual
v/V/Ctrl-v selecionam caracteres/linhas/bloco. gv reseleciona a última seleção visual — prático para reaplicar uma operação. o move para a outra ponta da seleção (para que você possa estender em qualquer direção). No modo bloco, O move para o outro canto da mesma linha.
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 -> blockwiseOperações Visuais
Com uma seleção feita, d/c/y/x funcionam como esperado. = auto-indenta (ótimo para reformatar código). >/< indentam/dedentam um shiftwidth. ! conecta a seleção por pipe a um comando shell e a substitui pela saída. Pressionar : no modo visual preenche '<,'> automaticamente como intervalo, então :s/velho/novo/g roda só na seleção.
# 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-filledTruques de Bloco Visual
O bloco visual (Ctrl-v) é um dos recursos mais poderosos do Vim. I e A inserem antes/depois do bloco — o texto é replicado em todas as linhas após Esc. Esta é a forma mais fácil de adicionar um prefixo de comentário a várias linhas ou anexar um sufixo. c muda o bloco inteiro; r{x} substitui cada caractere por x. Edições de bloco só funcionam limpas quando as linhas têm comprimentos similares.
# 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;Modo Visual de Linha
V seleciona linhas inteiras. Depois de V, as operações comuns são d/y/>/</= para manipulá-las. :m move a seleção (ex.: :'<,'>m0 move para o topo). :t duplica. '< e '> são marcas no início/fim da última seleção visual — úteis em scripts. gv reseleciona o último intervalo visual.
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 visualVisual com Objetos de Texto
Objetos de texto funcionam no modo visual também — eles estendem a seleção atual. vi( seleciona dentro dos parênteses; va( inclui os parênteses. Repetir um objeto (vawaw) estende mais. Isso costuma ser mais rápido que posicionar o cursor manualmente. Combine com operadores: ciw muda a palavra interna independentemente da posição do cursor dentro dela.
# 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 parensBusca Visual e Numeração
Pressionar : no modo visual pré-preenche '<,'> como intervalo — substituições rodam só na seleção. Para buscar pela seleção visual, use y/ e depois Ctrl-r " Enter (colar o registro na busca). g Ctrl-a no bloco visual cria uma sequência numérica — inestimável para gerar listas numeradas (1, 2, 3, ...) a partir de uma coluna de números idênticos.
# 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-aBuffers
Básico de Buffers
Buffers são arquivos em memória. :e abre um arquivo num novo buffer. :ls lista cada um dos buffers com flags de status (% = atual, # = alternado, + = modificado, h = oculto). :b N troca pelo número; :b nome pelo prefixo único. Ctrl-6 (ou :b#) alterna entre os buffers atual e alternado — extremamente comum.
: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
# + modifiedNavegação entre Buffers
:bn/:bp percorrem os buffers. Ctrl-6 alterna entre os dois mais recentes — a forma mais rápida de ir e voltar. Com 'hidden' definido, trocar de um buffer modificado não força salvar — o Vim o oculta. Use :ls e depois :b N se esquecer os números dos buffers. Plugins como fzf.vim tornam a troca fuzzy de buffers muito mais rápida.
: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'Operações com Buffers
:bd remove um buffer da lista (o arquivo é fechado). :bw também apaga marcas e variáveis locais do buffer. :%bd | e# deleta cada um dos buffers, exceto o atual — um padrão comum de limpeza. :bufdo roda um comando Ex em cada buffer — poderoso para substituições globais, mas cuidado com erros (use ! para ignorar, ou adicione a flag 'e' ao :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)Buffers Ocultos
Com 'set hidden' (altamente recomendado), você pode trocar de buffers modificados sem salvar — o Vim os mantém na memória. Sem 'hidden', o Vim bloqueia a troca até você salvar ou usar ! para descartar. :ls mostra 'h' para buffers ocultos e '+' se modificados. Essa configuração é essencial para edição produtiva de múltiplos arquivos.
: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)Lista de Argumentos
A arglist é uma lista separada da lista de buffers — é o conjunto de arquivos passado na linha de comando ou definido com :args. :n/:prev navegam por ela. :argdo roda um comando Ex em cada arquivo da arglist — perfeito para processamento em lote como :argdo %s/foo/bar/ge | update. A arglist costuma ser mais focada que a lista de buffers.
# 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 [ ])Gestão da Lista de Buffers
:ls lista os buffers, :ls! inclui os não listados (deletados, mas lembrados). Use :sb para abrir um buffer num split sem mudar o buffer da janela atual. Não existe 'buffer fechado recentemente' embutido, mas há plugins. :bufdo vimgrepadd seguido de :copen permite buscar em cada um dos buffers abertos via a lista 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)Marcas e Saltos
Definindo Marcas
Marcas são posições nomeadas em arquivos. Minúsculas (a-z) são locais do buffer; maiúsculas (A-Z) são marcas de arquivo que persistem entre sessões do Vim. Marcas numeradas (0-9) são definidas automaticamente — 0 é a posição quando o Vim fechou pela última vez, 1-9 são arquivos fechados recentemente. :marks lista, :delm deleta.
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)Saltando às Marcas
` (crase) salta à posição exata (linha + coluna); ' (apóstrofo) salta ao primeiro não-espaço da linha marcada. `A abre o arquivo que contém a marca A, mesmo que tenha sido fechado. `. salta a onde você mudou texto pela última vez, `[ e `] delimitam a última região copiada/deletada, `< e `> delimitam a última seleção visual.
\`{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
O Vim mantém uma jumplist de movimentos significativos do cursor. Ctrl-o/Ctrl-i voltam/avançam por ela. 'Significativo' significa saltos (G, gg, busca, saltos de marca, saltos de tag) — não movimentos comuns como j/k/w. :jumps mostra a lista. A jumplist é por janela e persiste entre sessões no 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
A changelist acompanha posições de edição (não navegação). g; salta à edição anterior, g, à próxima. Útil para percorrer suas mudanças de trás para frente: 'onde eu estava trabalhando?'. :changes mostra a lista. Diferente da jumplist, a changelist é por buffer. Combine com `.` para a última mudança do buffer atual.
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 editsMarcas de Arquivo (A-Z)
Marcas maiúsculas (A-Z) são marcas de arquivo — lembram o arquivo E a posição, persistindo entre sessões do Vim (guardadas no viminfo). Definir mA em foo.txt permite retornar àquela posição de qualquer lugar com `A, mesmo depois de reiniciar o Vim. Use-as como marcadores para arquivos/posições importantes num projeto.
# 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)Marcas Especiais Embutidas
O Vim define marcas especiais automaticamente. `.` é a última mudança, `[ e `] delimitam a última região copiada/deletada, `< e `> delimitam a última seleção visual, `^ é onde o modo insert terminou por último (gi salta para lá e reentra no insert). `" é a posição quando o arquivo foi fechado pela última vez — útil para retomar o trabalho.
\`. # 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 modeObjetos de Texto
Objetos de Palavra e Frase
Objetos de texto permitem operar em unidades semânticas. 'aw' (around word) inclui o espaço final — daw fecha a lacuna. 'iw' (inner word) mantém o espaço intacto — diw deixa um vazio. as/ap são as versões de frase/parágrafo. Repetir um objeto (dawaw) estende a seleção. Mais úteis com os operadores 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 wordObjetos de Colchetes
Objetos de colchetes funcionam em (), [], {}, <>. a (around) inclui os colchetes; i (inner) os exclui. ci( muda o conteúdo dos parênteses sem removê-los — perfeito para editar argumentos de funções. Funciona no par mais interno quando aninhado. at/it operam em tags HTML/XML (ex.: cit muda o conteúdo interno da tag).
# 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 innermostObjetos de Aspas
Objetos de aspas (a"/i", a'/i', a`/i`) operam em strings entre aspas. O cursor não precisa estar dentro das aspas — o Vim acha o par mais próximo. ci" muda o conteúdo de uma string sem remover as aspas — inestimável para editar literais de string. Inclui as aspas com 'a', exclui com '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 tooObjetos de Frase e Parágrafo
Frases terminam com . ! ? seguidos de espaço (ou quebra de parágrafo). Parágrafos são blocos separados por linhas em branco. 'a' inclui o espaço final, 'i' o exclui. Úteis com operadores: gqap reformata um parágrafo, >ip o indenta, das deleta uma frase. Os movimentos ( e ) saltam entre frases.
# 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 startObjetos de Tag e URL (com plugins)
at/it embutidos operam em tags HTML/XML. cit muda o conteúdo interno da tag, dat deleta a tag inteira incluindo abertura/fechamento. Para tags aninhadas, it seleciona a mais interna, depois vat estende para fora. Plugins adicionam mais objetos: vim-textobj-url (au/iu), vim-indent-object (ai/ii para blocos de mesma indentação — excelente para código).
# 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)Usando Objetos de Texto (Receitas)
Objetos de texto combinam com qualquer operador (d/c/y/v/>/</=) para edições poderosas. ciw muda uma palavra sem que você precise posicionar o cursor exatamente. ci"/ci(/ci[ mudam dentro de aspas/colchetes. gqip reformata parágrafos. Dominar isto é a chave para editar à velocidade do pensamento no 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 wordsRegistros
Básico de Registros
Registros são as áreas de transferência do Vim. "ayy copia uma linha para o registro a, "ap cola de a. Há muitos registros: nomeados (a-z), de acréscimo (A-Z), numerados (1-9) e especiais (sem nome ", yank 0, clipboard +, etc.). :reg lista-os. No modo insert, Ctrl-r {reg} insere um registro. Letra maiúscula ACRESCENTA a um registro.
# 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' contentsRegistros Nomeados e Numerados
Registros nomeados (a-z) são controlados pelo usuário; A-Z acrescentam aos a-z. Registros numerados (1-9) acompanham automaticamente os deletes recentes — 1 é o mais recente, cada novo delete empurra os demais. O registro 0 guarda só o último YANK (deletes não o sobrescrevem) — útil para fluxos de copiar-então-deletar. "- guarda deletes pequenos (sub-linha).
# 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)Registros Especiais
Registros especiais: ". = último texto inserido, "% = arquivo atual, "/ = última busca, ": = último comando. "_ é o buraco negro — escrever nele descarta o texto (útil para deletes que você não quer poluindo outros registros). "+ é a área de transferência do sistema, "* é a seleção primária do X11. "= avalia uma expressão Vimscript e insere o resultado.
# 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.Macros em Registros
Macros vivem em registros — gravar com qa escreve as teclas no registro a, @a as reproduz. Por serem registros, você pode inspecioná-los (:reg a), editá-los colando/modificando/copiando de volta, ou salvá-los no seu vimrc com :let @a = '...'. Escape teclas especiais com \<Esc> em literais de string.
# 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 lineAcréscimo e Buraco Negro
Letras maiúsculas de registro ACRESCENTAM: "Ayy acrescenta ao registro a (muito útil para construir texto ou macros de múltiplos passos). O registro buraco negro "_ descarta qualquer coisa escrita nele — deletes não atualizam os registros numerados/sem nome/de yank. Use quando quiser deletar texto sem estragar seu último 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.Clipboard e Seleção
"+ é a área de transferência do sistema (Ctrl-C/Ctrl-V em apps GUI), "* é a seleção primária do X11 (colar com o botão do meio). Com :set clipboard=unnamedplus, yanks e colas vão direto para a área de transferência do sistema — sem precisar do prefixo "+. No Linux, pode ser necessário ter xclip/xsel (X11) ou wl-clipboard (Wayland) instalados.
# 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 WaylandMacros
Gravando Macros
q{letra} começa a gravar num registro; pressione q de novo para parar. As teclas gravadas podem ser reproduzidas com @{letra}. Ao gravar, use movimentos que funcionem de forma consistente — prefira 0, ^, $, w, e a j/k, que dependem da coluna. Teste em algumas linhas antes de aplicar em massa.
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'Reproduzindo Macros
@a reproduz a macro uma vez, @@ reproduz a última, N@a reproduz N vezes. Para aplicar uma macro a muitas linhas, selecione-as visualmente e rode :normal @a, ou use :%normal @a para o arquivo inteiro. Macros param em erro (ex.: quando uma busca falha), então 999@a processa com segurança até o fim do arquivo. :g/padrao/normal @a roda só nas linhas que casam.
@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 timesEditando Macros
Como macros são guardadas em registros, você pode editá-las. Cole o registro ("ap), modifique o texto, depois copie de volta ("ay$ ou "ayy). Ou use :let @a = '...' com escapes de teclas (\<Esc>, \<CR>). Isso é muito mais fácil que regravar uma macro complexa do zero quando você erra um detalhe.
# 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' contentsMacros Recursivas
Macros recursivas chamam a si mesmas até dar erro — tipicamente quando uma busca falha. CRÍTICO: limpe o registro primeiro (let @a = '') antes de gravar, senão a primeira chamada @a dentro da macro reproduz o conteúdo ANTIGO. A macro se auto-termina quando a busca que falha interrompe a recursão. Ótimo para padrões globais de busca e substituição.
# 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 fileMacros com Contagens
N@a reproduz a macro N vezes — mas para cedo em qualquer erro, então 999@a processa com segurança até o fim do arquivo. :bufdo normal @a roda a macro em cada buffer, :argdo em cada arquivo da arglist. :g/padrao/normal @a roda só nas linhas que casam. Contagens DENTRO da macro (ex.: 5j) repetem por reprodução, não por macro.
# 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 fileMacros entre Arquivos e Linhas
:[intervalo]normal @a roda uma macro em cada linha do intervalo — a forma mais comum de aplicar uma macro a muitas linhas. Termine sua macro com 'j' para que cada iteração avance à linha seguinte. :bufdo/:argdo rodam através de buffers/arquivos. Adicione | update para salvar cada arquivo modificado. Use ! para continuar após erros (ex.: :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).Dobras (Folding)
Comandos de Dobra
foldmethod controla como as dobras são criadas. 'manual' permite criar dobras com zf. 'indent' auto-dobra por indentação (ótimo para código). 'syntax' usa regras de sintaxe (consciente da linguagem). 'marker' usa {{{ }}} no texto do arquivo. 'expr' para lógica personalizada. Dobras manuais se perdem ao fechar o arquivo, a menos que você :mkview para salvá-las.
: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 savesDobra Manual
No modo manual, zf cria uma dobra (ex.: zf3j dobra as próximas 3 linhas). zd deleta uma dobra, zD deleta recursivamente, zE elimina todas as dobras da janela. Modo visual + zf dobra a seleção. Com foldmethod=marker, você marca o início da dobra com {{{ nos comentários e a fecha com o marcador espelhado de três chaves, criando dobras persistentes guardadas no arquivo — útil para compartilhar a estrutura de dobras no versionamento.
# 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.Comandos Abrir/Fechar Dobra
zo/zc abrem/fecham uma dobra; za alterna. zO/zC/zA agem recursivamente em dobras aninhadas. zr/zm ajustam o nível de dobra globalmente (um nível por vez). zR abre tudo, zM fecha tudo — formas rápidas de resetar. zj/zk saltam entre dobras, [z/]z saltam ao início/fim da dobra atual.
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 foldsNavegação e Edição de Dobras
j/k podem pular sobre dobras fechadas, dependendo de 'foldopen'. zj/zk navegam entre os limites das dobras. yy/dd numa linha dobrada operam em TODAS as linhas dobradas como unidade (por linha). Digitar dentro de uma dobra fechada a abre. Configure 'foldopen' para controlar quais movimentos abrem dobras (ex.: remova 'search' para manter dobras fechadas ao buscar).
# 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 regionOpções de Dobra
foldlevel controla quão fundas as dobras permanecem abertas (maior = mais abertas). foldlevelstart=99 começa com tudo aberto. foldcolumn mostra uma barra lateral com indicadores do estado das dobras. foldminlines impede dobras minúsculas. Para persistir dobras entre sessões, :mkview no BufWinLeave e :loadview no BufWinEnter — padrão comum de 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 loadviewDobras Aninhadas e Nível
Dobras se aninham hierarquicamente. 'foldlevel' determina o nível mais fundo que permanece aberto — foldlevel=0 fecha tudo, 99 abre tudo. zr/zm ajustam em 1, zR/zM são os extremos. 'foldnestmax' limita a profundidade de aninhamento para evitar dobras descontroladas em código profundamente aninhado. Funções foldtext personalizadas permitem controlar o que é exibido numa dobra fechada.
# 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)'
endfunctionJanelas Divididas
Dividindo Janelas
:split/:vsplit dividem a janela atual — ambas mostram o mesmo buffer por padrão (as mudanças sincronizam). :split arquivo abre um arquivo num novo split. :new/:vnew criam buffers vazios. Ctrl-w s/v são os atalhos de teclado. Adicionar um prefixo numérico define o tamanho da nova janela (:10split cria uma janela de 10 linhas).
: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)Navegação entre Janelas
Ctrl-w seguido de h/j/k/l navega entre janelas (mnemônico: hjkl como movimento). Ctrl-w w percorre as janelas. Por velocidade, muitos usuários mapeiam Ctrl-h/j/k/l direto à navegação de janelas. Ctrl-w p retorna à janela usada anteriormente — útil ao alternar entre duas janelas.
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' buffersRedimensionando Janelas
Ctrl-w +/-/</> ajustam o tamanho em 1; prefixe com uma contagem (10 Ctrl-w +) para passos maiores. Ctrl-w _ maximiza a altura, Ctrl-w | maximiza a largura. Ctrl-w = equaliza todas as janelas. Para precisão, use :resize N (altura) e :vertical resize N (largura). Com 'mouse=a', você pode arrastar linhas de status e separadores direto.
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-resizeMovendo Janelas
Ctrl-w H/J/K/L movem a janela atual para as bordas extremas (maiúscula = tela cheia naquele lado). Ctrl-w r/R rotacionam janelas dentro do layout. Ctrl-w x troca com a janela seguinte. Ctrl-w T move uma janela para uma nova aba. Um truque bacana: Ctrl-w K/H também converte entre orientações horizontal e vertical.
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 tabOrganização de Janelas
Ctrl-w = equaliza os tamanhos das janelas. :ball abre uma janela por buffer — útil para ver tudo de uma vez. Ctrl-w r/R rotacionam janelas dentro do layout. Para salvar e restaurar um layout completo de janelas (incluindo buffers, dobras etc.), use :mksession e :source. Cada página de aba mantém o próprio layout de janelas.
# 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 windowFechando Janelas
:q fecha uma janela (e sai do Vim se for a última). :close (ou Ctrl-w c) fecha uma janela, mas não fecha a última. :only (Ctrl-w o) fecha todas as outras janelas. Com 'hidden' definido, fechar uma janela com buffer modificado o oculta, em vez de forçar uma decisão de salvar. :only! força o fechamento dos outros mesmo se modificados.
: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.Abas (Tabs)
Criação de Abas
:tabnew/:tabedit criam uma nova página de aba. vim -p arquivo1 arquivo2 abre cada arquivo na própria aba ao iniciar. Cada página de aba contém uma ou mais janelas — uma aba é um layout, não um arquivo único. Ctrl-w T move a janela atual para uma nova página de aba. Abas são ótimas para separar contextos de trabalho sem relação (ex.: uma aba por área do projeto).
: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)Navegação entre Abas
gt/gT trocam de aba (modo Normal). Ngt salta direto à aba N (indexada a partir de 1). :tabs lista todas as páginas de aba e suas janelas. Comum mapear Ctrl-Tab/Ctrl-Shift-Tab ou <leader>1/2/3 para troca rápida de abas. As abas circulam por padrão. Cada aba mantém o próprio layout de janelas (splits etc.).
: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 windowsOperações com Abas
:tabc fecha a aba atual; :tabo fecha todas as outras. :tabm N move a aba atual para a posição N (0 = primeira). :tabdo roda um comando Ex em cada aba — útil para operações globais em workspaces separados por abas. Fechar uma aba fecha todas as suas janelas; buffers modificados são preservados se 'hidden' estiver definido.
: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.Layout de Abas e Multi-janela
Cada página de aba mantém um layout de janelas independente (splits, tamanhos, posições). Você pode ter múltiplas janelas por aba. Ctrl-w T move uma janela para uma aba nova própria. :set showtabline=2 sempre mostra a barra de abas. Abas são melhores usadas como separadores de workspace (ex.: uma aba por área do projeto), cada uma com o próprio layout.
# 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.Opções e Rótulos de Abas
showtabline controla a barra de abas (0=nunca, 1=só com múltiplas abas, 2=sempre). Você pode personalizar totalmente a tabline com uma função retornando a string de formato — útil para mostrar status de modificação, nomes de buffers, números de abas. guitablabel/guitabtooltip personalizam o Vim GUI. As abas são numeradas a partir de 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>Comandos de Página de Aba
:tabs lista as abas e suas janelas. :tabdo roda um comando Ex em cada aba. :tab ball abre cada buffer na própria aba. <C-w>gf abre o arquivo sob o cursor numa nova aba. Use abas para agrupar arquivos relacionados (uma aba por recurso/área). Para operações entre abas, :tabdo é o cavalo de batalha — pareie com windo para abas multi-janela.
: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)Configuração (.vimrc)
Básico do vimrc
$MYVIMRC é o caminho para o seu arquivo vimrc — :edit $MYVIMRC o abre, :source $MYVIMRC recarrega após edições. O runtimepath controla onde o Vim procura arquivos de sintaxe, plugins etc. Use :verbose set opcao? para ver onde uma opção foi definida por último — inestimável para depurar plugins em conflito.
# 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?Configurações Básicas
Estas são configurações comuns de qualidade de vida. relativenumber + number mostra numeração híbrida — números de linha relativos ao cursor para saltos fáceis, com o absoluto na linha atual. showmatch pisca colchetes correspondentes. wildmenu melhora o completamento de :comandos com um menu. scrolloff mantém contexto visível ao redor do cursor — nunca edite na borda da tela.
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)Indentação
tabstop controla quantas colunas um caractere de tab exibe. shiftwidth é a quantidade de indentação usada por <<, >> e autoindent. softtabstop faz o Backspace remover o número certo de colunas mesmo com expandtab desligado. expandtab converte tabs em espaços — recomendado por consistência. :retab converte tabs/espaços existentes depois de mudar as configurações.
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 linesConfigurações de Busca
ignorecase + smartcase é a combinação recomendada: sem diferenciar caixa, a menos que seu padrão tenha uma letra maiúscula. hlsearch realça cada um dos matches; incsearch mostra matches incrementalmente enquanto você digita. Mapeamento comum: <leader>h alterna hlsearch, ou :noh limpa o realce atual. Vim 8.2+ pode mostrar a contagem de buscas via 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:
:nohlsearchConfigurações de Exibição
wrap + linebreak quebram linhas longas nas fronteiras de palavra (não no meio) para legibilidade. list + listchars revelam tabs, espaços finais e espaços não separáveis. colorcolumn marca uma coluna (ex.: 80 para limites de comprimento de linha). termguicolors habilita cor real de 24 bits em terminais modernos. splitright/splitbelow controlam onde novos splits aparecem.
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 solarizedMapeando Teclas
SEMPRE use as variantes *noremap (nnoremap, vnoremap etc.) para mapeamentos pessoais — elas não recursam, evitando comportamento inesperado. <leader> é uma tecla de prefixo personalizável (padrão barra invertida; muitos definem vírgula ou espaço). <CR> é Enter, <Esc> é escape, <C-x> é Ctrl-X. Mapeie atalhos de leader para comandos comuns como salvar/sair.
# 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>Plugins (vim-plug)
Básico do vim-plug
vim-plug é o gerenciador de plugins moderno mais popular. Declare os plugins entre call plug#begin e plug#end. Cada linha Plug especifica um repositório GitHub (usuario/repo). Depois de adicionar plugins, :source $MYVIMRC e então :PlugInstall os baixa. Você pode fixar numa tag, branch ou commit, por estabilidade. Plugins são instalados no diretório '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' }Comandos de Gestão de Plugins
:PlugInstall instala plugins novos, :PlugUpdate atualiza tudo, :PlugClean remove os não listados, :PlugStatus mostra o estado deles. O hook 'do' roda um comando após a instalação — útil para plugins que precisam compilar ou instalar binários. As opções 'on'/'for' habilitam lazy loading (carregar só quando um comando/filetype acionar) — melhora o tempo de inicialização.
: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)Plugins Essenciais Comuns
Essenciais comuns: fzf para busca fuzzy de arquivos/buffers/texto (muito mais rápido que :find), vim-surround para editar aspas/colchetes/tags ao redor do texto, vim-fugitive para integração com Git, vim-commentary para comentar rápido (operador gc), NERDTree para uma barra lateral de exploração de arquivos, vim-airline para uma barra de status mais bonita, e um bom colorscheme como 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'Configuração de Plugins
Use 'on'/'for' para carregar plugins preguiçosamente — eles só carregam quando acionados, melhorando o tempo de inicialização. A configuração específica de plugin tipicamente usa variáveis g:nomeplugin_var definidas no vimrc, OU arquivos em ~/.vim/after/plugin/. O hook 'do' roda após instalação/atualização para passos de build. Definir g:loaded_nomeplugin=1 no vimrc impede que um plugin carregue por completo.
" 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 loadingCarregamento e Runtime de Plugins
O Vim executa os arquivos plugin/*.vim na inicialização, em ordem de diretório, e por último after/plugin/*.vim (para sobrescritas). :scriptnames lista tudo que foi executado — inestimável para depuração. :verbose map <tecla> mostra onde um mapeamento foi definido; :verbose set opcao? faz o mesmo para opções. Arquivos autoload/ carregam preguiçosamente quando suas funções são chamadas pela primeira vez.
" 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)Gerenciadores de Plugins Alternativos
Além do vim-plug, as opções incluem Vundle (API similar, menos recursos), Pathogen (o mais simples — apenas adiciona diretórios bundle ao runtimepath), Dein.vim (rápido, focado em lazy-loading) e os pacotes embutidos do Vim 8+ (sem gerenciador de plugins — solte plugins em pack/<nome>/start/). Para usuários Neovim, Packer (baseado em Lua) é popular. Pacotes embutidos são ótimos para minimalistas.
" 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)Movimento Avançado
Busca de Caractere (f/F/t/T)
f/F acham o próximo/anterior caractere na linha atual (o cursor cai sobre ele); t/T movem até logo antes/depois dele. ; repete o último f/F/t/T na mesma direção, , na oposta. Combine com operadores: dt, deleta até (sem incluir) a próxima vírgula, df. deleta passando pelo próximo ponto. Rápido e preciso para navegação na linha.
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.Movimento por Frase e Parágrafo
( e ) movem por frase (frases terminam com . ! ? mais espaço); { e } movem por parágrafo (separados por linha em branco). Para linhas quebradas, gj/gk/g0/g$ operam nas linhas visuais da tela, enquanto j/k/0/$ operam nas lógicas — essencial com 'wrap' ativado. Combine ( ) { } com operadores: das deleta uma frase, yap copia um parágrafo.
( # 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.Pares Correspondentes (%)
% salta entre colchetes correspondentes (padrão: (), [], {}). Também funciona em #if/#endif e /* */ se 'matchpairs' estiver configurado apropriado. Combine com operadores: d% deleta do cursor ao par correspondente, v% seleciona. [( [{ ]) ]} saltam a colchetes sem par — útil para achar o bloco envolvente de função/classe.
% # 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 {Movimento na Tela
H/M/L saltam ao topo/meio/fundo da tela visível. Ctrl-f/b rola páginas inteiras; Ctrl-d/u meias páginas (menos desorientador); Ctrl-e/y rola uma linha sem mover o cursor. zz/zt/zb reposicionam a linha do cursor ao meio/topo/fundo da tela — essencial para manter contexto. 'scrolloff' garante que o cursor nunca alcance a borda da tela.
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 cursorRola Vinculada e Sincronização
:set scrollbind sincroniza a rolagem entre janelas — defina em cada janela que quiser sincronizar. :vimdiff abre dois arquivos em modo diff com scrollbind ligado, diferenças com realce de sintaxe, e [c/]c para navegar trechos. do (diff obtain) puxa mudanças da outra janela, dp (diff put) envia. Ótimo para comparar versões de um arquivo.
# 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.Indo a Posições
Muitas formas de posicionar o cursor: :N para a linha N, N% para porcentagem, `.`/`"`/[`]/`</`> para marcas especiais (última mudança, última saída, último yank, último visual). Ctrl-o/Ctrl-i navegam a jumplist. `" restaura a posição quando o arquivo foi fechado por último — combinado com uma configuração de viminfo, isso persiste entre sessões.
: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)Modo Linha de Comando
Comandos com Intervalo
Intervalos especificam quais linhas um comando afeta. :% é o arquivo inteiro (1,$). . é a linha atual, $ a última. '<,'> é a última seleção visual (preenchida automaticamente ao pressionar : no modo visual). 'a,'b é da marca a à marca b. Você também pode usar padrões de busca como limites de intervalo: :/foo/,/bar/d deleta da linha que casa com foo à que casa com 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' patternsComandos de Arquivo
:w salva, :e abre um novo arquivo, :r insere o conteúdo de outro arquivo (ou a saída de um comando shell via :r !cmd). :saveas salva e troca para o novo arquivo. :e! recarrega o arquivo descartando mudanças. ++enc/++ff especificam codificação/finais de linha explicitamente — útil para converter arquivos. :browse e abre um diálogo de arquivos GUI (no Vim GUI).
: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 endingsComandos de Buffer e Janela
Todas as operações multi-buffer/janela/aba têm formas de comando Ex. :b troca buffers, :sp/:vs dividem janelas, :tabnew cria abas. A família :*do (bufdo, argdo, tabdo, windo, cdo) roda um comando em muitos alvos — extremamente poderosa para operações em lote. :ls mostra buffers; :tabs mostra abas; :args mostra a 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 fileDefinindo Opções
:set alterna opções booleanas com !, define valores com =, acrescenta/remove com +=/-= e reseta para os padrões com &. :set opcao? mostra o valor atual. :setlocal define um valor local ao buffer/janela (não afeta outros buffers). :set sem argumentos lista todas as opções alteradas; :set all mostra tudo. Tab completa os nomes de opções.
: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)Comandos de Mapeamento
Use as variantes *noremap para mapeamentos pessoais — elas não recursam, prevenindo comportamento inesperado. <leader> é um prefixo personalizável (padrão barra invertida; muitos definem espaço ou vírgula). <buffer> torna um mapeamento local ao buffer atual. Teclas especiais usam <notação> como <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 = '\\'Comandos Ex Úteis
:!cmd roda um comando shell; :r !cmd insere sua saída no buffer. :sort ordena linhas (u=únicos, n=numérico, !=reverso). :retab converte entre tabs e espaços. :normal roda teclas do modo normal como Ex — adicione ! para ignorar mapeamentos personalizados. :%!cmd conecta o arquivo inteiro por pipe a um comando externo e o substitui pela saída.
:!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 commandBásico de Vimscript
Variáveis
Vimscript usa let para atribuição e unlet para deletar. Variáveis têm escopos indicados por prefixos: g: (global), b: (buffer), w: (janela), t: (aba), s: (script), l: (local de função), v: (embutida). const cria valores imutáveis (Vim 8+). exists() verifica se uma variável está definida. Vim 8.2+ suporta interpolação de string com $"...{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}!"Funções
function! Nome(args) ... endfunction define uma função — o ! permite redefinição. a: acessa argumentos; a:000 é a lista de argumentos variádicos. Argumentos padrão (Vim 8+) usam =valor. Lambdas (Vim 8+) são {args -> expr}. function('Nome') retorna uma funcref que você pode repassar. Use :call para invocar uma função pelos efeitos colaterais.
# 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)Condicionais e Loops
if/elseif/else/endif para condicionais. for percorre uma lista (range(N) gera 0..N-1) e pode desempacotar pares [chave, valor] de items(). while/endwhile para loops condicionais. break/continue funcionam como esperado. Checagens de condição comuns: has() para recursos, exists() para variáveis/comandos, filereadable() para arquivos, empty() para valores vazios, type() para comparação de tipos.
# 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 checkStrings
. concatena strings. Vim 8.2+ adiciona interpolação $"...{expr}...". len/strlen dão o comprimento em bytes; strcharlen dá a contagem de caracteres (importante para multibyte). split/join convertem entre strings e listas. substitute() é o comando :s programático. matchstr() extrai um match de regex. =~ é o operador de match de 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"
endifListas e Dicionários
Listas são ordenadas (como arrays); dicionários são mapas chave-valor. Fatiamento de listas usa [início:fim]. add/insert/remove modificam listas no próprio local. sort/reverse também mutam. Para dicts, tanto .chave quanto ["chave"] funcionam; keys()/values()/items() retornam listas. has_key() verifica pertinência. #{...} (Vim 8+) é um literal de dict mais limpo que não exige aspas nas chaves.
# 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}Autocmds e Comandos Personalizados
autocmd roda código em eventos do Vim (BufRead, BufWritePre, FileType, VimEnter, CursorMoved etc.). Sempre envolva autocmds em augroup com autocmd! para limpar definições antigas ao recarregar — evita duplicação. Comandos personalizados usam :command! -nargs=N -range -bang Nome acao. <args>, <line1>, <line2>, <bang> acessam a entrada do usuário na definição do comando.
# 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 BufWritePreSnippets de Vim relacionados
Copy-paste ready code for common tasks.
Buffers, Windows & Tabs
Editar múltiplos arquivos com buffers, janelas divididas e abas.
Busca & Substituição
Encontrar texto com / e substituir com :s, usando regex e ranges.
Registers (Multi-Clipboard)
Armazenar yanks/deletes em registers nomeados e colar a partir deles.
Marks (Bookmarks)
Pular de volta para posições em um arquivo ou entre arquivos com marks.
Macros (Teclas Gravadas)
Gravar uma sequência de teclas e reproduzi-la para automatizar edições repetitivas.
Folding (Colapsar Código)
Ocultar regiões de código para focar na estrutura com métodos de fold.
Gerenciadores de Plugins & Ecossistema
Instalar, configurar e descobrir plugins com vim-plug / packer / lazy.
LSP, Completion & Diagnósticos
Obter recursos de IDE (autocomplete, go-to-definition, diagnósticos) via LSP.
Was this helpful?