sexta-feira, 27 de fevereiro de 2009

Expressão regular: quantificador para zero ou mais ocorrências de um item, o menos possível

item\{-}
obtém zero ou mais ocorrências do item precedente, o menos possível.

Ele é útil quando combinado com outro item de padrão:

a\{-}b
zero ou mais 'a' (o menos possível) seguido de b.
No entanto, em 'xaaab', obtém-se a ocorrência 'aaab' porque:
a ocorrência que aparece mais cedo tem preferência sobre a ocorrência menor.

Seja o texto 'axbxb'.

a.\{-}b significa:
'a', seguido de zero ou mais caracteres (o mínimo possível), seguido de 'b'.
Obtém: 'axb'


Em contrapartida, a.*b significa:
'a', seguido de zero ou mais caracteres (o máximo possível), seguido de 'b'.
Obtém: 'axbxb'

Expressão regular: padrão para um caracter qualquer

Use:
.
Obtém a ocorrência de um único caracter qualquer, exceto o fim-de-linha.

quinta-feira, 26 de fevereiro de 2009

Expressão regular: lookahead negativo - testa a não existência de um item

item\@!
passa se o item precedente não existe (não obtém nenhuma ocorrência).

Em 'foobarfoo':

foo\(bar\)\@!
'foo', não seguido de 'bar'.
(qualquer 'foo' não seguido de 'bar')
Obtém somente o 2º foo.

O '\@!' pode causar confusão porque há muitos locais aonde o padrão não passa.

a.*p\@!
'a', seguido de zero ou mais caracteres (o máximo possível), não seguido de 'p'.
Obtém : ap, app, etc.
Pois '.*' consome todos 'p' até o fim-de-linha e 'p\@!' passa pois o fim-de-linha não é 'p'.

a.\{-}p\@!
'a', seguido de zero mais caracteres (o menos possível), não seguido de 'p'.
Obtém: a, ap, app, etc.
Pois '.\{-}' consome todos 'p' até um outro caracter diferente de 'p' (ou o final-de-linha) e 'p\@!' passa pois não há mais 'p' na posição corrente.

if \(\(then\)\@!.\)*$
'if ', seguido de zero ou mais testes de não existência de 'then' (o maximo possível) e zero ou mais caracteres, seguido do fim-de-linha.
Obtém: 'if' sem nenhum 'then' à direita.
O '$' garante que o teste irá até o final da linha, evitando ocorrências parciais que só ignoraram um 'then' à direita.

Expressão regular: lookahead positivo - testa a existência de um item

item\@=
somente testa a existencia do item precedente (não obtém nenhuma ocorrência).

Isso pode se tornar confuso, pois o item após '\@=' tentará obter uma ocorrência na mesma posição (o cursor de regex não avança).
Por exemplo em 'foobarfoo':

foo\(bar\)\@=
obtém a ocorrência 'foo'

foo\(bar\)\@=foo
não obtém a ocorrência, pois o item tenta obter 'foo' na mesma posição de 'bar'.

'\@=' é o mesmo que '\&' :
foo\&..
\(foo\)\@=..
\& tem vantagem precisar menos '\'.

Expressão regular: padrão para o início e fim de palavra

Para expressar o início e fim de uma palavra use os itens:
\< - início \> - fim
A opção 'iskeyword' define o que é uma palavra.
\<especial\>
obtém as ocorrências: especial ,-especial-,'especial'.

Expressão regular: padrão para um identificador de linguagem de programação

Um identificador de linguagem começa com uma letra seguida de letras e dígitos.
Underscores podem ser usados também.

\<\h\w*\>
início de palavra, seguido de um caracter de início de identificador, seguido de um caracter de identificador, seguido do fim de palavra.

Expressão regular: exemplo para uma placa de carro da Califórnia

A placa tem um dígito, 3 letras maiúsculas e 3 dígitos.
\d\u\u\u\d\d\d
ou:
\d\u\{3}\d\{3}
ou
[0-9][A-Z]\{3}[0-9]\{3}
A pior opção é a última, pois se digita mais e é mais lenta.

Expressão regular: padrão para quebra de linha

Use:
\n - obtém uma quebra de linha.
\_s - obtém um espaço ou quebra de linha.
\_a - obtém uma letra ou quebra de linha.

O prefixo '\_' pode ser anexado a qualquer classe de caracter ou intervalo.
Com outros itens também:
\_. - obtém um caracter ou quebra de linha.

"\_[^"]*"
obtém ocorrências com um '"', seguido de uma ou mais quebras de linha ou caracteres que não sejam '"', seguido de um '"'.
Isso obtém ocorrências de texto entre aspas duplas que se espalham por várias linhas.

the\nword
obtém ocorrências com quebra de linha entre elas.

the\_sword
obtém ocorrências com quebra de linha ou um espaço entre elas.

the\_\+word
obtém ocorrencias com quebra de linha ou um ou mais espaços entre elas.

Expressão regular: classe de caracteres

A classe de caracteres é semelhante a coleção de caracteres.

No entanto, a coleção refere a um conjunto fixo e a classe a um conjunto que
pode ser redefinido sem mudar o expressão regular.

Exemplo:
\f\+
obtém a ocorrência de um ou mais caracteres que são válidos para
um nome de arquivo.
Que caracteres são depende do sistema operacional e está definido na opção:
:set isfname
isfname=@,48−57,/,.,−,_,+,,,#,$,%,~,=

As classes de caractere são:
\i - caracteres de identificador - 'isident'
\I - como \i, excluindo dígitos
\k - caracteres de palavra-chave - 'iskeyword'
\K - como \k, excluídos dígitos
\p - caracteres imprimíveis - 'isprint'
\P - o mesmo que \p, excluindo dígitos.
\f - caracteres de nome de arquivo - 'isfname'
\F - como \f, excluindo dígitos

quarta-feira, 25 de fevereiro de 2009

Expressão regular: intervalo de caracteres pré-definido

Alguns intervalos de caracteres são tão comuns que o Vim tem abreviações para eles.
\a - todas letras, maiúsculas ou minusculas, [a-zA-Z]
\d - todos dígitos, [0-9].
\D - nenhum dígito, [^0-9].
\x - dígito hexadecimal, [0-9a-fA-F].
\X - nenhum dígito hexadecimal, [^0-9a-fA-F].
\s - espaço em branco, espaço ou tab.
\S - nenhum espaço em branco, nem espaço e tab.
\l - letras em minúsculo, [a-z].
\L - letras não em minúsculo, [^a-z].
\u - letras em maiúsculo, [A-Z].
\U - letras não em maiúsculo, [^A-Z].
\h - caractere de início de palavra, [A-Za-z_].
\w - caractere de palavra, [0-9A-Za-z_]
Esses intervalos pré-definidos são mais rápidos que os intervalos de caracteres correspondentes.

Eles não podem ser usados dentro de '[]'.
[\d\l]
não funcionam para obter um dígito ou letra minúscula, use:
\(\d\|\l\)
ao invés.

Expressão regular: coleção de caracteres

Uma coleção de caracteres permite definir os caracteres válidos que uma posição do texto pode ter.
Exemplos:
[a-z]
ocorrência de um caractere que seja letra.
[0-9a-f]
ocorrência de um caractere que seja um número ou letra de a até f.
[-0-9]
[0-9-]
ocorrência de um caractere que seja número ou '-'.

Para excluir um ou mais caracteres use um '^' no início do intervalo.
"[^"]*"
", seguido de zero ou mais caracteres que não são '"', seguido de um ".
Obtém ocorrências:
"foo" e "3!x"
Para procurar a literal '^' use '\^'.
Se prefixar a coleção com
\_
ou incluir dentro da coleção
\n
inclui também o fim-de-linha.
Alguns caracteres especiais aceitos dentro da coleção:
\e - <esc>
\t - <tab>
\r - <CR>
\b - <BS>

Expressão regular: alternativas de padrão (e)

item/&item/&item ...

Retorna uma ocorrência se todas alternativas passarem, na mesma posição.
Só a última alternativa retorna uma ocorrência.

"Na mesma posição", quer dizer que o primeiro item define o início, e o 2º (e os demais) deve passar também nessa posição. Por isso a necessidade de '.*' na 2ª alternativa.

.*Peter\&.*Bob
testa se 'Peter' e 'Bob' estão na linha.

forever\&...
'forever' e 3 caracteres quaisquer
obtém ocorrência 'for' (última alternativa).
mas não em 'fortuin' (falha a primeira alternativa).

Expressão regular: ou

O operador '\|' permite especificar duas ou mais alternativas na expressão
regular.
item\|item\|item ...
Testa cada item e termina logo que um passa.
Retorna a ocorrência do primeiro item que passou.
foo \| bar
obtém as ocorrências 'foo' ou 'bar'.
foo\|bar\|one
obtém as ocorrências 'foo' ou 'bar' ou 'one'.
\(foo\|bar\)\+
Testa múltiplas vezes (uma ou mais vezes, guloso), obtendo a maior ocorrência possível.
Obtém as ocorrências:
'foo','bar','foofoo',barfoobar'
end\(if\|while\|for\)
obtém as ocorrências
'endif','endwhile','endfor'

Expressão regular: quantificador - definindo um número específico de ocorrências, a menor possível

Use :
\{-n,m}
Semelhante a
\{n,m}
só que obtém as ocorrências mais curtas que for possível
(preguiçoso).
ab\{-1,3}
obtém a ocorrência 'ab' em 'abbb' enquanto
ab\{1,3}
obtém a ocorrência 'abbb' em 'abbb'.
a\{-3,}
obtém 3 ou mais 'a', o menos possível.
a\{-,5}
obtém de 0 até 5 ocorrências de 'a' (de fato, sempre obtendo uma
ocorrência de um caractere).
a\{-}
obtém 0 ou mais ocorrências de 'a', o menos possível. Note que esse
padrão, por si próprio, sempre irá obter 0 (preguiçoso). Ele só tem sentido com
algo depois dele.
Por exemplo:
[a-z]\{-}x 
obtém a ocorrência 'cx' em 'cxcx'.
Se tivesse usado:
[a-z]*x
teria obtido 'cxcx' inteiro.
a\{-5]
obtém exatamente 5 'a', o menos possível. Como o menos possível é 5, o padrão é
igual a
a\{5}

Expressão regular: quantificador - definindo um número específico de ocorrências, a maior possível

Use
item\{n,m}
Obtém o mínimo 'n' e no máximo 'm' de ocorrências do 'item' precedente. A maior que for possível.
ab\{3,5}
obtém as ocorrências 'abbb', 'abbbb', 'abbbbb'.

se n é omitido, assume 0, sem mínimo.
se m é omitido, infinitas ocorrências.
se ,m é omitido mas n não, é exatamente n ocorrências.
\{,4}
obtém 0,1,2,3,4 ocorrências.
\{3,}
obtém 3,4,5, etc ocorrências.
\{0,1}
obtém 0 ou 1 ocorrência, mesmo que \=.
\{0,}
obtém 0 ou mais ocorrências, mesmo que *.
\{1,}
obtém 1 ou mais ocorrências, mesmo que \+.
\{3}
obtém exatamente 3 ocorrências.

Expressão regular: quantificador - nenhuma ou uma ocorrência de um item

Use o quantificador '\=' para identificar um item que deve ocorrer nenhuma ou
uma vez, a maior possível (guloso).
Serve para definir um item como opcional.
Exemplo:
folders\=
obtém ocorrências: folder e folders.

Expressão regular: quantificador - uma ou mais ocorrências de um item, a maior possível

Use o quantificador '+' para identificar que o item que precede deve ter 1 ou
mais ocorrências, a maior possível (guloso).
ab\+
'b' deve ocorrer 1 ou mais vezes:
ab, abb, abbb.
Ao contrário do '*', se não tiver ocorrência, o teste
falhará.

Expressão regular: quantificador para zero ou mais ocorrências de um item, a maior possível

Use o quantificador '*' para dizer que você quer zero ou mais ocorrências, o
máximo possível (ele é guloso), do item precedido.
Use-o para identificar itens opcionais.

Exemplo:
a*
obtém:
a, aa, aaa, ""
.*
obtém:
qualquer string de caracteres, inclusive nenhum caractere.

O item antes do '*' pode também ser um grupo de caracteres. Use '\(' e '\)' para definir o grupo:
\(ab\)*
tem ocorrências: ab, abab, ababab, "".

O problema da posição inicial da pesquisa e o uso do deslocamento do cursor no vim

O vim começa a pesquisar a partir do cursor.
Quando usando deslocamento de linha isso pode causar problema:
/const/-2
o vim pesquisa a palavra e posiciona o cursor 2 linhas atrás. Se usar 'n' o vim pesquisará a mesma palavra.

Com o deslocamento de caracteres o vim procura compensar, iniciando a pesquisa alguns caracteres antes ou depois para que a mesma ocorrência não seja encontrada.

Repetindo uma pesquisa com ou sem posicionamento de cursor

Repete a pesquisa anterior usando o mesmo posicionamento de cursor:
/
n
Repete com outro posicionamento de cursor:
//e
Repete sem usar o posicionamento de cursor anterior:
//

terça-feira, 24 de fevereiro de 2009

Pesquisando e posicionando o cursor na linha

Por default, a pesquisa deixa o cursor posicionado no início da ocorrência.
Use flags para colocar o cursor em outras posições.

Move o cursor para o final da ocorrência:
/palavra/e
Move o cursor n caracteres à direita do final da ocorrência:
/palavra/e+3
Move o cursor n caracteres à esquerda do final da ocorrência:
/palavra/e-3
Move o cursor n caracteres à direita a partir do início da ocorrência:
/palavra/b+2
Move o cursor n caracteres à esquerda a partir do início da ocorrência:
/palavra/b-1
Da mesma forma, pesquisando para trás e posicionando cursor:
?palavra?e
?palavra?e+3
?palavra?b-1

Pesquisando e posicionando o cursor em outra linha

Por default, uma pesquisa posiciona o cursor na linha e no início da ocorrência.

Mover o cursor no início da n-ésima linha seguinte:
/palavra/2
Move o cursor para o início da n-ésima linha anterior:
/palavra/-4
Pesquisando para trás com posicionamento de cursor:
?palavra?3

Pesquisando em círculos no arquivo

Com o valor default da opção:
:set wrapscan
uma pesquisa para frente (/) vai do cursor até o final do arquivo.
Uma pesquisa para trás (?) vai do cursor até o início do arquivo.

Ao chegar nesses limites o Vim dá uma aviso.

Se repetir a pesquisa (n) o vim continua na direção até voltar para a 1ª ocorrência.

Para perceber que está dando voltas visualize a posição do cursor:
:set ruler
ou configure uma linha de status.

Para desligar o vai e volta de uma pesquisa use:
:set nowrapscan
Agora quando chegar no limite do arquivo, o vim dará um erro.
Para pesquisar todo arquivo, posicione no início com 'gg' e pesquise até dar essa mensagem de erro.

Terminando um comando do vim

Se uma pesquisa está demorando ou retornando algo não esperando use o comando:
<ctrl-c>
para interrompe-la.

Use também para terminar qualquer comando pendente do modo normal.

Definindo a regra do case na própria expressão regular

Você pode definir se considera o case ou não com um flag no própria expressão
regular.
Para ignorar o case use:
\cpadrão
Para considerar o case use:
\Cpadrão
Eles sobrepõe as opções 'ignorecase' e 'smartcase' vigentes.

Opção para considerar o case dependendo como foi digitado

Se estas opções estiverem ligadas:
:set smartcase
:set ignorecase
O vim irá pesquisar sem se importar com o case se o texto digitado for totalmente minúsculo.
No entanto, se digitar uma ou mais letras maiúscula, o vim fará uma pesquisa sensível ao case usando o case digitado.

Passando comandos do modo normal para o vim pelo shell

Se quiser mandar um script de comandos do modo normal pelo shell use:
vim -s script file.txt ...

Quando o argumento '-s script' é usado sem o argumento ' -e' significa que o arquivo fará source (incluir) dos comandos do modo normal.
Com -e, vim será executado em modo Ex e o -s significa para executar em modo silencioso e não tem opção arquivo.

Os comandos do script são executados como se fossem digitados.
Uma quebra-de-linha é considerada como um <enter> e em modo normal isso move o cursor para a próxima linha.

Uma forma de criar o script é digitar os comandos em um arquivo e imaginar como seria o resultado. Isso pode ser complicado.

Outra forma é gravar os comandos enquanto voce os executa manualmente. Use:
vim -w script file.txt ...
Todas teclas digitadas serão gravadas no arquivo 'script'. Se cometer um pequeno erro, continue e lembre de corrigir mais tarde no arquivo.
O argumento '-w' apenda os comandos a uma arquivo existente. Útil para gravar passo a passo.
Se quiser começar do zero, use '-W' para regravar um arquivo existente.

Lendo o texto pelo stdin do vim

O stdin normalmente é usado para ler comandos do vim.
Se quiser ler o texto ao invés passe o argumento '-' no lugar do nome de um arquivo:
ls | vim -

Isso permite usar a saída de ls sem precisar salva-lo em um arquivo.

Se o stdin está sendo usado para ler o texto a ser editado, use o argumento -S para ler um script de comandos vim:
programa | vim - S change.vim

Executando o Vim dentro de um shell script

Suponha que você quer trocar um determinado string por outro em vários arquivos.
O jeito mais ágil é escrever um shell script para fazer o trabalho.

Primeiro escreva os comandos Ex que farão a mudança no arquivo.
Escreva os comandos (comandos de linha de comando) em um arquivo:
:%s/-person-/Jones/g
:write tempfile
:quit
e grave como change.vim.

Agora rode o vim como um comando do shell usando o seguinte shell script:
for file in *.txt; do
vim -e -s $file < change.vim
lpr -r tempfile
done
Agora a descrição dos comandos do shell (bash):

for line... é um loop do shell que repete os comandos dentro dele. A variável $file recebe um nome de arquivo a cada passo do loop.
vim... roda como um comando de shell em modo Ex (-e), editando o arquivo $file
e lendo comandos ( < change.vim) do stdin, no modo silencioso (-s) ou seja,
sem apresentar prompts.
lpr... imprime o arquivo tempfile e o deleta no final (-r)

Fazendo a mesma alteração em vários arquivos

Mudando uma palavra por outra em vários arquivos.

Coloque todos os arquivos relevantes na lista de argumentos:
:args *.c
o comando localiza todos os arquivos e edita o primeiro.

Agora faça o comando de substituição que rodará sobre todos arquivos:
:argdo %s/\/x_counter/ge | update
:argdo - é um comando que tem como argumento um outro comando. Esse comando será executado para cada arquivo da lista.
%s - substitui em todas as linhas
/\ - aonde tiver o padrão, a palavra 'x_cnt', não o substring
/x_counter/ - mude para esta palavra
g - substitui todas ocorrências na linha.
e - não imprime mensagem de erro caso o padrão não exista no arquivo e continua com o próximo. Sem esse flag :argdo abortaria antes de completar todos arquivos.
| - concatenador de comandos
update - grava o buffer somente se houve modificação.
Outras alternativas são:
:windo
executa seu argumento em todas janelas.
:bufdo
executa seu argumento em todos buffers. Cuidado com este pois pode haver mais arquivos na lista de buffers do que o esperado. Use ':buffers' ou ':ls' para verificar.

Somando e subtraindo um número no texto

Para aumentar um número sob o cursor use (1 ou 'contagem'):
<Ctrl-A>
3<Ctrl-A>
Para diminuir um número sob o cursor use (1 ou 'contagem'):
<Ctrl-X>
2<Ctrl-X>
Use a técnica abaixo para alterar somar um ao ano que existir no texto.

Faça uma pesquisa que abranja todos os anos a serem alterados:
/19[0-9][0-9]\|20[0-9][0-9]
<Enter>
Vai para a 1ª ocorrência.
<Ctrl-A>
Soma 1 ao ano selecionado.

Agora as demais ocorrências.
n
.
Salta para a próxima ocorrência e altera.

O Vim detecta formatos de números e irá diferenciar números octais, hexadecimais
e decimais.
Se o número começa com '0x' ou '0X', o vim o considera hexadecimal
0x1E <Ctrl-A> 0x1F
Se o número começa com '0', o vim o considera octal :
0177 <Ctrl-A> 0200
Se quiser que o Vim o considere como decimal use a opção:
:set nrformats-=octal

segunda-feira, 23 de fevereiro de 2009

Repetindo uma seleção visual no vim

Após uma seleção visual e um comando a seleção desaparece. Repita a mesma seleção visual com:
gv
não importando ao o cursor está.

Alterando <Tab> no modo de substituição virtual

Suponha um arquivo texto com uma tabela cujas colunas são separadas por <Tab>.
O texto de uma coluna será estendido sobre um <Tab> adjacente:
rcaractere
Sem o <Tab> layout da tabela será destruído.

Ao invés use:
grcaractere
agora o Vim irá inserir também <Tab> ou espaços necessários para manter a distância com o próximo caractere.

Se precisar trocar mais de um caractere usando:
R
Novamente, o <Tab> será sobreposto e o layout destruído.

Ao invés, use:
gR
O Vim entrará no modo substituição virtual. Novamente o Vim usará <Tab> e espaços para manter o layout.

Naturalmente, se a opção 'expandtab' estiver ligada, não incorrerá no problema.

Copiando uma coluna no vim

Use o edição virtual com:
:set virtualedit=all

Selecione com um bloco visual a coluna que se deseja copiar:
<ctrl-v>
2j
9l
Se for possível inclua também os espaços de separação a direita (espaço virtual).

Copie o bloco:
y

Mova o cursor para a coluna que seguirá a nova coluna e cole a direita
/coluna-1
P

Desligue a opção de edição virtual:
:set virtualedit=all

Opção para editar tabelas de texto no vim

O modo básico para preencher colunas vazias mais a direita é inserir vários espaços e finalmente chegar a posição desejada.

Um jeito mais ágil é com a opção:
:set virtualedit=all

Com essa opção, o cursor pode ser posicionado aonde não existe caracter algum. Isso é chamado de "espaço virtual'. Editar tabelas fica fácil.

Posicione na coluna mais a direita, desça com 'j' e digite no local.
Assim que voce começa a digitar o vim se encarrega de preencher o vazio antes do texto com espaços.

Transformando um parágrafo em linha no vim

Se quiser exportar texto para o MS-Word, cada parágrafo deveria ser uma linha.
Se os parágrafos são separados por uma linha vazia use:
:g/./,/^$/join

Explicação:
:g/./ - um comando global, que marca todas linhas que contém ao menos um caracter qualquer.
,/^$/ - um intervalo, começando da linha corrente (a linha não-vazia) e vai até uma linha vazia.
join - um comando join, que junta o intervalo de linhas em uma única linha.

Use o comando 'gq' para formatar o texto.

Se houver parágrafos separados por linhas em branco porém não-vazias (espaços e tabs) use este comando ao invés:
:g/\S/,/^\s*$/join
gg
gqG

:g/\S/ - marca todas linhas com um caracter não-branco
,/^\s*$/- no intervalo da linha corrente (não-branco) até uma linha com o padrão 'início-um ou mais brancos-fim'
join - faz join das linhas do intervalo.

Movendo linhas de tela ao invés de linhas de buffer no vim

Os comandos 'j' e 'k' saltam para linhas reais do buffer.
Se as linhas forem compridas, muitas linhas de tela serão saltadas.

Para saltar as linhas de tela ao invés das linha do buffer use:
gj
gk

Para facilitar, mapeie os comandos:
:map gk
:map gj

Opção para indicar que uma linha foi quebrada no vim

Coloca um string no início das linhas que foram quebradas:
:set showbreak="> "

Opção que define caracteres causam quebra de linha

Se 'linebreak' estiver ligar esta opção define quais caracteres determinam uma quebra de linha.
:set breakat=" ^I!@*-+;:,./?" (default)

Opção para visualizar linhas longas sem inserir quebras no arquivo no vim

Suponha que você está preparando um texto sem quebra de parágrafos para um outro programa.
Isso significa 'textwidth=0' (sem quebra-de-linhas automáticas) e sem quebrar linhas com <Enter>.

Quando estiver visualizando, com 'nowrap' não se pode ver a sentença toda e com
'wrap' palavras são quebradas no meio se necessário.

Uma boa solução é usar:
:set linebreak
o qual faz o vim quebrar em locais apropriados (sem alterar o arquivo).
Essa opção só quebra visualmente, não alterando o arquivo.

Os 'locais apropriados' são determinados pelo valor da opção
:set breakat

domingo, 22 de fevereiro de 2009

Convertendo um arquivo com tabstop fora do padrão

Se um arquivo foi editado com 'tabstop=4' ele parecerá distorcido ao abrir no vim com o 'tabstop' default de 8.
Usaremos o comando:
:retab
o qual converte tabs para espaço (se 'expandtab' estiver ligada) ou converte
tamanho de tabstops (com 'expandtab' desligada).

Iremos converter o tabstop do arquivo para o tabstop desejado.

Primeiro, use o tabstop original do arquivo:
:set tabstop=4
:set noexpandtab
Agora, o texto aparece corretamente na tela.
Execute o comando:
:%retab 8
Isso muda os tab stops para 8. O texto aparecerá inalterado, porque o Vim mudou
o espaço em branco para corresponder ao novo valor de 'tabstop'.

Opção para substituir um tab por espaços no vim

Use:
:set expandtab

Ao pressionar <tab> diz ao vim para usar o número de espaços correspondentes e não <tab>.

Opção que define quantos espaços um Tab tem.

A opção 'tabstop' diz ao vim quantos espaços um <tab> conta.

Recomendação- sempre mantenha o default:
:set tabstop=8
Se usar um valor diferente, os outros programas usando o valor padrão, mostrará seu texto de modo incorreto. As impressoras também usam esse valor.

Caso tenha recebido um arquivo com 'tabstop' diferente de 8, use o comando ':retab' para corrigir.

Opção para definir quantos espaços um tab insere no vim

Essa opção faz o vim parecer que está inserindo <tab>s, mas na realidade é uma combinação de <tab> e espaço (ou só espaços).

Use:
:set softtabstop=4
Cada <tab> irá inserir 4 espaços no modo inserção.

Sem a opção 'expandtab' o vim fará o uso de <tab> para minimizar os espaços.
Por exemplo, se já existe 4 espaços um <tab> será usado, economizando 7 caracteres.

Opção para definir o tamanho da indentação

Use:
:set shiftwidth=4
define o número de espaços para cada nível de indentação.

Usado por: opção 'autoindent', comandos '<','>', etc

Aumentando e diminuindo a indentação

A quantidade de indentação vem do valor de 'shiftwidth'.

Para aumentar use o operador:
>
>4j
para linha corrente:
>>
para as 4 linhas consecutivas:
4>>

Para diminuir use:
<
<4j
4<<

Indentando baseado na linha anterior

Útil para linguagens estruturadas como 'Python', 'Pascal' e 'Perl'.
Usa a mesma indentação da linha corrente ao criar uma nova linha:
:set autoindent
É a forma mais simples de indentação.

Justificando texto num programa externo no vim

Use o programa de shell fmt, por exemplo:
:%!fmt

Justificando texto

Use o pacote de macros com (coloque no vimrc se for usa-lo com frequência):
:runtime macros/justify.vim
Este script define um novo comando visual:
_j
Selecione o texto visualmente e aplique o comando.
Ele usará o valor de :textwidth
Do mesmo plugin, para tirar o excesso de espaços antes da formatação use:
,gq

Alinhando texto

Para centralizar o texto use:
:{intervalo}center{largura}
Se a largura não for informada será usado o valor de 'textwidth' ou o default 80.
Centrando um intervalo de linhas:
:1,5center
Centrando entre 40 colunas:
:1,5 center 40
Alinhando à direita:
:1,5right 37
Alinhando à esquerda:
:1left 5
:2,$left
Ao contrário de ':center' e ':right' o argumento é a margem esquerda, não o tamanho da linha. O default é zero.

Opção que define quantos espaços insere após uma junção de linhas

Use:
set joinspaces
é inserido 2 espaços após um junção de linha ('J')
após um '.,!,?'.

Opção para usar um programa externo para formatar texto

O Vim usa lógica de formatação interna para formatar. Se quiser, pode usar um
programa externo, tal como 'fmt' do Unix, quando o usar o comando 'gq':
:set formatprg=fmt
Mesmo sem essa opção você pode usar um filtro ('!') para formatar o texto.
Para formatar um parágrafo através desse programa use:
!}fmt

Reformatando um texto no vim

O vim, por default, não faz reformatação automatica de texto quando voce deleta ou acrescenta texto.
Para reformatar, selecione o texto e use 'gq':
v4j
gq

Como 'gq' é um operador pode-se um dos 3 modos de selecionar texto: o visual, com movimento e com objeto-texto.
Movimento:
gq4j
menos digitação, porém precisa contar.
qg}
move para o fim do parágrafo é melhor.

Objeto-texto:
gqap
formata texto de um parágrafo, separados por linha vazias.

Para reformatar o arquivo inteiro, se os parágrafos são separados por linhas vazias:
gggqG
Contudo se os parágrafos não forem separados corretamente, eles serão juntados. Um erro comum é ter um espaço ou tab.

Executando um comando do modo normal no modo inserção

O modo inserção oferece um número limitado de comandos.
O modo normal tem muito mais. Quando você quer usa-los você deixa o modo inserção com <Esc>, executa o comando no modo normal e volta ao modo inserção com 'i' ou 'a'.

Um modo mais ágil é usando o comando:
<Ctrl-O>comando
Você só pode executar um comando assim ou um comando mais complexo com registrador-operador-movimento.
Deletando até a 3ª palavra para dentro do registrador g:
<Ctrl-O>"g3dw

Criando um dígrafo

Dígrafo é um par de caracteres usado para representar um caractere
que não existe no teclado.

Você pode criar seus próprios dígrafos usando:
:digraphs a" ä
ou usando o número decimal:
:digraphs a" 228
Isto significa que
<Ctrl-K>a"
irá inserir um carácter ä.

Listando os dígrafos disponíveis

Use:
:digraphs
Aparece uma lista com o dígrafo, os caracteres que o gera, e o número decimal do caractere.

Inserindo caracteres especiais

No modo inserção, o comando:
<Ctrl-V>
insere o caractere seguinte literalmente.
Em outras palavras, qualquer significado especial que um caractere tem no vim, será ignorado.

Para inserir o caractere <Esc> sem sair do modo inserção:
<Ctrl-V><Esc>
Pode ser usado também para inserir um caractere em decimal, hexadecimal ,octal e byte.

Decimal.
Inserindo o caractere Del:
<Ctrl-V>127
Inserindo o caractere Tab:
<Ctrl-V>009
Hexadecimal, prefixe com 'x':
<Ctrl-V>x7f
Octal, prefixe com 'o':
<Ctrl-V>o123
Byte em 16 e 32 bits:
<Ctrl-V>u1234
<Ctrl-V>U12345678

Evitando remapeamento de abreviações

Abreviações podem causar problemas com mapeamentos:
:abbreviate @a ad
:imap ad adder
Quando se digitar '@a' será adicionado 'ad'. Mas como 'ad' está mapeado para
inserir 'adder', a palavra 'adder' será adicionada no texto.
Para evitar isso use:
:noreabbrev @a ad
para que a abreviação não seja candidata a mapeamento.

Removendo abreviações

Remova uma abreviação com:
:unabbreviate @f
apesar de ocorrer abreviação o vim consegue deletar a abreviação (exceto se a expansão for também uma abreviação).

Para remover todas abreviações:
:abclear
Há versões exclusivas para o modo inserção e a linha de comando:
:iunabbreviate
:cunabbreviate
:iabclear
:caclear