Comando Linux vim

Nos sistemas operacionais do tipo Unix, o vim , que significa ” Vi Improved”, é um editor de texto . Ele pode ser usado para editar qualquer tipo de texto e é especialmente adequado para editar programas de computador.

Descrição

O vim é um editor de texto compatível com o Vi . Existem muitas melhorias acima do Vi : desfazer vários níveis, várias janelas e buffers, destaque de sintaxe , edição de linha de comando , conclusão de nome de arquivo , um sistema completo de ajuda, seleção visual e outros.

Iniciando o vim

Na maioria das vezes, o vim é iniciado para editar um único arquivo usando o seguinte comando.

  vim arquivo

De maneira mais geral, a sintaxe para iniciar o vim é a seguinte:

  vim [ opções ] [ lista de arquivos ]

Se a lista de arquivos estiver ausente, o editor começará com um buffer vazio. Caso contrário, uma das quatro opções a seguir poderá ser usada para escolher um ou mais arquivos a serem editados.

Opções principais

Invocando o vim

O vim se comporta de maneira diferente, dependendo do nome do comando usado para invocá-lo. Por exemplo, se você criar um link simbólico para o executável do vim com um dos seguintes nomes, ele se comportará da seguinte maneira:

Sintaxe

  vim [ opções ] [ arquivo ..]

  vim [ opções ] -

  vim [ opções ] -t tag

  vim [ opções ] -q [ arquivo de erro ]

Opções adicionais

As opções podem ser dadas em qualquer ordem, antes ou depois dos nomes dos arquivos. Opções sem argumento podem ser combinadas após um único traço.

  vim "+ set si" main.c

Acessando a Ajuda no vim

Digite ” :help ” no vim para começar. Digite ” :help subject” para obter ajuda sobre um assunto específico. Por exemplo: ” :help ZZ ” para obter ajuda para o comando ” ZZ “. Use <Tab> e Ctrl-D para concluir os assuntos (” : ajude a cmdline-complete “). As tags estão presentes para pular de um lugar para outro (tipo de links de hipertexto, consulte ” : ajuda “). Todos os arquivos de documentação podem ser visualizados dessa maneira, por exemplo ” : help syntax.txt “.

Aprendendo o vim com o tutor do vim

O vim é instalado com um sistema de tutorial interno chamado vimtutor para ajudá-lo a aprender os comandos do vim. É um tutorial de 30 minutos que ensina as funcionalidades básicas mais básicas do vim . No Unix e Linux , se o vim tiver sido instalado corretamente, você poderá iniciá-lo na linha de comando executando o comando:

  vimtutor

No Microsoft Windows, você pode encontrá-lo no menu Programas / vim ou executar vimtutor.bat no diretório em que o vim foi instalado.

Editando no vim: Inserindo texto

O editor vim é um editor “modal”. Isso significa que o editor se comporta de maneira diferente, dependendo do modo em que você está. Os dois modos básicos são chamados de modo normal e modo de inserção . No modo Normal, os caracteres digitados são comandos. No modo Inserir, os caracteres são inseridos como texto.

Desde que você acabou de iniciar o vim, ele estará no modo Normal. Para iniciar o modo Inserir, digite o comando ” i ” ( i para Inserir). Então você pode inserir o texto. Será inserido no arquivo. Por exemplo, você pode iniciar uma nova sessão do vim executando o seguinte comando na linha de comandos:

  vim

Isso o colocará em uma nova janela de edição do vim , que mostrará um til (” ~ “) em qualquer linha vazia de texto. A janela será semelhante ao seguinte:

  ┌────────────────────────────────────────────────── ───────┐
 │ ~ │
 │ ~ │
 │ ~ │
 │ ~ │
 │ │
 └─────────────────────────────────────────────────────── ───────┘

Você começará no modo normal , portanto, para inserir texto, será necessário entrar no modo de inserção . Você digitará i e, em seguida, o texto que deseja inserir no documento. Então, você pode digitar o seguinte:

  iEsta é uma linha de texto.
 Esta é a linha número dois!

(Pressione <Enter> após a palavra texto para iniciar a nova linha). Por fim, pressione a tecla <Esc> para interromper o modo Inserir e voltar ao modo Normal. Agora você tem duas linhas de texto na janela do vim :

  ┌────────────────────────────────────────────────── ───────┐
 │Esta é uma linha de texto.  │
 │Esta é a linha número dois!  │
 │ ~ │
 │ ~ │
 │ │
 └────────────────────────────────────────────────── ───────┘

Sair do problema

Quando você aprende o vim pela primeira vez, é comum ficar confuso digitando o comando errado ou digitando-o no modo errado. Sempre, para voltar ao modo Normal (não importa em que modo você esteja), pressione a tecla <Esc> . Às vezes você tem que pressionar duas vezes. Se o vim emitir um bipe, você já está no modo Normal.

Movendo-se em torno de

Depois de retornar ao modo Normal, você pode se mover usando estas teclas:

Essas teclas podem parecer escolhas estranhas para mover o cursor, mas há uma boa razão para isso: mover o cursor é a coisa mais comum que você faz em um editor e essas teclas estão na linha inicial da sua mão direita. Em outras palavras, esses comandos são colocados onde você pode digitá-los mais rapidamente (especialmente quando você digita com dez dedos).

Você também pode mover o cursor usando as teclas de seta. No entanto, se você fizer isso, você diminui bastante a velocidade da edição porque, para pressionar as teclas de seta, deve mover a mão das teclas de texto para as teclas de seta. Considerando que você pode fazer isso centenas de vezes por hora, isso pode levar uma quantidade significativa de tempo. Além disso, existem teclados que não possuem teclas de seta ou que os localizam em locais incomuns; portanto, conhecer o uso das teclas hjkl ajuda nessas situações.

A melhor maneira de aprender esses comandos é usando-os. Use o comando ” i ” para inserir mais algumas linhas de texto. Em seguida, use as teclas hjkl para se mover e inserir uma palavra em algum lugar. Não se esqueça de pressionar <Esc> para voltar ao modo Normal. O vimtutor também é uma maneira fácil de aprender fazendo.

Exclusão de caracteres

Para excluir um caractere, mova o cursor sobre ele e digite ” x “. Mova o cursor para o início da primeira linha, por exemplo, e digite xxxxxxx (sete x ‘s) para excluir ” Isto é “. O resultado deve ficar assim:

  ┌────────────────────────────────────────────────── ───────┐
 │ uma linha de texto.  │
 │Esta é a linha número dois!  │
 │ ~ │
 │ ~ │
 │ │
 └────────────────────────────────────────────────── ───────┘

Agora você pode inserir um novo texto, por exemplo, digitando:

  Aqui está

<Esc>

Isso inicia uma inserção ( i ), insere as palavras ” Aqui está ” e sai do modo de inserção ( <Esc> ). O resultado:

  ┌────────────────────────────────────────────────── ───────┐
 IsAqui está uma linha de texto.  │
 │Esta é a linha número dois!  │
 │ ~ │
 │ ~ │
 │ │
 └────────────────────────────────────────────────── ───────┘

Excluindo uma linha

Para excluir uma linha inteira, mova o cursor para essa linha e digite ” dd “. A próxima linha será movida para cima para preencher a lacuna. Por exemplo, se você mover o cursor para a primeira linha e digitar ” dd “, nosso exemplo será semelhante a:

  ┌────────────────────────────────────────────────── ───────┐
 │Esta é a linha número dois!  │
 │ ~ │
 │ ~ │
 │ ~ │
 │ │
 └────────────────────────────────────────────────── ───────┘

Excluindo uma quebra de linha

No vim, você pode unir duas linhas, o que significa que a quebra de linha entre elas é excluída. O comando ” J ” faz isso. Pegue estas duas linhas:

  Esta é a linha 
    número dois

Mova o cursor para a primeira linha e pressione ” J “:

  Esta é a linha número dois

Desfazer

O comando ” u ” desfaz a última edição. No vim , pressionar u várias vezes continua a desfazer as edições anteriores. Essa é uma das maneiras pelas quais o vim é diferente do vi ; no vi , pressionar u duas vezes desfaz o próprio desfazer.

Refazer

Pressionar Ctrl-R (refazer) inverte o comando anterior. Então, depois de fazer um desfazer com ” u “, pressionar Ctrl-R desfaz o desfazer.

Anexar

O comando ” i ” insere um caractere antes do caractere sob o cursor. Isso funciona bem; mas o que acontece se você quiser adicionar coisas ao final da linha? Para isso, você precisa inserir texto após o cursor. Isso é feito com o comando ” a ” (acrescentar). Por exemplo, para alterar a linha

  Estou muito empolgado em usar o vim.

para

  Estou muito empolgado em usar o vim !!!

mova o cursor para o ponto (ponto final) no final da linha. Em seguida, digite ” x ” para excluir o período. O cursor está agora posicionado no final da linha. Agora digite

  uma!!!

E, em seguida, pressione <Esc> para retornar ao modo normal.

Portanto, sempre que desejar inserir texto exatamente onde está o cursor, pressione ” i “. Mas se você deseja começar a adicionar texto após a posição do cursor, pressione ” a “.

Abrindo uma nova linha

O comando ” o ” cria uma nova linha vazia abaixo do cursor e coloca o vim no modo Inserir. Então você pode digitar o texto para a nova linha. Suponha que o cursor esteja em algum lugar na primeira dessas duas linhas:

  Estou muito empolgado em usar o vim. 
 Surpreender.

Se você agora usa o comando ” o ” e digite o novo texto:

  uau.  Tão útil.  Poupa muito tempo.

Em seguida, digite <Esc> para retornar ao modo normal. O resultado é:

  Estou muito empolgado em usar o vim.
 Uau.  Tão útil.  Poupa muito tempo.
 Surpreender.

O comando ” O ” (maiúsculo) é semelhante, mas abre uma linha acima do cursor em vez de abaixo dele.

Repetindo um comando usando uma contagem

Suponha que você queira subir nove linhas. Você pode digitar ” kkkkkkkkk ” ou inserir o comando ” 9k “. De fato, você pode preceder muitos comandos com um número. Por exemplo, anteriormente adicionamos três pontos de exclamação ao final de uma linha, digitando ” a !!! <Esc> “. Outra maneira de fazer isso é usar o comando ” 3a! <Esc> “. A contagem de 3 indica o comando a seguir para triplicar seu efeito. Da mesma forma, para excluir três caracteres, use o comando ” 3x “. A contagem sempre vem antes do comando ao qual se aplica.

Sair do vim

Para sair, use o comando ” ZZ “. Este comando grava o arquivo e sai.

Diferentemente de outros editores, o vim não cria automaticamente um arquivo de backup. Se você digitar ” ZZ “, suas alterações serão confirmadas e não haverá retorno. Você pode configurar o vim para produzir arquivos de backup (consulte ” Arquivos de backup “, abaixo), mas não o fará por padrão.

Descartando alterações

Para sair sem salvar suas alterações, use o comando

  : q!

Para os interessados ​​nos detalhes, as três partes deste comando são dois pontos (:), que entram no modo de linha de comando; o comando q , que diz ao editor para sair; e o modificador de comando de substituição ( ! ). O modificador de comando override é necessário porque o vim reluta em jogar fora as alterações. Se você digitar apenas ” : q “, o vim exibirá uma mensagem de erro e se recusará a sair:

  E37: Nenhuma gravação desde a última alteração (use! Para substituir)

Se você deseja apenas reverter para a versão salva do arquivo, o comando ” : e! ” Recarrega a versão original do arquivo.

Movendo de uma palavra para outra

Para mover o cursor para frente uma palavra, use o comando ” w “. Como a maioria dos comandos do vim , você pode usar um prefixo numérico para passar várias palavras. Por exemplo, ” 3w ” move três palavras. Este exemplo mostra como funciona: Para a seguinte linha de texto, se você pressionar ” w ” onde indicado, o cursor se moverá para o local indicado pela seta.

  Esta é uma linha com texto de exemplo 
 w ---> _
  w -> _
  w > _

Ou, usando o prefixo numérico:

  Esta é uma linha com texto de exemplo
 3w -------> _

O comando ” b ” retrocede ao início da palavra anterior:

  Esta é uma linha com texto de exemplo 
                     _ <--- b
           _ <-------- 2b 
         _ < b 
      _ <- b 
 _ <--- b 

Há também o comando ” e ” que se move para o próximo final de uma palavra e ” ge “, que se move para o final anterior de uma palavra:

  Esta é uma linha com texto de exemplo 
    <- <--- -----> ---->
    ge  ge     e     e

Se você estiver na última palavra de uma linha, o comando ” w ” o levará à primeira palavra na próxima linha. Assim, você pode usar isso para percorrer um parágrafo, muito mais rápido do que usar ” l “. ” b ” faz o mesmo na outra direção.

Uma palavra termina com um caractere que não seja da palavra, como ” . “, ” – ” ou ” ) “. Para alterar o que o vim considera uma palavra, use o comando ” : help iskeyword “. Também é possível mover por palavras separadas por espaço em branco . Esta não é uma “palavra” no sentido normal, é por isso que as letras maiúsculas são usadas. Os comandos para mover dessa maneira estão em maiúsculas, como mostrado aqui:

  ge b w e
        _ <_ <-> _ -> _
 Esta é uma linha, com palavras especiais / separadas / (e mais algumas). 
    _ <---- _ <--- -------------------> _ ----> _
  gE B W E

Com essa combinação de comandos em minúsculas e maiúsculas, você pode avançar e retroceder rapidamente através de um parágrafo.

Movendo para o início ou fim de uma linha

O comando ” $ ” move o cursor para o final de uma linha. Se o seu teclado tiver uma tecla <End> , fará o mesmo.

O comando ” ^ ” se move para o primeiro caractere não em branco da linha. O comando ” 0 ” (zero) move para o primeiro caractere da linha (a tecla <Home> faz a mesma coisa):

  ^
      _ <----------
      Esta é uma linha com texto de exemplo 
 _ <--------------- --------------> _
  0 $

O comando ” $ ” recebe uma contagem, como a maioria dos comandos de movimento. Mas passar para o final da linha várias vezes não faz sentido. Portanto, faz com que o editor vá para o final de outra linha. Por exemplo, ” 1 $ ” move você para o final da primeira linha (aquela em que você está), ” 2 $ ” para o final da próxima linha e assim por diante.

O comando ” 0 ” não aceita um argumento de contagem, porque o ” 0 ” faria parte da contagem.

Usar uma contagem com ” ^ ” não tem nenhum efeito.

Movendo-se para um personagem

Um dos comandos de movimento mais úteis é o comando de pesquisa de caracteres únicos. O comando ” fx ” pesquisa adiante na linha o caractere único “x”. O “f” significa “Localizar”.

Por exemplo, você está no início da seguinte linha. Suponha que você queira ir para o “h” em “humano”. Basta executar o comando ” fh ” e o cursor será posicionado sobre o h :

  Errar é humano.  Perdoar é divino. 
 ---------> _
 fh	

Você pode especificar uma contagem; portanto, desde o início da linha, você pode ir para o “o” de “perdoar” com ” 3fo “:

  Errar é humano.  Perdoar é divino. 
 --------------------> _
 3fo

O comando ” F ” (F maiúsculo) pesquisa à esquerda:

  Errar é humano.  Perdoar é divino.
           _ <----------
  Fh

O comando ” tx ” funciona como o comando ” fx “, exceto para um caractere antes do caractere pesquisado. O “t” significa “Para”. A versão anterior deste comando é ” Tx “.

  Errar é humano.  Perdoar é divino. 
           _ <--------- ---------> _
  Th tn

Esses quatro comandos podem ser repetidos com ” ; “.

” , ” repete na outra direção.

O cursor nunca é movido para outra linha. Nem mesmo quando a frase continua.

Às vezes, você inicia uma pesquisa, apenas para perceber que digitou o comando errado. Você digita ” f ” para pesquisar para trás, por exemplo, apenas para perceber que você realmente quis dizer ” F “. Para abortar uma pesquisa, pressione <Esc> . Portanto, ” f <Esc> ” é uma pesquisa direta abortada e não faz nada. <Esc> cancela a maioria das operações, não apenas as pesquisas.

Correspondência entre parênteses

Ao escrever um programa, você geralmente termina com construções <v> () </v> aninhadas. Então, o comando ” % ” é muito útil: move-se para o parêntese correspondente. Se o cursor estiver em um ” ( “, ele se move para o correspondente ” ) “. Se estiver em um ” ) “, ele será movido para o ” ( ” correspondente).

  %
          _ <----
 se (a == (b * c) / d) 
     ---------------> _
  %

Isso também funciona para pares [] e {} . Isso pode ser definido com a opção ‘ matchpairs ‘. Use o comando ” : help matchpairs ” no vim para obter mais informações.

Quando o cursor não estiver em um caractere útil, ” % ” procurará adiante para encontrar um. Portanto, se o cursor estiver no início da linha do exemplo anterior, ” % ” procurará para a frente e encontrará o primeiro ” ( “. Em seguida, ele se moverá para sua correspondência:

  se (a == (b * c) / d) 
  - + ---------------> _
 %

Movendo para uma linha específica

Para ir para uma linha específica, use o comando ” G “.

Sem argumento, ” G ” o posiciona no final do arquivo. Uma maneira rápida de ir para o início de um arquivo, use ” gg “. ” 1G ” fará o mesmo.

  |  primeira linha de um arquivo ^
	     |  texto texto texto texto |
	     |  texto texto texto texto |  gg
	 7G  texto texto texto texto |
	     |  texto texto texto texto
	     |  texto texto texto texto
	     V text text text text |
		 texto texto texto texto |  G
		 texto texto texto texto |
		 última linha de um arquivo V

Outra maneira de mover para uma linha é usar o comando ” % ” com uma contagem, que move essa porcentagem pelo arquivo. Por exemplo, ” 50% ” move você para a metade do arquivo. ” 90% ” chega perto do fim.

O anterior pressupõe que você deseja mover para uma linha no arquivo, não importa se está visível no momento ou não. E se você quiser passar para uma das linhas que pode ver? Esta figura mostra os três comandos que você pode usar, H , M e L.

H move você para o topo da tela visível, M para o meio e L para o final. Por exemplo:

  ┌──────────────────────────┐	
 H -> |  texto de exemplo |
         |  texto de exemplo |
         |  texto de exemplo |
         |  texto de exemplo |
 M -> |  texto de exemplo |
         |  texto de exemplo |
         |  texto de exemplo |
         |  texto de exemplo |
 L -> |  texto de exemplo |
         └──────────────────────────┘

“H” significa Casa, “M” significa Médio e “L” significa Último.

Determinando onde você está

Para ver onde você está em um arquivo, há três maneiras:

Use o comando Ctrl-G . Você recebe uma mensagem como esta:

  "usr_03.txt" line 233 of 650 --35% - col 45-52

Isso mostra o nome do arquivo que você está editando, o número da linha onde está o cursor, o número total de linhas, a porcentagem do caminho através do arquivo e a coluna do cursor.

Às vezes, você verá um número de coluna dividido. Por exemplo, ” col 2-9 “. Isso indica que o cursor está posicionado no segundo caractere, mas como o caractere um é uma guia, ocupando oito espaços no valor de colunas, a coluna da tela é 9 .

Defina a opção ‘ number ‘. Isso exibe um número de linha na frente de cada linha:

  :set number

Para desligar novamente:

  :set nonumber

Como ‘number’ é uma opção booleana , acrescentar ” não ” ao nome tem o efeito de desativá-lo. Uma opção booleana possui apenas esses dois valores, está ativada ou desativada.

O vim tem muitas opções. Além dos booleanos, existem opções com um valor numérico e opções de string. Você verá exemplos disso onde eles são usados.

Defina a opção ‘ régua ‘. Isso exibe a posição do cursor no canto inferior direito da janela do vim :

  :set ruler

Rolagem

O comando Ctrl-U rola metade da tela para baixo. Pense em olhar através de uma janela de visualização para o texto e movê-la pela metade da altura da janela. Assim, a janela move-se sobre o texto, que fica para trás no arquivo. Não se preocupe se tiver um pouco de dificuldade para lembrar qual é o fim. A maioria dos usuários tem o mesmo problema.

O comando Ctrl-D move a janela de visualização para metade da tela no arquivo e rola o texto para cima na metade da tela.

  ┌────────────────┐
                                |  algum texto |
                                |  algum texto |
                                |  algum texto |
 ┌───────────────┐ |  algum texto |
 |  algum texto |  Ctrl-U -> |  |
 |  |  |  123456
 |  123456  └────────────────┘
 |  7890
 |  |  ┌────────────────┐
 |  exemplo |  Ctrl-D -> |  7890
 └───────────────┘ |  |
                                |  exemplo |
                                |  exemplo |
                                |  exemplo |
                                |  exemplo |
                                └────────────────┘

Para rolar uma linha de cada vez, use Ctrl-E (role para cima) e Ctrl-Y (role para baixo). Pense em Ctrl-E para fornecer uma linha extra. Se você usar mapeamentos de teclas compatíveis com o MSWindows, o Ctrl-Y refaz uma alteração em vez de rolar.

Para avançar uma tela inteira (exceto duas linhas), use Ctrl-F . A outra maneira é inversa, Ctrl-B é o comando a ser usado. Felizmente, Ctrl-F é Forward e Ctrl-B é Backward, isso é fácil de lembrar.

Um problema comum é que, depois de descer muitas linhas com ” j “, seu cursor fica na parte inferior da tela. Você gostaria de ver o contexto da linha com o cursor. Isso é feito com o comando ” zz “.

  ┌─────────────────┐ ┌──────────────────┐
 |  algum texto |  |  algum texto |
 |  algum texto |  |  algum texto |
 |  algum texto |  |  algum texto |
 |  algum texto |  zz -> |  linha com cursor |
 |  algum texto |  |  algum texto |
 |  algum texto |  |  algum texto |
 |  linha com cursor |  |  algum texto |
 └─────────────────┘ └──────────────────┘

O comando ” zt ” coloca o cursor no topo, ” zb ” no fim. Para sempre manter algumas linhas de contexto em volta do cursor, use a opção ‘ scrolloff ‘ (” :set scrolloff “).

Buscas Simples

Para buscar uma string , use o comando ” / string “. Para achar a palavra “include”, por exemplo, use o comando:

 /include

Você vai perceber que ao usar o comando ” / ” o cursor pula para a ultima janela do vim, como em comandos de “:”. Alí é onde você digita a palavra. Você pode apertar o backspace(backarrow or <BS> ) para fazer correções. Use as teclas de cursor <Left> e <Right> quando necessário. Pressinar <Enter> executa o comando.

Nota: Os caracteres .*[]^%/\?~$ tem significado especial. Se quiser usa-las em busca adicione um  \ na frente delas; ver abaixo.

Para achar a próxima ocorrencia da busca use o comando ” n “. Use isso para achar os “#include” após o cursor:

 /#include

Então digite ” n ” varias vezes. Você vai para cada “#include” no texto. Você também pode usar um contador se souber qual ocorrência você quer. Logo ” 3n ” encontra a terceira ocorrência. Usar um contador com ” / ” não funciona.

O comando ” ? ” funciona como ” / ” mas busca ao contrário:

 ?word

O comando ” N ” repete a última busca na direção oposta. Logo, usar ” N ” após um ” / ” busca para trás, usar ” N ” após ” ? ” procura para frente.

Ignoring Case

Normalmente você tem que digitar exatamente o quer achar. Se você não se importa se tiver em maiúsculo ou minusculo numa palavra, use a opção ‘ ignorecase ‘:

 :set ignorecase

Se procurar por “word” agora, ele também vai retornar “Word” e “WORD”.  Para ficar case sensitive novamente use:

 :set noignorecase

Histórico

Suponha que você faça três buscas:

 /one

 /two

 /three

Agora vamos começar uma busca digitando um “/” sem apertar <Enter> . Se você apertar <Up>, o vim põe ” /three ” na linha de comando. Apertar <Enter> nesse ponto ele procura for “three”. Se você não apertar <Enter> , mas ao invés apertar <Up>, o vim muda o prompt para ” /two “. Outro <Up> move você para ” /one “.

Você também pode usar <Down> para mover o cursor através do histórico de busca na direção contrária.

Se você sabe com o que um padrão usado previamente começa, e você quer usa-lo de novo, digite o caractér antes de apertar <Up>. Com o exemplo anterior, você pode digitar ” /o<Up> ” e o vim vai colocar ” /one ” na linha de comando.

Os comandos que iniciam com “:” também tem um histórico. Isso permite você re-executar comandos prévios. Os dois históricos são distintos.

Buscando uma palavra no texto

Suponha que você veja a palavra “TheLongFunctionName” no texto e quer achar a próxima ocorrência. Você pode digitar ” /TheLongFunctionName “, mas é muita digitação.

Existe um jeito mais fácil: posicione o cursor na palavra e use o comando “*”. O vim vai procurar pela palavra no cursor.

O comando “#” faz o mesmo na outra direção. Você pode prepender um contador: “3*” busca pela terceira ocorrência da palavra que está no cursor.

Buscando por palavras completas

Se você digitar ” /the ” ele também vai corresponder com “there”. Para procurar palavras que terminam com “the” use:

 /the\>

A notação “\> ” é um marcador especial que faz a correspondência no fim da palavra. Similarmente “\<” só corresponde no começo da palavra. Logo, para procurar apenas pela palavra “the” usamos:

 /\<the\>

Isso não vai retornar “there” ou “soothe”. Note que os comandos “*” e “#” usam esses mascadores especiais para usar palavras completas.

Destacando correspondências

Enquanto editando um programa você vê uma variável chamada “nr”. Você quer checar onde ela é usada. Você pode mover o cursor para “nr” e usar o commando “*” e pressionar “n” para percorrer as ocorrências.

Existe outro caminho. Digite esse comando:

 :set hlsearch

Se você buscar por “nr” agora, o vim vai destacar todas as ocorrências. Essa é uma boa maneira de ver onde a variável é usada sem ter que digitar vários comandos.

Para desligar isso:

:set nohlsearch

Então você tem que ligar novamente se quiser usar isso novamente na próxima busca. Se você quer remover o destacamento, use esse comando:

 :nohlsearch

Isso não reseta a opção. Ao invés disso, ela desliga o destacamento. Assim que você executar a busca, o destacamento será usado novamente.

Tuning Searches

Existem algumas opções que mudam como as buscas funcionam. Essas são as mais importantes:

 :set incsearch

Isso faz com que o vim mostre a ocorrência da string de busca enquanto você a digita. Use isso para checar se a correnpondência correta será encontrada. Então pressione <Enter> para pular para a localização dela. Ou digite mais para mudar a string de busca.

 :set nowrapscan

Isso para a busca no fim do arquivo. Ou, se for uma busca contrária, no começo do arquivo. A opção “wrapscan” é ativa por padrão.

Intermezzo

Se você gosta de alguma das opções mencionadas, e usa ela todas as vezes que você usa o vim, você pode  colocar o comando no arquivo de inicialização do vim.

Se você precisar localizar o arquivo de inicialização, use este comando:

 :scriptnames

Edite o arquivo com:

 :edit ~/.vimrc

Então adicione uma linha com o comando desejado. Exemplo:

 Go:set hlsearch <Esc>

” G ” move para o fim do arquivo. ” o ” põe uma nova linha, onde você escreve o comando ” :set “. Você termina o modo de edição com <Esc> . Então escreve o arquivo:

  ZZ

Se você abrir o vim novamente, a opção ‘ hlsearch ‘ já estará selecionada.

Padrões de busca simples

O editor vim usa expressões regulares(“Regex”) para especificar a busca. Expressões Regulares são maneiras extremamente poderosas e compactas de especificar um padrão de busca.

Regex: começo e fim de uma linha

O caractere ^ ( cursor ) corresponde ao início de uma linha. O padrão “incluir” corresponde à palavra incluir em qualquer lugar da linha. Mas o padrão ” ^ include ” corresponde à palavra include apenas se estiver no início de uma linha.

O caractere $ corresponde ao final de uma linha. Portanto, ” was $ ” corresponde à palavra “was” somente se estiver no final de uma linha.

Você pode tentar pesquisar com ” / ^ the $ “, ele corresponderá apenas a uma única linha que consiste apenas na palavra “the”. O espaço em branco é importante; portanto, se uma linha contiver um espaço após a palavra, como “the”, o padrão não corresponderá.

Regex: Combinando qualquer caractere único

O. (ponto ou ponto) corresponde a qualquer caractere existente. Por exemplo, o padrão ” c.m ” corresponde a uma sequência cujo primeiro caractere é um “c”, cujo segundo caractere é qualquer coisa e cujo terceiro caractere é “m”.

Regex: Correspondência de caracteres especiais

Se você realmente deseja combinar um ponto, evite seu significado especial colocando uma barra invertida antes dele, assim: ” \. “. O mesmo vale para qualquer caractere especial ( . * [] ^% / \? ~ $ ).

Usando marcas

Quando você salta para uma posição com o comando ” G “, o vim se lembra da posição anterior a esse salto. Esta posição é chamada de marca. Para voltar de onde você veio, use este comando:

  ``

Este ` é um backtick ou caractere de aspas simples aberto.

Se você usar o mesmo comando uma segunda vez, retornará novamente. Isso ocorre porque o comando ` é um salto em si, e a posição anterior a esse salto é lembrada.

Geralmente, toda vez que você executa um comando que pode mover o cursor além da mesma linha, isso é chamado de salto. Isso inclui os comandos de pesquisa ” / ” e ” n ” (não importa a que distância esteja a correspondência). Mas o personagem não pesquisa com ” fx ” e ” tx ” ou os movimentos da palavra ” w ” e ” e “.

Além disso, ” j ” e ” k ” não são considerados um salto. Mesmo quando você usa uma contagem para fazê-los mover o cursor muito longe.

O comando “ pula para frente e para trás, entre dois pontos. O comando Ctrl-O pula para posições mais antigas (“O” significa “mais antigo”). Ctrl-I então volta para as posições mais recentes. Considere esta sequência de comandos:

  33G

  / ^ The

  Ctrl-O

Você primeiro pula para a linha 33 e, em seguida, procura uma linha que comece com “The”. Depois, com Ctrl-O, você volta para a linha 33. Outro Ctrl-O leva você de volta para onde você começou. Se você agora usa Ctrl-I, você pula para a linha 33 novamente. E para a partida de “The” com outro Ctrl-I .

Nota: Ctrl-I é o mesmo que <Tab> .

O comando ” : pula ” fornece uma lista de posições para as quais você pulou. A entrada que você usou pela última vez está marcada com ” > “.

Marcas nomeadas

O vim permite que você coloque marcas no texto. O comando ” ma ” marca o local abaixo do cursor como marca “a”. Você pode colocar 26 marcas ( a a z ) no seu texto. Você não pode vê-los, é apenas uma posição que o vim lembra.

Para ir a uma marca, use o comando ` { mark }, onde { mark } é a letra da marca. Assim, para ir para a marca a:

  `a

A marca de comando (aspas simples ou apóstrofo) move você para o início da linha que contém a marca. Isso difere do comando ` mark , que o move para a coluna marcada.

As marcas podem ser muito úteis ao trabalhar em duas partes relacionadas em um arquivo. Suponha que você tenha algum texto próximo ao início do arquivo que precisa examinar, enquanto trabalha em algum texto próximo ao final do arquivo.

Vá para o texto no início e coloque a marca “s” (início) lá:

  ms

Em seguida, vá para o texto em que deseja trabalhar e coloque a marca “e” (final) lá:

  me

Agora você pode se mover e, quando quiser ver o início do arquivo, use isso para pular para lá:

  's

Em seguida, você pode usar ” para voltar para onde estava ou para ir para o texto em que estava trabalhando no final.

Não há nada de especial em usar “s” para o início e “e” para o fim, eles são fáceis de lembrar.

Você pode usar este comando para obter uma lista de marcas:

  :marks

Você notará algumas marcas especiais. Esses incluem:

Operadores e movimentos

O comando ” dw ” exclui uma palavra. Você pode reconhecer o comando ” w ” como o comando mover palavra. De fato, o comando ” d ” pode ser seguido por qualquer comando de movimento e é excluído do local atual para o local onde o cursor termina. O comando ” 4w “, por exemplo, move o cursor sobre quatro palavras. O comando d4w exclui quatro palavras.

  Errar é humano.  Perdoar é divino.  É necessário respirar. 
                  --------------------->
  d4w
 Errar é humano.  É necessário respirar.

O vim exclui apenas até a posição em que o movimento leva o cursor. Isso ocorre porque o vim sabe que você provavelmente não deseja excluir o primeiro caractere de uma palavra. Se você usar o comando ” e ” para ir para o final de uma palavra, o vim acha que deseja incluir esse último caractere:

  Errar é humano.  É necessário respirar. 
                 ---------->
  d2e
 Errar é humano.  É necessário.

A inclusão do caractere sob o cursor depende do comando que você usou para mover para esse caractere. Isso é chamado de “exclusivo” quando o personagem não está incluído e “inclusivo” quando está.

O comando ” $ ” se move para o final de uma linha. O comando ” d $ ” exclui do cursor até o final da linha, que é um movimento inclusivo, portanto, o último caractere da linha é incluído na operação de exclusão:

  Errar é humano.  é divino. 
                  -------->
  d $
 Errar é humano.

Há um padrão aqui: movimento do operador. Você primeiro digita um comando do operador. Por exemplo, ” d ” é o operador de exclusão. Então você digita um comando de movimento como ” 4l ” ou ” w “. Dessa forma, você pode operar com qualquer texto que possa mover.

Alterar texto

Outro operador é ” c “, altere. Ele age exatamente como o operador ” d “, exceto que o deixa no modo Inserir. Por exemplo, ” cw ” altera uma palavra. Ou, mais especificamente, ele exclui uma palavra e o coloca no modo Inserir.

  Errar é humano 
    ------->
  c2wbe <Esc>
 Ser humano

Este ” c2wbe <Esc> ” contém estes bits:

O espaço antes de “humano” não é excluído. O operador c funciona exatamente como o operador d , com uma exceção: ” cw “. Na verdade, funciona como ” ce “, mude para o final da palavra. Portanto, o espaço após a palavra não é incluído, uma exceção que remonta ao antigo Vi . Como muitas pessoas estão acostumadas a isso agora, a inconsistência permaneceu no vim .

Mais alterações

Como ” dd ” exclui uma linha inteira, ” cc ” altera uma linha inteira. Mantém o recuo existente (espaço em branco à esquerda).

Assim como ” d $ ” é excluído até o final da linha, ” c $ ” é alterado até o final da linha. É como fazer ” d $ ” para excluir o texto e, em seguida, ” a ” para iniciar o modo Inserir e anexar novo texto.

Atalhos

Alguns comandos de movimento do operador são usados ​​com tanta frequência que recebem um comando de letra única:

Onde colocar a contagem

Os comandos ” 3dw ” e ” d3w ” excluem três palavras. Se você quer ser realmente exigente, o primeiro comando, ” 3dw “, exclui uma palavra três vezes; o comando ” d3w ” exclui três palavras uma vez, o que é uma diferença sem distinção. Você pode realmente colocar em duas contagens, no entanto. Por exemplo, ” 3d2w ” exclui duas palavras, repetidas três vezes, para um total de seis palavras.

Substituindo por um caractere

O comando ” r ” não é um operador. Ele espera que você digite um caractere e substitui o caractere sob o cursor por ele. Você pode fazer o mesmo com ” cl ” ou com o comando ” s “, mas com ” r ” você não precisa pressionar <Esc>

  há algo sombrio aqui 
 rT
 Há algo sombrio aqui 
  rt
 Há algo grong aqui
  rw
 Há algo errado aqui

O uso de uma contagem com ” r ” faz com que muitos caracteres sejam substituídos pelo mesmo caractere. Exemplo:

  Há algo errado aqui 
  5rx
 Há algo xxxxx aqui

Para substituir um caractere por uma quebra de linha, use ” r <Enter> “. Isso exclui um caractere e insere uma quebra de linha. O uso de uma contagem aqui se aplica apenas ao número de caracteres excluídos: ” 4r <Enter> ” substitui quatro caracteres por uma quebra de linha.

Repetindo uma mudança

O comando ” . ” É um dos comandos mais simples e poderosos do vim . Repete a última alteração. Por exemplo, suponha que você esteja editando um arquivo HTML e deseje excluir todas as tags <B> . Você posiciona o cursor no primeiro < e exclui o <B> com o comando ” df> “. Você então vai para o < do próximo </B> e o mata usando o comando ” . “. O comando ” . ” Executa o último comando de alteração (nesse caso, ” df> “). Para excluir outra marca, posicione o cursor no < e use o comando ” . “.

  Para <B> gerar </B> uma tabela com <B> conteúdo 
 f < encontre primeiro <--->
 df> excluir para> ->
 f < encontre o próximo <--------->
 .  repita df> --->
 f < encontre o próximo <------------->
 .  repita df> ->

O comando ” . ” Funciona para todas as alterações feitas, exceto para ” u ” (desfazer), Ctrl-R (refazer) e comandos que começam com dois pontos (:).

Outro exemplo: você deseja alterar a palavra “quatro” para “cinco”. Aparece várias vezes no seu texto. Você pode fazer isso rapidamente com esta sequência de comandos:

etc.

Modo Visual

Para excluir itens simples, as alterações de movimento do operador funcionam muito bem. Mas muitas vezes não é tão fácil decidir qual comando se move sobre o texto que você deseja alterar. Então você pode usar o modo Visual.

Você inicia o modo Visual pressionando ” v “. Você move o cursor sobre o texto em que deseja trabalhar. Enquanto você faz isso, o texto é destacado. Por fim, digite o comando do operador.

Por exemplo, para excluir da metade de uma palavra para a outra palavra:

  Esta é uma amostra de exame do modo visual 
                 --------->
	  velllld
 Este é um exemplo de modo visual

Ao fazer isso, você realmente não precisa contar quantas vezes precisa pressionar ” l ” para terminar na posição correta. Você pode ver imediatamente o texto que será excluído quando pressionar ” d “.

Se a qualquer momento você decidir que não quer fazer nada com o texto realçado, basta pressionar <Esc> e o modo Visual será interrompido sem fazer nada.

Selecionando linhas

Se você deseja trabalhar em linhas inteiras, use ” V ” para iniciar o modo Visual. Você verá imediatamente que toda a linha está realçada, sem se mover. Quando você se move para a esquerda ou direita, nada muda. Quando você move para cima ou para baixo, a seleção é estendida por linhas inteiras por vez.

Por exemplo, selecione três linhas com ” Vjj “:

  ┌────────────────────────┐
                   |  texto mais texto |
                >>  mais texto mais texto | 
 linhas selecionadas >> |  texto texto texto | 
                >>  texto mais | 
                   |  mais texto mais |
                   └────────────────────────┘

Selecionando blocos

Se você deseja trabalhar em um bloco retangular de caracteres, use Ctrl-V para iniciar o modo Visual. Isso é muito útil ao trabalhar em tabelas.

  nome Q1 Q2 Q3
 pierre 123 455 234
 João 0 90 39
 steve 392 63 334

Para excluir a coluna ” Q2 ” do meio, mova o cursor para ” Q ” de ” Q2 “. Pressione Ctrl-V para iniciar o modo Visual em blocos. Agora mova o cursor três linhas para baixo com ” 3j ” e para a próxima palavra com ” w “. Você pode ver o primeiro caractere da última coluna incluído. Para excluí-lo, use ” h “. Agora pressione ” d ” e a coluna do meio se foi.

Indo para o outro lado

Se você selecionou algum texto no modo Visual e descobre que precisa alterar a outra extremidade da seleção, use o comando ” o “. O cursor irá para o outro extremo, e você pode mover o cursor para mudar onde a seleção começa. Pressionar ” o ” novamente leva você de volta ao outro lado. Ao usar a seleção em blocos, você tem quatro cantos. ” o ” leva você a um dos outros cantos, na diagonal. Use ” O ” para ir para o outro canto na mesma linha. Observe que ” o ” e ” O ” no modo Visual funcionam de maneira muito diferente do modo Normal, onde eles abrem uma nova linha abaixo ou acima do cursor.

Movendo texto

Quando você exclui algo com o ” d “, ” x ” ou outro comando, o texto é salvo. Você pode colá-lo novamente usando o comando p . (O nome do vim para isso é “put”).

Veja como isso funciona. Primeiro você excluirá uma linha inteira, colocando o cursor na linha que deseja excluir e digitando ” dd “. Agora você move o cursor para onde deseja colocar a linha e use o comando ” p ” (put). A linha é inserida na linha abaixo do cursor.

  uma linha uma linha uma linha
	 linha 2 dd linha 3 p linha 3
	 linha 3 linha 2

Como você excluiu uma linha inteira, o comando ” p ” colocou a linha de texto abaixo do cursor. Se você excluir parte de uma linha (uma palavra, por exemplo), o comando ” p ” a colocará logo após o cursor.

  Um pouco mais chato tente texto para comandos fora. 
		  ---->
		  dw
 Um pouco de texto mais chato para sair dos comandos. 
		  ------->
		  welp
 Um pouco de texto mais chato para experimentar comandos.

Colocando

O comando ” P ” coloca texto como ” p “, mas antes do cursor. Quando você excluiu uma linha inteira com ” dd “, ” P ” a coloca novamente acima do cursor. Quando você excluiu uma palavra com ” dw “, ” P ” a coloca novamente antes do cursor.

Você pode repetir a colocação quantas vezes quiser. O mesmo texto será usado.

Você pode usar uma contagem com ” p ” e ” P “. O texto será repetido quantas vezes for especificado com a contagem. Assim, ” dd ” e ” 3p ” colocam três cópias da mesma linha excluída.

Trocando Personagens

O vim facilita a correção de problemas como digitar acidentalmente “teh” para “the”. Basta colocar o cursor no e de “teh” e executar o comando “xp”. Isso funciona da seguinte maneira: ” x ” exclui o caractere e o coloca em um registro. ” p ” coloca o texto após o cursor, após o “h”.

  teh
 x 
 º
 p
 a

Copiando texto

Para copiar texto de um lugar para outro, você pode excluí-lo, usar ” u ” para desfazer a exclusão e, em seguida, ” p ” para colocá-lo em outro lugar. Existe uma maneira mais fácil: puxar. O operador ” y ” copia o texto em um registro. Em seguida, um comando ” p ” pode ser usado para colocá-lo.

Arrancar é apenas um nome de cópia para copiar. A letra ” c ” já foi usada para o operador de alteração e ” y ” ainda estava disponível. Chamar esse operador de “puxão” tornou mais fácil lembrar de usar a tecla ” y “.

Como ” y ” é um operador, use ” yw ” para puxar uma palavra. Uma contagem é possível como sempre. Para puxar duas palavras, use ” y2w “. Exemplo:

  let sqr = LongVariable * 
		  -------------->
		  y2w
	 let sqr = LongVariable * 
			  p
	 let sqr = LongVariable * LongVariable

Observe que ” yw ” inclui o espaço em branco após uma palavra. Se você não quiser isso, use ” ye “.

O comando ” yy ” puxa uma linha inteira, assim como ” dd ” exclui uma linha inteira. Inesperadamente, enquanto ” D ” exclui do cursor até o final da linha, ” Y ” funciona como ” yy “, puxa a linha inteira. Cuidado com esta inconsistência! Use ” y $ ” para puxar para o final da linha.

  uma linha de texto yy
         linha 2
         última linha
	 uma linha de texto
	 linha 2 p
 	 última linha
	 uma linha de texto
	 linha 2
	 uma linha de texto
	 última linha

Usando a área de transferência

Se você estiver usando a versão da GUI do vim ( gvim ), poderá encontrar o item “Copiar” no menu “Editar”. Primeiro, selecione algum texto com o modo Visual e, em seguida, use o menu Editar / Copiar. O texto selecionado agora é copiado para a área de transferência. Você pode colar o texto em outros programas. No próprio vim também.

Se você copiou o texto para a área de transferência em outro aplicativo, poderá colá-lo no vim com o menu Editar / Colar. Isso funciona nos modos Normal e Inserir. No modo Visual, o texto selecionado é substituído pelo texto colado.

O item de menu “Recortar” exclui o texto antes de colocá-lo na área de transferência. Os itens “Copiar”, “Recortar” e “Colar” também estão disponíveis no menu pop-up (somente quando houver um menu pop-up, é claro). Se o seu vim tiver uma barra de ferramentas, você também poderá encontrar esses itens lá.

Se você não estiver usando a GUI, ou se não gostar de usar um menu, precisará usar outra maneira. Você usa os comandos normais ” y ” (arrancar) e ” p ” (colocar), mas acrescenta “* (estrela de aspas duplas) antes dele. Para copiar uma linha para a área de transferência:

  "* yy

Para colocar o texto da área de transferência novamente no texto:

  "* p

Isso funciona apenas em versões do vim que incluem suporte à área de transferência.

Objetos de texto

Se o cursor estiver no meio de uma palavra e você quiser excluir essa palavra, será necessário voltar ao início antes de poder executar “dw”. Existe uma maneira mais simples de fazer isso: ” daw “.

  este é um texto de exemplo. 
		  daw
	 isso é algum texto.

O ” d ” de ” daw ” é o operador de exclusão. ” aw ” é um objeto de texto. Dica: ” aw ” significa “Uma Palavra”. Assim, ” daw ” é “Excluir uma palavra”. Para ser mais preciso, o espaço em branco após a palavra também é excluído (o espaço em branco antes da palavra no final da linha).

Usar objetos de texto é a terceira maneira de fazer alterações no vim . Já tínhamos movimento de operador e modo visual. Agora adicionamos objeto de texto do operador.

É muito semelhante ao movimento do operador, mas, em vez de operar no texto entre a posição do cursor antes e depois de um comando de movimento, o objeto de texto é usado como um todo. Não importa onde estava o objeto no cursor.

Para alterar uma frase inteira, use ” cis “. Veja este texto:

  Olá.  este 
	 é um exemplo  Somente 
	 algum texto.

Vá para o início da segunda linha, em “é um”. Agora use “cis”:

  Olá.  Somente 
	 algum texto.

O cursor está entre os espaços em branco na primeira linha. Agora você digita a nova frase “Outra linha”.

  Olá.  Outra linha.  Somente 
	 algum texto.

” cis ” consiste no operador ” c ” (alteração) e o objeto de texto “é”. Isso significa “Sentença interna”. Há também o objeto “como” (uma sentença). A diferença é que “como” inclui o espaço em branco após a frase e “é” não. Se você excluir uma frase, deseje excluir o espaço em branco ao mesmo tempo, portanto, use ” das “. Se você deseja digitar um novo texto, o espaço em branco pode permanecer, portanto, use ” cis “.

Você também pode usar objetos de texto no modo Visual. Incluirá o objeto de texto na seleção Visual. O modo visual continua, portanto, você pode fazer isso várias vezes. Por exemplo, inicie o modo Visual com ” v ” e selecione uma frase com ” como “. Agora você pode repetir ” como ” para incluir mais frases. Finalmente, você usa um operador para fazer algo com as frases selecionadas.

Modo Substituir

O comando ” R ” faz com que o vim entre no modo de substituição. Nesse modo, cada caractere digitado substitui aquele sob o cursor. Isso continua até você digitar <Esc> .

Neste exemplo, você inicia o modo Substituir no primeiro ” t ” de ” texto “:

  Isso é texto. 
 Interessante.  <Esc>
 Isto é interessante.

Você deve ter notado que esse comando substituiu 5 caracteres na linha por doze outros. O comando ” R ” estende automaticamente a linha se ficar sem caracteres para substituir. Não continuará na próxima linha.

Você pode alternar entre o modo Inserir e o modo Substituir com a tecla <Inserir> .

Ao usar <BS> (backspace) para fazer a correção, você notará que o texto antigo é colocado de volta. Assim, funciona como um comando de desfazer para o último caractere digitado.

Conclusão

Os operadores, comandos de movimento e objetos de texto oferecem a possibilidade de fazer muitas combinações. Agora que você sabe como isso funciona, você pode usar N operadores com comandos de movimento M para criar comandos N * M!

Por exemplo, existem outras maneiras de excluir partes do texto. Aqui estão alguns dos mais usados:

Se você usar ” c ” em vez de ” d “, eles se tornarão comandos de alteração. E com ” y ” você arranca o texto. E assim por diante.

Existem alguns comandos frequentemente usados ​​para fazer alterações que não cabiam em outro lugar:

O arquivo vimrc

Você provavelmente se cansou de digitar comandos que usa com muita frequência. Para iniciar o vim com todas as suas configurações e mapeamentos de opções favoritas, escreva-os no que é chamado de arquivo vimrc . O vim executa os comandos neste arquivo quando é iniciado.

Se você já possui um arquivo vimrc (por exemplo, quando o seu sysadmin tiver uma configuração para você), você poderá editá-lo desta maneira:

  :edit $ MYVIMRC

Se você ainda não possui um arquivo vimrc , é possível criar um. O comando ” : version ” menciona o nome do “user vimrc file” procurado pelo vim .

Para Unix e Macintosh, esse arquivo é sempre usado e é recomendado: ~ / .vimrc

Para MS-DOS e MS-Windows, você pode usar um destes: $ HOME / _vimrc , $ VIM / _vimrc

O arquivo vimrc pode conter todos os comandos que você digita após dois pontos. Os mais simples são para definir opções. Por exemplo, se você deseja que o vim comece sempre com a opção ‘ incsearch ‘, adicione esta linha ao seu arquivo vimrc :

  set incsearch

Para que essa nova linha entre em vigor, você precisa sair do vim e iniciá-lo novamente. Mais tarde, você aprenderá como fazer isso sem sair do vim .

Mapeamentos simples

Um mapeamento permite vincular um conjunto de comandos do vim a uma única chave. Suponha, por exemplo, que você precise cercar certas palavras com chaves. Em outras palavras, você precisa alterar uma palavra como “quantidade” para “{quantidade}”. Com o comando : map , você pode dizer ao vim que a tecla F5 faz esse trabalho. O comando é o seguinte:

  :map <F5> i {<Esc> ea} <Esc>

Ao inserir este comando, você deve inserir <F5> digitando quatro caracteres. Da mesma forma, <Esc> não é inserido pressionando a tecla <Esc> , mas digitando cinco caracteres. Cuidado com essa diferença.

Vamos dividir isso:

Depois de executar o comando ” : map “, tudo o que você precisa fazer para colocar {} em torno de uma palavra é colocar o cursor no primeiro caractere e pressionar F5 .

Neste exemplo, o gatilho é uma única chave; pode ser qualquer string. Mas quando você usa um comando vim existente, esse comando não estará mais disponível. É melhor você evitar isso.

Uma chave que pode ser usada com mapeamentos é a barra invertida. Como você provavelmente deseja definir mais de um mapeamento, adicione outro caractere. Você pode mapear ” \ p ” para adicionar parênteses em torno de uma palavra e ” \ c ” para adicionar chaves, por exemplo:

  :map \p i(<Esc> e a) <Esc>

  :map \c i{<Esc> e a} <Esc>

Você precisa digitar \ e p rapidamente após o outro, para que o vim saiba que eles pertencem um ao outro.

O comando ” : map ” (sem argumentos) lista seus mapeamentos atuais. Pelo menos os do modo Normal.

Adicionando um plug-in global

A funcionalidade do vim pode ser estendida adicionando plugins. Um plug-in nada mais é do que um arquivo de script do vim carregado automaticamente quando o vim é iniciado. Você pode adicionar um plugin com muita facilidade, soltando-o no diretório do plugin. {não disponível quando o vim foi compilado sem o | + eval | característica}

Existem dois tipos de plugins: plugins globais, usados ​​para todos os tipos de arquivos; e plug-ins de tipo de arquivo, que são usados ​​apenas para um tipo específico de arquivo.

Quando você inicia o vim , ele carrega automaticamente vários plugins globais. Você não precisa fazer nada para isso. Eles adicionam funcionalidades que a maioria das pessoas deseja usar, mas que foram implementadas como um script vim em vez de serem compiladas.

Você pode adicionar um plug-in global para adicionar funcionalidades que sempre estarão presentes quando você usa o vim . Existem apenas duas etapas para adicionar um plug-in global: obtenha uma cópia do plug-in e solte-o no diretório certo.

Obtendo um plug-in global

Alguns plugins globais vêm com o vim . Você pode encontrá-los no diretório $ VIMRUNTIME / macros e seus subdiretórios .

Outros podem ser baixados no site oficial do vim , https://vim.sourceforge.io/ .

Usando um plug-in global

Leia primeiro o texto no próprio plug-in para verificar se há condições especiais. Em seguida, copie o arquivo para o diretório do plug-in:

Exemplo para Unix (assumindo que você ainda não tinha um diretório de plugins):

  mkdir ~/.vim

  mkdir ~/.vim/plugin

  cp /usr/local/share/vim/vim60/macros/justify.vim ~ / .vim / plugin

Isso é tudo! Agora você pode usar os comandos definidos neste plugin para justificar o texto.

Em vez de colocar plugins diretamente no diretório plugin / , você pode organizá-los melhor colocando-os em subdiretórios em plugin / . Como exemplo, considere usar ” ~ / .vim / plugin / perl / *. Vim ” para todos os seus plugins Perl .

Plugins de tipo de arquivo

A distribuição vim vem com um conjunto de plugins para diferentes tipos de arquivos que você pode começar a usar com este comando:

  :filetype plugin on

Se estiver faltando um plug-in para um tipo de arquivo que você está usando, ou se encontrou um melhor, você pode adicioná-lo. Existem duas etapas para adicionar um plug-in de tipo de arquivo: obtenha uma cópia do plug-in e solte-o no diretório certo.

Opções frequentemente usadas

O vim é um programa extenso e, portanto, tem muitas opções! A maioria deles você quase nunca vai usar. Alguns dos mais úteis serão mencionados aqui. Não esqueça que você pode encontrar mais ajuda sobre essas opções com o comando ” : help “, com aspas simples antes e depois do nome da opção. Por exemplo:

  :help 'wrap'

Caso você tenha confundido um valor de opção, é possível configurá-lo de volta ao padrão colocando um e comercial (&) após o nome da opção. Exemplo:

  :set iskeyword &

O vim normalmente envolve linhas longas, para que você possa ver todo o texto. Às vezes, é melhor deixar o texto continuar à direita da janela. Então você precisa rolar o texto da esquerda para a direita para ver toda uma linha longa. Desative a finalização com este comando:

  :set nowrap

O vim rolará automaticamente o texto quando você mudar para o texto que não é exibido. Para ver um contexto de dez caracteres, faça o seguinte:

  :set sidescroll = 10

Isso não altera o texto no arquivo, apenas a maneira como ele é exibido.

A maioria dos comandos para se mover irá parar de se mover no início e no final de uma linha. Você pode alterar isso com a opção ‘ whichwrap ‘. Isso define o valor padrão:

  :set whatwrap=b,s

Isso permite que a tecla <BS> , quando usada na primeira posição de uma linha, mova o cursor para o final da linha anterior. E a tecla <Space> se move do final de uma linha para o início da próxima.

Para permitir que as teclas do cursor <Left> e <Right> também sejam quebradas, use este comando:

  :set whatwrap=b,s,<,>

Isso ainda é apenas no modo Normal. Para permitir que <Left> e <Right> façam isso também no modo Inserir:

  :set whatwrap = b,s,<,>,[,]

Existem alguns outros sinalizadores que podem ser adicionados, consulte ‘ whatwrap ‘.

Usando destaque de sintaxe

Tudo começa com um comando simples:

  :syntax enable

Isso deve funcionar na maioria das situações para obter cores nos seus arquivos. O comando vim detectará automaticamente o tipo de arquivo e carregará o realce de sintaxe correto. De repente, os comentários são azuis, palavras-chave marrons e cordas vermelhas. Isso facilita a visão geral do arquivo. Depois de um tempo, você verá que o texto em preto e branco o torna mais lento!

Se você sempre deseja usar o destaque da sintaxe, coloque o comando ” : syntax enable ” no seu arquivo vimrc .

Se você quiser destacar a sintaxe apenas quando o terminal suportar cores, poderá colocar isso no seu arquivo vimrc :

  if &t_Co> 1
    syntax enable
 endif

Se você deseja destacar a sintaxe apenas na versão da GUI, coloque o comando ” : syntax enable ” no seu arquivo gvimrc .

Escolhendo cores

O vim adivinha a cor de fundo que você está usando. Se for preto (ou outra cor escura), usará cores claras para o texto. Se for branco (ou outra cor clara), usará cores escuras para o texto. Se vim adivinhou errado, o texto será difícil de ler. Para resolver isso, defina a opção ‘ segundo plano ‘. Para um fundo escuro:

  :set background=dark

E para um fundo claro:

  :set background=light

Certifique-se de colocar isso antes do comando ” : syntax enable “, caso contrário as cores já terão sido definidas. Você pode fazer ” :syntax reset ” depois de definir ‘ background ‘ para fazer com que o vim defina as cores padrão novamente.

Se você não gostar das cores padrão, poderá selecionar outro esquema de cores. Na GUI, use o menu Editar / Esquema de cores. Você também pode digitar o comando:

  : colorscheme evening

” evening ” é o nome do esquema de cores. Existem vários outros que você pode querer experimentar. Procure no diretório $ VIMRUNTIME / colors .

Quando você encontrou o esquema de cores desejado, adicione o comando ” : colorscheme ” ao seu arquivo vimrc .

Você também pode escrever um esquema de cores. É assim que se faz:

(1) Selecione um esquema de cores que se aproxime. Copie este arquivo para o diretório vim . Para Unix, isso deve funcionar. Estes comandos são feitos no vim :

  :! mkdir ~ / .vim / colors

  :! cp $ VIMRUNTIME / colors / morning.vim ~ / .vim / colors / mine.vim

(2) Edite o arquivo do esquema de cores. Essas entradas são úteis:

Por exemplo, para tornar os comentários verdes:

  :highlight Comment ctermfg=green guifg=green

Os atributos que você pode usar para ” cterm ” e ” gui ” são ” bold ” e ” underline “. Se você quer os dois, use ” bold, underline“.

(3) Diga ao vim para sempre usar seu esquema de cores. Coloque esta linha no seu vimrc :

  colorscheme mine

Se você quiser ver como são as combinações de cores usadas com mais frequência, use este comando:

  :runtime syntax/colortest.vim

Você verá o texto em várias combinações de cores. Você pode verificar quais são legíveis e com boa aparência.

Editando outro arquivo

Quando estiver no vim , você poderá começar a editar outro arquivo usando este comando:

  :edit foo.txt

Você pode usar qualquer nome de arquivo em vez de “foo.txt”. O vim fechará o arquivo atual e abrirá o novo. Se o arquivo atual tiver alterações não salvas, no entanto, o vim exibirá uma mensagem de erro e não abrirá o novo arquivo:

  E37: Nenhuma gravação desde a última alteração (use! Para substituir)

O vim coloca um ID de erro no início de cada mensagem de erro. Se você não entender a mensagem ou o que a causou, procure esse ID no sistema de ajuda. Nesse caso:

  :help E37

Neste ponto, você tem várias alternativas. Você pode gravar o arquivo usando este comando:

  :write

Ou você pode forçar o vim a descartar suas alterações e editar o novo arquivo, usando o caractere force ( ! ):

  :edit!  foo.txt

Se você deseja editar outro arquivo, mas ainda não gravar as alterações no arquivo atual, é possível ocultá-lo:

  :hide edit foo.txt

O texto com alterações ainda está lá, mas você não pode vê-lo.

Editando uma lista de arquivos

Você pode iniciar o vim para editar uma sequência de arquivos. Por exemplo:

  vim one.c two.c three.c

Este comando inicia o vim e informa que você estará editando três arquivos. O vim exibe apenas o primeiro arquivo. Depois de concluir seu trabalho neste arquivo, para editar o próximo arquivo, use este comando:

  :next

Se houver alterações não salvas no arquivo atual, você receberá uma mensagem de erro e o ” : next ” não funcionará. Esse é o mesmo problema com ” : edit ” mencionado na seção anterior. Para abandonar as alterações:

  :next!

Mas, principalmente, você deseja salvar as alterações e passar para o próximo arquivo. Há um comando especial para isso:

  : wnext

Isso faz o mesmo que usar dois comandos separados:

  :write

  :next

Para ver qual arquivo na lista de argumentos você está editando, procure no título da janela. Deve mostrar algo como ” (2 de 3) “. Isso significa que você está editando o segundo arquivo em três arquivos.

Se você quiser ver a lista de arquivos, use este comando:

  :args

Isso é abreviação de “argumentos”. A saída pode parecer com isso:

 one.c [two.c] three.c

Esses são os arquivos que você abriu o vim com. O que você está atualmente editando, está entre colchetes.

Movendo de arquivo em arquivo

Para voltar para um arquivo:

 :previous

É como o comando ” :next “, só que se move na direção oposta. Novamente, há um comando atalho para escrever um arquivo antes de mudar:

 :wprevious

Para se mover para o último arquivo da lista:

 :last

Para voltar para o primeiro:

 :first

No entanto não existem os comandos ” :wlast ” or ” :wfirst “.

Você pode usar contadores com os comandos ” :next ” e ” :previous “. Para pular 2 arquivos:

 :2next

Arquivos de backup

O vim não faz normalmente arquivos de backup. Se você quiser um, é necessário executar o seguinte comando:

 :set backup

O nome do arquivo de backup é o nome original com um ‘~’ no fim. Se isso não te agradar , você pode mudar a extenção do arquivo:

 :set backupext=.bak

O resultado será data.txt.bak ao invés de data.txt~ .

Outra opção importante aqui é ‘ backupdir ‘. Ela especifica onde o arquivo backup é escrito. O padrão é escreve-lo na mesma pasta do arquivo original, que normalmente é o correto.

Quando a opção ‘backup‘ estiver desabilitada, mas  a opção ‘writebackup‘ estiver, o vim ainda criará um arquivo de backup. Entretanto, ele é excluído assim que a escrita for feita em cima do arquivo original. Isso funciona como garantia que a edição do arquivo não será perdida.

Se você estiver editando arquivos de código fonte, você pode querer o arquivo original antes de qualquer mudança. Mas o arquivo de backup é reescrito após cada escrita do arquivo original, logo ele contém a versão anterior do arquivo ao invés da original.

Para fazer o vim manter o arquivo original, use a opção ‘patchmode’. Ela especifica a extensão do primeiro backup de um arquivo alterado. Usualmente faz-se assim:

 :set patchmode=.orig

Agora quando você editar o arquivo data.txt pela primeira vez, fazer alterações e escrever o arquivo, o vim vai manter uma cópia inalterada com o nome “data.txt.orig“.

Se você fizer mais mudando ao arquivo, o vim vai perceber que “data.txt.orig” já existe e o deixa quieto. Arquivos de backup adicionais são nomeadoss “data.txt~”.

Se você deixar ‘patchmode‘ vazia(que é o padrão), o arquivo original, não será mantido.

Usando registradores

Quando você quer copiar diversos pedaços de um texto de um arquivo para outro, ter que mudar de arquivos e escrever no arquivo destino pode levar um longo tempo. Para evitar isso, copie cada pedaço de texto para um registrador.

Um registrador é um lugar onde o vim guarda textos. Aqui usaremos os registradores nomeados de ‘a’ à ‘z'(existem outros além desses). Vamos copiar uma frase para o registrador f.

 "fyas

O comando ” yas ” puxa uma frase como antes. É o  “f que diz ao vim que texto deve ser colocado no registrador f. Isso deve vir logo antes do comando de yank.

Agora de yank 3 linhas inteiras ao registrador l:

 "l3Y

O contador também pode ficar antes do “l. Para copiar um bloco de texto para o registador b:

 Ctrl-Vjjww"by

Perceba que a especificação de registrador “b fica logo antes do comando “y”. Isso é obrigatório. Se você coloca-lo antes do comando “w”, ele não funcionará:

Agora você tem 3 pedações de texto nos registradores f, l e b. Edite outro arquivo e coloque os textos onde quiser:

 "fp

Novamente, a especificação de registrador “f vem antes do comando  ” p “.

Você pode colocar os registradores em qualquer ordem. E o texto fica no registrador até outro texto ser copiado a ele. Logo você pode reutiliza-lo várias vezes.

Quando você deleta textos, você também pode especificar registradores. Use isso para mover textos por ai. Por exemplo: deletar uma palavra e colocar ela num registrador ‘w’:

 "wdaw

Novamente, a especificação do registrador vem antes do comando de deletar.

Ver um arquivo em read-only

Algumas vezes você quer apenas ver o conteúdo de um arquivo sem intenção de edita-la. Existe o risco de abrir no modo de edição e cometer algum erro e escreve-lo sem perceber. Para evitar isso você pode usar o vim em modo read-only.

Para abrir o vim em modo de read-only, use este comando:

 vim -R file

Num sistema Unix, este comando pode fazer a mesma coisa:

 view file

Agora você pode “editar” o arquivo em read-only. Quando você tenta usar “:w” um erro aparecerá e o arquivo não será escrito.

Quando você tenta fazer alguma mudança ao arquivo o vim te da um aviso:

 W10: Warning: Changing a readonly file

Apesar disso a mudança será feita. Isso permite formatação de arquivos, para a leitura ficar mais fácil.

Se você alterar um arquivo em read-only e quiser escreve-lo mesmo assim, use a opção “!” no comando “:w” para forçar a escrita.

Se você quiser realmente proibir qualquer mudança no arquivo, use este comando:

 vim -M file

Agora qualquer tentativa de alteração no arquivo falhará. Se tentar alterar o arquivo receberá esse erro:

 E21: Cannot make changes, 'modifiable' is off

Você pode usar o argumento “-M” para fazer o vim trabalhar num modo de visualização. Mas é algo voluntário porque os seguintes comandos removem a proteção de dentro do vim:

 :set modifiable

 :set write

Salvando arquivos com outro nome

Uma maneira experta de começar a editar um novo arquivo é usando um arquivo existente que contém várias coisas que você vai precisar. Por exemplo, escrever um novo programa que move um arquivo. Você sabe que já existe um programa que copia arquivos, assim você começa fazendo:

 :edit copy.c

Você pode deletar coisas que não precisa. Agora você precisa salvar o arquivo com um novo nome. O comando “:saveas” pode ser usado para isso:

 :saveas move.c

O vim vai escrever um arquivo sob o nome dado, e editar esse novo arquivo. A próxima vez que você usar “:write”, ele vai escrever “move.c”, e “copy.c” continua inalterado.

Quando você quiser mudar o nome de um arquivo sem escreve-lo, use este comando:

 :file move.c

O vim vai marcar o arquivo como “não editado”. Isso significa que o vim sabe que esse não é o arquivo que você editava inicialmente. Quando você tentar escrever o arquivo, você pode receber a seguinte mensagem:

 E13: File exists (use ! to override)

Isso te proteje de acidentalmente sobrescrever outro arquivo.

Splitting Windows

O jeito mais fácil de abrir uma nova janela é com o seguinte comando:

 :split

Esse comando divide a tela em duas janelas e deixa o cursor na janela superior:

 ┌──────────────────────────────────┐
	|/* file one.c */ |
	|~ |
	|~ |
	|one.c=============================|
	|/* file one.c */ |
	|~ |
	|one.c=============================|
	 |  |
        └──────────────────────────────────┘

O que você vê aqui são duas janelas no mesmo arquivo. A linha com “====” é a linha de status. Ela mostra informações sobre a janela acima dela.

As duas janelas permitem que você olhe duas partes de um mesmo arquivo. Por exemplo você pode deixar a janela superior exibindo as definições de variáveis e a janela inferior com o código que as utiliza.

O comando “Ctrl-W w” pode ser usado para alternar entre janelas. Se você tiver na janela superior, ele te joga para a inferior, e vice-versa. Os comandos “CTRL+W + CRTL+W” faz a mesma coisa.

Para fechar uma janela, use este comando:

 :close

Na verdade, qualquer comando que fecha a edição de um arquivo, como “:quit” e “ZZ”. Mas “:close” evita que você acidentalmente feche o vim quando fechar a última janela.

Se você tiver aberto várias janelas, mas agora quer se concentrar em só uma delas, esse comando será útil.

 :only

Isso fecha todas janelas com exceção da janela atual. Se alguma das outras janelas tiver mudanças não salvas, você receberá uma mensagem de erro e a janela não será fechada.

Dividindo janelas com outro arquivo

O seguinte comando abre uma segunda janela com um outro arquivo para edição:

 :split two.c

Se você estiver editando “one.c”, o resultado será o seguinte:

 ┌──────────────────────────────────┐
	|/* file two.c */ |
	|~ |
	|~ |
	|two.c=============================|
	|/* file one.c */ |
	|~ |
	|one.c=============================|
	 |  |
        └──────────────────────────────────┘

Para abrir uma janela com um novo arquivo, use:

 :new

Você pode repetir os comandos “:split” e “:new” para criar quantas janelas quiser.

Tamanho da janela

O comando ” :split ” pode receber um argumento numérico, se desejar,isso vai especificar a altura de uma nova janela. Por exemplo, o seguinte comando abre uma nova janela com 3 linhas de altura e abre o arquivo alpha.c :

 :3split alpha.c

Você pode mudar o tamanho de janelas já existentes de várias maneiras. Como por exemplo, usando um mouse para arrastar a janela para o tamanho necessário.

Ou então, para aumentar o tamanho da janela: Ctrl-W +

Para diminuí-la: Ctrl-W –

Ambos comandos podem receber contadores para aumentar ou diminuir a janela de tamanho. Logo ” 4 Ctrl-W + ” aumenta a janela em 4 linhas.

Usando o mouse

No vim você pode fazer muitas coisas rapidamente pelo teclado. Infelizmente, os comandos de redimensionamento de janela requerem bastante digitação. Nesse caso, usar o mouse é mais rápido. Posicione o ponteiro numa linha de status, aperte o botão esquerdo e arraste-a, assim, deixando a janela do tamanho que desejar.

Opções

A opção 'winheight' pode ser definida para uma altura mínima desejada de uma janela e 'winminheight' para uma altura mínima rígida. Da mesma forma,
há 'winwidth' para a largura mínima desejada e 'winminwidth' para a largura mínima rígida. A opção 'igual sempre', quando definida, faz com que o vim
iguale os tamanhos das janelas quando uma janela é fechada ou aberta.

Separações verticais

O comando split cria uma nova janela acima de janelas existentes. Para criar uma nova janela ao lado de outra, use:

 :vsplit

ou:

 :vsplit two.c

O resultado fica algo assim:

 ┌──────────────────────────────────────┐
	|/* file two.c */ ||/* file one.c */ ||||
	|~ ||~ ||||
	|~ ||~ ||||
	|~ ||~ ||||
	|two.c===============one.c=============|
	 |  |
        └──────────────────────────────────────┘

Também existe o comando ” :vnew “, que abre uma nova janela com um novo arquivo em branco. Outro jeito de fazer isso é:

 :vertical new

O comando ” :vertical ” pode ser inserido antes de outros comandos de separação de janelas. Isso causará que o vim separe as janelas verticalmente.

Movendo entre janelas

Já que você pode dividir janelas verticalmente e horizontalmente o quanto quiser, você pode criar varios layouts de janelas. Então, pode usar estes comandos para se mover por elas:

Moving windows

Você dividiu algumas janelas, mas agora elas estão nos lugares errados. Então, você precisa de um comando para reorganiza-las. Por exemplo:

 ┌──────────────────────────────────┐
	|/* file two.c */ |
	|~ |
	|~ |
	|two.c=============================|
	|/* file three.c */ |
	|~ |
	|~ |
	|three.c===========================|
	|/* file one.c */ |
	|~ |
	|one.c=============================|
	 |  |
        └──────────────────────────────────┘

Claramente, a última janelas devia estar no topo. Mova-se para ela (usando Ctrl-W w ) e digite este comando: Ctrl-W K

Ele usa a letra K maiúscula. A janela é movida para o topo. Você vai perceber que K é novamente usado para se mover para cima. Quando você tem divisões verticais, Ctrl-W K move a janela atual pro topo e faz ela ocupar toda a largura do vim. Se este for seu layout:

 ┌───────────────────────────────────────────┐
	|/* two.c */ ||/* three.c */ ||/* one.c */ |
	|~ ||~ ||~ |
	|~ ||~ ||~ |
	|~ ||~ ||~ |
	|~ ||~ ||~ |
	|~ ||~ ||~ |
	|two.c=========three.c=========one.c========|
	 |  |
        └───────────────────────────────────────────┘

Então usar Ctrl-W K na janela do meio ( three.c ) resultará em:

 ┌───────────────────────────────────────────┐
	|/* three.c */ |
	|~ |
	|~ |
	|three.c====================================|
	|/* two.c */ ||/* one.c */ ||||
	|~ ||~ ||||
	|two.c==================one.c===============|
	 |  |
	└───────────────────────────────────────────┘

Os outros comandos similares:

Comandos para todas as janelas

Quando você tiver várias janelas abertas e quiser sair do vim, pode fechar cada janela separadamente. Uma maneira mais rápida é usar este comando:

 : qall

Isso significa "sair de tudo". Se alguma das janelas contiver alterações, o vim não sairá. O cursor será posicionado automaticamente em uma janela com alterações.
Você pode então usar ":write" para salvar as alterações ou ":quit!" Para descartá-las.

Se você sabe que há janelas com alterações e deseja salvar todas essas alterações, use este comando:

 :wall

Isso significa "escrever tudo". Mas, na verdade, ele apenas grava arquivos com alterações.
O comando vim sabe que não faz sentido gravar arquivos que não foram alterados.

E então há a combinação de ":qall" e ":wall": o comando "write and quit all":

 : wqall

Isso grava todos os arquivos modificados e fecha o vim.

Finalmente, há um comando que fecha o vim e descarta todas as alterações:

 :qall!

Cuidado, não há como desfazer este comando!

Abrindo uma janela para cada arquivo

Para fazer o vim abrir uma janela para cada arquivo, inicie-o com o argumento “-o”:

 vim -o one.txt two.txt three.txt

Isto resulta em:

 ┌───────────────────────────────┐
	|file one.txt |
	|~ |
	|one.txt========================|
	|file two.txt |
	|~ |
	|two.txt========================|
	|file three.txt |
	|~ |
	|three.txt======================|
	 |  |
	└───────────────────────────────┘

O argumento ” -o ” é usado para ter janelas verticalmente divididas.

Quando o vim já está em execução, o comando ” :all ” abre uma janela para cada arquivo fornecido. ” :vertical all ” faz o mesmo com divisões verticais.

Viewing Differences With vimdiff

There is a special way to start vim , which shows the differences between two files. Let’s take a file “main.c” and insert a few characters in one line. Write this file with the ‘backup’ option set, so that the backup file “main.c~” will contain the previous version of the file.

Type this command in a shell (not in vim ):

Existe uma maneira especial de iniciar o vim, que mostra as diferenças entre dois arquivos. Vamos pegar um arquivo "main.c" e inserir alguns caracteres em uma linha.
Grave este arquivo com a opção 'backup' definida, de forma que o arquivo de backup "main.c ~" contenha a versão anterior do arquivo.

Digite este comando em um shell (não no vim):

 vimdiff main.c~ main.c

O vim iniciará com duas janelas lado a lado. Você só verá as linhas contendo a linha alterada e algumas outras linhas que estão acima e abaixo dela.

 VV VV
	┌─────────────────────────────────────────┐
	|+ +--123 lines: /* a|+ +--123 lines: /* a| <- fold|||
	 | text | text |
	 | text | text |
	 | text | text |
	 | text | changed text | <- changed line
	 | text | text |
	 | text | ------------------| <- deleted line
	 | text | text |
	 | text | text |
	 | text | text |
	|+ +--432 lines: text|+ +--432 lines: text| <- fold|||
	 | ~ | ~ |
	 | ~ | ~ |
	|main.c~==============main.c==============|
	 |  |
	└─────────────────────────────────────────┘

Essa imagem não mostra os destacamentos, use o comando vimdiff para ver melhor.

As linhas que não foram modificadas foram recolhidas em uma linha. Isso é chamado de dobra fechada. Eles são indicados na imagem com ” <dobra “. Assim, a linha de dobra única no topo representa 123 linhas de texto. Essas linhas são iguais nos dois arquivos.

A linha marcada com ” <linha alterada ” é destacada e o texto inserido é exibido com outra cor. Isso mostra claramente qual é a diferença entre os dois arquivos.

A linha que foi excluída é exibida com ” — ” na janela main.c. Veja o marcador ” <- linha excluída ” na imagem. Esses personagens não estão realmente lá. Eles apenas preenchem main.c, para que ele exiba o mesmo número de linhas que a outra janela.

A coluna da dobra

Cada janela possui uma coluna à esquerda com um fundo ligeiramente diferente. Na imagem acima, estes são indicados com “VV”. Você percebe que há um caractere positivo lá, na frente de cada dobra fechada. Mova o ponteiro do mouse para esse sinal de mais e clique no botão esquerdo. A dobra será aberta e você poderá ver o texto que ela contém.

A coluna da dobra contém um sinal de menos para uma dobra aberta. Se você clicar nisto -, a dobra será fechada. Obviamente, isso só funciona quando você tem um mouse em funcionamento. Você também pode usar “zo” para abrir uma dobra e “zc” para fechá-la.

Diffing no vim

Outra maneira de iniciar no modo diff pode ser feita a partir do vim . Edite o arquivo “main.c”, faça uma divisão e mostre as diferenças:

  :edit main.c

  :diffsplit vertical main.c ~

O comando ” : vertical ” é usado para fazer a janela se dividir verticalmente. Se você omitir isso, obterá uma divisão horizontal.

Se você possui um arquivo de correção ou diff, pode usar a terceira maneira de iniciar o modo diff. Primeiro edite o arquivo ao qual o patch se aplica. Diga ao vim o nome do arquivo de correção:

  :edit main.c

  :diffpatch vertical main.c.diff

AVISO: O arquivo de correção deve conter apenas uma correção para o arquivo que você está editando. Caso contrário, você receberá muitas mensagens de erro e alguns arquivos poderão ser corrigidos inesperadamente.

O patch será feito apenas na cópia do arquivo no vim . O arquivo no seu disco rígido permanecerá inalterado (até você decidir gravá-lo).

Encadernação de rolagem

Quando os arquivos tiverem mais alterações, você poderá rolar da maneira usual. O vim tentará manter as duas janelas na mesma posição, para que você possa ver facilmente as diferenças lado a lado.

Quando você não quiser isso por um momento, use este comando:

  :set noscrollbind

Saltando para Alterações

Quando você desabilitou a dobragem de alguma maneira, pode ser difícil encontrar as alterações. Use este comando para avançar para a próxima alteração:

  ] c

Para ir para o outro lado, use:

  [c

Precedeu uma contagem para pular mais longe.

Removendo alterações

Você pode mover o texto de uma janela para outra. Isso remove diferenças ou adiciona novas. O comando vim não mantém o destaque atualizado em todas as situações. Para atualizá-lo, use este comando:

  : diffupdate

Para remover uma diferença, você pode mover o texto em um bloco realçado de uma janela para outra. Veja o exemplo “main.c” e “main.c ~” acima. Mova o cursor para a janela esquerda, na linha que foi excluída na outra janela. Agora digite este comando:

  dp

A alteração será removida colocando o texto da janela atual na outra janela. “dp” significa “diff put”.

Você também pode fazer o contrário. Mova o cursor para a janela direita, para a linha em que “alterado” foi inserido. Agora digite este comando:

  do

A alteração será removida agora, obtendo o texto da outra janela. Como não há mais alterações agora, o vim coloca todo o texto em uma dobra fechada. “do” significa “diff obtenção”. “dg” teria sido melhor, mas isso já tem um significado diferente (“dgg” exclui do cursor até a primeira linha).

Opções diversas

A opção ‘ laststatus ‘ pode ser usada para especificar quando a última janela tem uma linha de status:

Muitos comandos que editam outro arquivo têm uma variante que divide a janela. Para comandos da linha de comando, isso é feito acrescentando um “s”. Por exemplo: ” : tag ” pula para uma tag, ” : stag ” divide a janela e pula para uma tag.

Para comandos no modo Normal, um Ctrl-W é anexado. Ctrl- ^ pula para o arquivo alternativo, Ctrl-W Ctrl- ^ divide a janela e edita o arquivo alternativo.

A opção ‘ splitbelow ‘ pode ser definida para fazer uma nova janela aparecer abaixo da janela atual. A opção ‘ splitright ‘ pode ser definida para fazer uma janela dividida verticalmente aparecer à direita da janela atual.

Ao dividir uma janela, você pode acrescentar um comando modificador para saber onde a janela deve aparecer:

Páginas da guia

Você deve ter notado que as janelas nunca se sobrepõem. Isso significa que você fica rapidamente sem espaço na tela. A solução para isso é chamada de páginas da guia.

Suponha que você esteja editando “este arquivo”. Para criar uma nova página de guia, use este comando:

  : tabedit thatfile

Isso editará o arquivo “thatfile” em uma janela que ocupa toda a janela do vim. E você notará uma barra na parte superior com os dois nomes de arquivo:

  ┌─────────────────────────────────┐
	 |  thisfile |  / thatfile / __________ X |  (esse arquivo está em negrito)
	 | / * esse arquivo * / |
	 | isso |
	 | isso |
	 | ~ |
	 | ~ |
	 | ~ |
	 |  |
	 └─────────────────────────────────┘

Agora você tem duas páginas de guia. O primeiro tem uma janela para “thisfile” e o segundo uma janela para “thatfile”. É como duas páginas uma em cima da outra, com uma guia destacada em cada página mostrando o nome do arquivo.

Agora use o mouse para clicar em “thisfile” na linha superior. O resultado é

  ┌─────────────────────────────────┐
	 |  / thisfile / |  esse arquivo __________ X |  (este arquivo está em negrito)
	 | / * thisfile * / |
	 | isso |
	 | isso |
	 | ~ |
	 | ~ |
	 | ~ |
	 |  |
	 └─────────────────────────────────┘

Assim, você pode alternar entre as guias clicando no rótulo na linha superior. Se você não possui um mouse ou não deseja usá-lo, pode usar o comando “gt”. Você pode lembrá-lo como uma abreviação de “Goto Tab”.

Agora vamos criar outra aba com o comando:

  :tab split

Isso cria uma nova página de guia com uma janela que está editando o mesmo buffer que a janela em que estávamos:

  ┌────────────────────────────────────┐
	 |  thisfile |  / thisfile / |  thatfile __X |  (este arquivo está em negrito)
	 | / * thisfile * / |
	 | isso |
	 | isso |
	 | ~ |
	 | ~ |
	 | ~ |
	 |  |
	 └────────────────────────────────────┘

Você pode colocar ” : tab ” antes de qualquer comando Ex que abrir uma janela. A janela será aberta em uma nova página de guia. Outro exemplo:

  :tab help gt

Irá mostrar o texto de ajuda para ” gt ” em uma nova página de guia.

Mais algumas coisas que você pode fazer com as guias:

• clique com o mouse no espaço após o último rótulo. A próxima aba será selecionada, como com ” gt “.
• clique com o mouse no “X” no canto superior direito. A ficha de registro atual será fechada. A menos que haja alterações não salvas na ficha de registro atual.
• clique duas vezes com o mouse na linha superior. Uma nova aba será criada.
• o comando ” tabonly “. Fecha todas as guias, exceto a atual. A menos que haja alterações não salvas em outras guias.

Macros

O comando ” . ” Repete a alteração anterior. Mas e se você quiser fazer algo mais complexo do que uma única alteração? É aí que entra a gravação de comandos, mais conhecida como macro . Existem três etapas:

(1) O comando ” q {register} ” inicia a gravação das teclas digitadas no registro chamado {register} . O nome do registro deve estar entre a e z .

(2) Digite seus comandos.

(3) Para finalizar a gravação, pressione q (sem nenhum caractere extra).

Agora você pode executar a macro digitando o comando ” @ {register }”. Veja como usar esses comandos na prática. Você tem uma lista de nomes de arquivos parecidos com este:

  stdio.h 
	 fcntl.h 
	 unistd.h 
	 stdlib.h

E o que você quer é o seguinte:

  #include "stdio.h" 
	 #include "fcntl.h" 
	 #include "unistd.h" 
	 #include "stdlib.h" 

Você começa movendo para o primeiro caractere da primeira linha. Em seguida, você executa os seguintes comandos:

Agora que você fez o trabalho uma vez, pode repetir a alteração digitando o comando ” @a ” três vezes.

O comando ” @a ” pode ser precedido por uma contagem, que fará com que a macro seja executada esse número de vezes. Nesse caso, você digitaria:

  3@a

Mover e executar

Você pode ter as linhas que deseja alterar em vários lugares. Basta mover o cursor para cada local e usar o comando ” @a “. Se você fez isso uma vez, pode fazê-lo novamente com ” @@ “. Isso é um pouco mais fácil de digitar. Se você agora executar o registro b com ” @b “, o próximo ” @@ ” usará o registro b .

Se você comparar o método de reprodução com o uso de ” . “, Há várias diferenças. Primeiro de tudo, ” . ” Pode repetir apenas uma alteração. Como visto no exemplo acima, ” @a ” pode fazer várias alterações e se mover também. Em segundo lugar, ” . ” Só pode lembrar a última alteração. A execução de um registro permite fazer alterações e ainda usar ” @a ” para reproduzir os comandos gravados. Finalmente, você pode usar 26 registros diferentes. Assim, você pode se lembrar de 26 sequências de comandos diferentes para executar.

Usando Registradores

Os registros usados ​​para a gravação são os mesmos que você usou para puxar e excluir comandos. Isso permite que você misture a gravação com outros comandos para manipular os registros.

Suponha que você tenha gravado alguns comandos no registro n . Quando você executa isso com ” @n “, percebe que fez algo errado. Você pode tentar gravar novamente, mas talvez cometa outro erro. Em vez disso, use este truque:

Agora você pode executar os comandos corrigidos com ” @n “. Se seus comandos gravados incluírem quebras de linha, ajuste os dois últimos itens no exemplo para incluir todas as linhas.

Anexando a um registro

Até agora, usamos uma letra minúscula para o nome do registro. Para anexar a um registro, use uma letra maiúscula.

Suponha que você tenha gravado um comando para alterar uma palavra para registrar c . Funciona corretamente, mas você gostaria de adicionar uma pesquisa para a próxima palavra a ser alterada. Isso pode ser feito com:

  qC/palavra\<Enter\>q

Você começa com ” qC “, que grava no registro c e anexa. Assim, escrever em um nome de registro em maiúsculas significa anexar ao registro com a mesma letra, mas em minúsculas.

Isso funciona tanto com a gravação quanto com os comandos yank e delete. Por exemplo, você deseja coletar uma sequência de linhas no registro a. Arranque a primeira linha com:

  "aY

Agora vá para a segunda linha e digite:

  "AY

Repita este comando para todas as linhas. O registro a agora contém todas essas linhas, na ordem em que você as arrancou.

Substituição

O comando ” : substitute ” permite executar substituições de seqüência de caracteres em todo um intervalo de linhas. A forma geral deste comando é a seguinte:

  : [range] substitute / from / to / [flags]

Este comando altera a cadeia ” de ” para a cadeia ” para ” nas linhas especificadas com [range] . Por exemplo, você pode alterar “Professor” para “Professor” em todas as linhas com o seguinte comando:

  :%substitute/Professor/Teacher/

Nota: O comando ” : substitute ” quase nunca é explicitado completamente. Na maioria das vezes, as pessoas usam a versão abreviada ” : s “. A partir daqui, a abreviação será usada.

O ” % ” antes do comando especifica que o comando funciona em todas as linhas. Sem um intervalo, ” : s ” funciona apenas na linha atual.

Por padrão, o comando ” : substitute ” altera apenas a primeira ocorrência em cada linha. Por exemplo, o comando anterior altera a linha:

  O professor Smith criticou o professor Johnson hoje.

para:

  O professor Smith criticou o professor Johnson hoje.

Para alterar todas as ocorrências na linha, você precisa adicionar o sinalizador g (global). O comando:

  :%s/Professor/Teacher/g

resulta em (começando com a linha original):

  O professor Smith criticou o professor Johnson hoje.

Outros sinalizadores incluem p (impressão), que faz com que o comando ” : substitute ” imprima a última linha que ele altera. O sinalizador c (confirmar) informa ” : substitute ” para solicitar uma confirmação antes que ele execute cada substituição. Digite o seguinte:

  :%s/Professor/Teacher/c

O vim encontra a primeira ocorrência de “Professor” e exibe o texto que está prestes a mudar. Você recebe o seguinte prompt:

  substituir por professor (s / n / a / q / l / ^ E / ^ Y)?

Neste ponto, você deve inserir uma das seguintes respostas:

A parte “from” do comando substituto é na verdade um padrão. O mesmo tipo usado para o comando de pesquisa. Por exemplo, este comando substitui apenas “the” quando aparece no início de uma linha:

  :s/^the/these/

Se você estiver substituindo por uma parte “de” ou “para” que inclua uma barra, será necessário colocar uma barra invertida antes dela. Uma maneira mais simples é usar outro caractere em vez da barra. Uma vantagem, por exemplo:

  : s + um / dois + um ou dois +

Intervalos de comando

O comando ” : substitute ” e outros comandos : podem ser aplicados a uma seleção de linhas. Isso é chamado de intervalo.

A forma simples de um intervalo é {number}, {number} . Por exemplo:

  : 1,5s / isto / aquilo / g

Executa o comando substituto nas linhas 1 a 5. A linha 5 está incluída. O intervalo é sempre colocado antes do comando.

Um único número pode ser usado para endereçar uma linha específica:

  : 54s / Presidente / Louco /

Alguns comandos funcionam no arquivo inteiro quando você não especifica um intervalo. Para fazê-los funcionar na linha atual, o endereço ” . ” É usado. O comando ” : write ” funciona assim. Sem um intervalo, ele grava o arquivo inteiro. Para fazê-lo gravar apenas a linha atual em um arquivo:

  : .write otherfile

A primeira linha sempre tem o número um. E a última linha? O caractere ” $ ” é usado para isso. Por exemplo, para substituir nas linhas do cursor até o final:

  :., $ s / sim / não /

O intervalo ” % ” que usamos anteriormente é realmente uma maneira curta de dizer ” 1, $ “, da primeira à última linha.

Usando um padrão em um intervalo

Suponha que você esteja editando um capítulo em um livro e queira substituir todas as ocorrências de ” cinza ” por ” cinza “. Mas apenas neste capítulo, não no próximo. Você sabe que apenas os limites dos capítulos têm a palavra “capítulo” na primeira coluna. Este comando funcionará então:

  :? ^ Capítulo?, / ^ Capítulo / s = cinza = cinza = g

Você pode ver que um padrão de pesquisa é usado duas vezes. O primeiro ” ? ^ Chapter? ” Localiza a linha acima da posição atual que corresponde a esse padrão. Assim, o padrão? O intervalo é usado para pesquisar para trás. Da mesma forma, ” / ^ Chapter / ” é usado para procurar o início do próximo capítulo.

Para evitar confusão com as barras, o caractere ” = ” foi usado no comando substituto aqui. Uma barra ou outro personagem também teria funcionado.

Adicionar e subtrair

Há um pequeno erro no comando acima: Se o título do próximo capítulo incluísse “cinza”, ele também seria substituído. Talvez seja isso que você queria, mas e se você não quisesse? Então você pode especificar um deslocamento.

Para procurar um padrão e, em seguida, use a linha acima dele:

  /Capítulo 1

Você pode usar qualquer número em vez do 1. Para endereçar a segunda linha abaixo da correspondência:

  / Capítulo / + 2

As compensações também podem ser usadas com os outros itens em um intervalo. Veja este:

  :. + 3, $ - 5

Isso especifica o intervalo que inicia três linhas abaixo do cursor e termina cinco linhas antes da última linha do arquivo.

Usando marcas

Em vez de descobrir os números de linha de determinadas posições, lembrando-os e digitando-os em um intervalo, você pode usar marcas.

Coloque as marcas conforme mencionado no capítulo 3. Por exemplo, use ” mt ” para marcar o topo de uma área e ” mb ” para marcar o fundo. Em seguida, você pode usar esse intervalo para especificar as linhas entre as marcas (incluindo as linhas com as marcas):

  :'t,'b

Modo visual e intervalos

Você pode selecionar texto no modo Visual. Se você pressionar ” : ” para iniciar um comando de dois pontos, verá o seguinte:

  : '<,'>

Agora você pode digitar o comando e ele será aplicado ao intervalo de linhas que foi selecionado visualmente.

Nota: Ao usar o modo Visual para selecionar parte de uma linha ou Ctrl-V para selecionar um bloco de texto, os comandos de dois pontos ainda serão aplicados a linhas inteiras.

Os ‘< e ‘> são realmente marcas, colocadas no início e no final da seleção Visual. As marcas permanecem em sua posição até que outra seleção visual seja feita. Assim, você pode usar o comando ” ‘< ” para pular para a posição em que a área Visual foi iniciada. E você pode misturar as marcas com outros itens:

  : '>, $

Isso aborda as linhas do final da área Visual até o final do arquivo.

Um número de linhas

Quando você souber quantas linhas deseja alterar, digite o número e depois ” : “. Por exemplo, quando você digita ” 5: “, você obtém:

  :.,. + 4

Agora você pode digitar o comando que deseja usar. Ele usará o intervalo ” . ” (Linha atual) até ” . + 4 ” (quatro linhas abaixo). Assim, abrange cinco linhas.

O comando global

O comando ” : global ” é um dos recursos mais poderosos do vim . Ele permite que você encontre uma correspondência para um padrão e execute um comando lá. A forma geral é:

  : [range] global / {padrão} / {comando}

Isso é semelhante ao comando ” : substitute “. Mas, em vez de substituir o texto correspondente por outro texto, o comando {command} é executado.

Nota: O comando executado para ” : global ” deve ser aquele que começa com dois pontos. Os comandos do modo normal não podem ser usados ​​diretamente. O comando : normal pode fazer isso por você.

Suponha que você queira alterar “foobar” para “barfoo”, mas apenas nos comentários no estilo C ++. Esses comentários começam com ” // “. Use este comando:

  : g + // + s / foobar / barfoo / g

Isso começa com ” : g “. Isso é abreviação de ” : global “, assim como ” : s ” é abreviação de ” : substitute “. Em seguida, o padrão, incluído em mais caracteres. Como o padrão que estamos procurando contém uma barra, ele usa o caractere mais para separar o padrão. Em seguida, vem o comando substituto que altera “foobar” em “barfoo”.

O intervalo padrão para o comando global é o arquivo inteiro. Portanto, nenhum intervalo foi especificado neste exemplo. Isso é diferente de ” : substitute “, que funciona em uma linha sem um intervalo.

O comando não é perfeito, pois também corresponde às linhas em que “//” aparece na metade da linha e a substituição também ocorre antes do “//”.

Assim como com ” : substitute “, qualquer padrão pode ser usado. Quando você aprender padrões mais complicados posteriormente, poderá usá-los aqui.

Modo de bloqueio visual

Com Ctrl-V, você pode iniciar a seleção de uma área retangular de texto. Existem alguns comandos que fazem algo especial com o bloco de texto.

Há algo de especial em usar o comando ” $ ” no modo de bloco Visual. Quando o último comando de movimento usado foi ” $ “, todas as linhas na seleção Visual se estenderão até o final da linha, também quando a linha com o cursor for mais curta. Isso permanece efetivo até você usar um comando de movimento que move o cursor horizontalmente. Assim, o uso de ” j ” o mantém, ” h ” o interrompe.

Inserindo texto

O comando ” I {string} <Esc> ” insere o texto {string} em cada linha, à esquerda do bloco visual. Você começa pressionando Ctrl-V para entrar no modo de bloqueio visual. Agora você move o cursor para definir seu bloco. Em seguida, digite I para entrar no modo Inserir, seguido pelo texto a inserir. Enquanto você digita, o texto aparece apenas na primeira linha.

Depois de pressionar <Esc> para finalizar a inserção, o texto será inserido magicamente no restante das linhas contidas na seleção visual. Exemplo:

  inclua um 
	 inclua dois 
	 inclua três 
	 inclui quatro

Mova o cursor para o “o” de “one” e pressione Ctrl-V . Mova para baixo com ” 3j ” para “quatro”. Agora você tem uma seleção de bloco que abrange quatro linhas. Agora digite:

  Eu permaneço. <Esc>

O resultado:

  inclua main.one 
	 inclua main.two 
	 inclua main.three 
	 inclua main.four

Se o bloco abranger linhas curtas que não se estendem para o bloco, o texto não será inserido nessa linha. Por exemplo, faça uma seleção de bloco Visual que inclua a palavra “long” na primeira e na última linha deste texto e, portanto, não tenha texto selecionado na segunda linha:

  Esta é uma longa fila 
	 baixo 
	 Qualquer outra linha longa 
		   ^^^^ bloco selecionado

Agora use o comando ” Ivery <Esc> “. O resultado é:

  Esta é uma fila muito longa 
	 baixo 
	 Qualquer outra fila muito longa

Na linha curta, nenhum texto foi inserido.

Se a string inserida contiver uma nova linha , o ” I ” funcionará como um comando de inserção normal e afetará apenas a primeira linha do bloco.

O comando ” A ” funciona da mesma maneira, exceto que é anexado após o lado direito do bloco. E insere texto em uma linha curta. Assim, você pode escolher se deseja ou não anexar texto a uma linha curta.

Há um caso especial para ” A “: selecione um bloco Visual e, em seguida, use ” $ ” para fazer com que o bloco se estenda até o final de cada linha. Usando ” A ” agora irá acrescentar o texto ao final de cada linha.

Usando o mesmo exemplo acima, e digitando “$ A XXX <Esc> , você obtém este resultado:

  Esta é uma longa fila XXX 
	 curto XXX 
	 Qualquer outra linha longa XXX 

Isso realmente requer o uso do comando ” $ “. O vim lembra que foi usado. Fazer a mesma seleção movendo o cursor para o final da linha mais longa com outros comandos de movimento não terá o mesmo resultado.

Alterar texto

O comando Visual bloco ” c ” exclui o bloco e o lança no modo Inserir para permitir que você digite uma sequência. A string será inserida em cada linha do bloco.

Começando com a mesma seleção das palavras “longas”, como acima, e digitando ” c_LONG_ <Esc> “, você obtém o seguinte:

  Esta é uma linha _LONG_ 
	 baixo 
	 Qualquer outra linha _LONG_

Assim como no ” I “, a linha curta não é alterada. Além disso, você não pode inserir uma nova linha no novo texto.

O comando ” C ” exclui o texto da borda esquerda do bloco até o final da linha. Em seguida, coloca você no modo Inserir, para que você possa digitar uma string, que é adicionada ao final de cada linha.

Começando com o mesmo texto novamente e digitando ” Cnew text <Esc> “, você obtém:

  Este é um novo texto 
	 baixo 
	 Qualquer outro texto novo

Observe que, mesmo que apenas a palavra “longa” tenha sido selecionada, o texto após ser excluído também. Assim, apenas a localização da borda esquerda do bloco visual realmente importa.

Novamente, as linhas curtas que não chegam ao bloco são excluídas.

Outros comandos que alteram os caracteres no bloco:

Preenchendo um caractere

Para preencher o bloco inteiro com um caractere, use o comando ” r “. Novamente, começando com o mesmo exemplo de texto acima e digitando ” rx “:

  Esta é uma linha xxxx 
	 baixo 
	 Qualquer outra linha xxxx

Nota: Se você deseja incluir caracteres além do final da linha no bloco, consulte o recurso ‘ virtualedit ‘ (você pode digitar ” : help virtualedit ” no vim para saber mais).

Deslocamento

O comando ” > ” desloca o texto selecionado para a quantidade certa de turno, inserindo espaços em branco. O ponto de partida para essa mudança é a borda esquerda do bloco visual.

Com o mesmo exemplo novamente, ” > ” fornece este resultado:

  Esta é uma longa fila 
	 baixo 
	 Qualquer outra linha longa

O valor do turno é especificado com a opção ‘ shiftwidth ‘. Para alterá-lo para usar 4 espaços:

  :set shiftwidth = 4

O comando ” < ” remove uma quantidade de turno de espaço em branco na borda esquerda do bloco. Este comando é limitado pela quantidade de texto existente; portanto, se houver menos de um turno de espaço em branco disponível, ele removerá o que puder.

Linhas de junção

O comando ” J ” une todas as linhas selecionadas em uma linha. Assim, remove as quebras de linha. Na verdade, a quebra de linha, o espaço em branco à esquerda e o espaço em branco à esquerda são substituídos por um espaço. Dois espaços são usados ​​após o final de uma linha (que pode ser alterada com a opção ‘ joinspaces ‘).

Vamos usar o exemplo com o qual nos familiarizamos agora. O resultado do uso do comando ” J “:

  Esta é uma linha longa curta Qualquer outra linha longa 

O comando ” J ” não requer uma seleção em blocos. Funciona com a seleção ” v ” e ” V ” exatamente da mesma maneira.

Se você não quiser que o espaço em branco seja alterado, use o comando ” gJ “.

Lendo e escrevendo parte de um arquivo

Ao escrever uma mensagem de email, convém incluir outro arquivo. Isso pode ser feito com o comando ” : read {filename} “. O texto do arquivo é colocado abaixo da linha do cursor.

Começando com este texto:

  Olá John, 
	 Aqui está o diff que corrige o erro: 
	 Tchau, Pierre.

Mova o cursor para a segunda linha e digite:

  : ler patch

O arquivo chamado ” patch ” será inserido, com este resultado:

  Olá John, 
	 Aqui está o diff que corrige o erro: 
	 2c2 
	 <para (i = 0; i <= comprimento; ++ i) 
	 --- 
	 > for (i = 0; i <comprimento; ++ i) 
	 Tchau, Pierre.

O comando ” : read ” aceita um intervalo. O arquivo será colocado abaixo do número da última linha desse intervalo. Assim, ” : $ r patch ” acrescenta o arquivo “patch” no final do arquivo.

E se você quiser ler o arquivo acima da primeira linha? Isso pode ser feito com o número da linha zero. Essa linha realmente não existe; você receberá uma mensagem de erro ao usá-la com a maioria dos comandos. Mas este comando é permitido:

  : 0read patch

O arquivo “patch” será colocado acima da primeira linha do arquivo.

Escrevendo um intervalo de linhas

Para gravar um intervalo de linhas em um arquivo, o comando ” : write ” pode ser usado. Sem um intervalo, ele grava o arquivo inteiro. Com um intervalo, apenas as linhas especificadas são gravadas:

  :.,$write tempo

Isso grava as linhas do cursor até o final do arquivo no arquivo “tempo”. Se esse arquivo já existir, você receberá uma mensagem de erro. O vim protege você de sobrescrever acidentalmente um arquivo existente. Se você sabe o que está fazendo e deseja substituir o arquivo, anexe ! :

  :.,$write!  tempo

CUIDADO: O ! deve seguir o comando ” : write ” imediatamente, sem espaço em branco. Caso contrário, ele se tornará um comando de filtro, explicado mais adiante nesta página.

Anexando a um arquivo

Na primeira seção desta página, foi explicado como coletar um número de linhas em um registro. O mesmo pode ser feito para coletar linhas em um arquivo. Escreva a primeira linha com este comando:

  :write collection

Agora mova o cursor para a segunda linha que deseja coletar e digite:

  :.write >> coleção

O ” >> ” informa ao vim que o arquivo “coleção” não deve ser gravado como um novo arquivo, mas a linha deve ser anexada no final. Você pode repetir isso quantas vezes quiser.

Formatando texto

Ao digitar texto sem formatação, é bom que o comprimento de cada linha seja cortado automaticamente para caber na janela. Para que isso aconteça ao inserir texto, defina a opção ‘ textwidth ‘:

 :set textwidth=72

Para verificar o valor atual de ‘ textwidth ‘:

  :set textwidth

Agora as linhas serão quebradas para conter apenas 72 caracteres. Porém, quando você insere texto na metade da linha ou exclui algumas palavras, as linhas ficam muito longas ou muito curtas. O vim não reformata automaticamente o texto.

Para dizer ao vim para formatar o parágrafo atual:

  gqap

Isso começa com o comando ” gq “, que é um operador. A seguir está ” ap “, o objeto de texto que significa “um parágrafo”. Um parágrafo é separado do próximo parágrafo por uma linha vazia.

Nota: Uma linha em branco, que contém espaço em branco, NÃO separa parágrafos. Isso é difícil de notar!

Em vez de ” ap “, você pode usar qualquer movimento ou objeto de texto. Se seus parágrafos estiverem separados adequadamente, você poderá usar este comando para formatar o arquivo inteiro:

  gggqG

” gg ” leva você à primeira linha, ” gq ” é o operador de formato e ” G ” o movimento que salta para a última linha. Caso seus parágrafos não estejam claramente definidos, você pode formatar apenas as linhas selecionadas manualmente. Mova o cursor para a primeira linha que deseja formatar. Comece com o comando ” gqj “. Isso formata a linha atual e a abaixo dela. Se a primeira linha for curta, as palavras da próxima linha serão anexadas. Se for muito longo, as palavras serão movidas para a próxima linha. O cursor se move para a segunda linha. Agora você pode usar ” . ” Para repetir o comando. Continue fazendo isso até chegar ao final do texto que deseja formatar.

Caso em mudança

Você tem texto com cabeçalhos de seção em minúsculas. Você deseja que a palavra “seção” seja toda maiúscula. Faça isso com o operador “gU”. Comece com o cursor na primeira coluna:

  gUw
 	 cabeçalho da seção ----> cabeçalho SECTION

O operador ” gu ” faz exatamente o oposto:

  guw
 	 Cabeçalho SEÇÃO ----> cabeçalho da seção

Você também pode usar ” g ~ ” para trocar de maiúsculas e minúsculas. Todos esses são operadores, portanto, eles trabalham com qualquer comando de movimento, com objetos de texto e no modo Visual.

Para fazer um operador trabalhar nas linhas, você o dobro. O operador de exclusão é ” d “, portanto, para excluir uma linha, você usa ” dd “. Da mesma forma, ” gugu ” torna uma linha inteira em minúscula. Isso pode ser reduzido para ” guu “. ” gUgU ” é reduzido para ” gUU ” e ” g ~ g ~ ” para ” g ~~ “. Exemplo:

  g ~~ 
 	 Algumas meninas se divertem ----> algumas meninas se divertem 

Usando um programa externo

O vim tem um conjunto de comandos muito poderoso, ele pode fazer qualquer coisa. Mas ainda pode haver algo que um comando externo possa fazer melhor ou mais rápido.

O comando ” ! {Motion} {program} ” pega um bloco de texto e o filtra através de um programa externo. Em outras palavras, ele executa o comando do sistema representado por {program}, fornecendo o bloco de texto representado por {motion} como entrada. A saída deste comando substitui o bloco selecionado.

Como isso resume mal se você não estiver familiarizado com os filtros UNIX, dê uma olhada em um exemplo. O comando de classificação classifica um arquivo. Se você executar o seguinte comando, o arquivo não classificado input.txt será classificado e gravado em output.txt. Isso funciona no UNIX e no Microsoft Windows.

  sort <input.txt> output.txt

Agora faça a mesma coisa no vim . Você deseja classificar as linhas 1 a 5 de um arquivo. Você começa colocando o cursor na linha 1. Em seguida, execute o seguinte comando:

  ! 5G

O ” ! ” Informa ao vim que você está executando uma operação de filtro. O editor vim espera que um comando de movimento seja seguido, indicando qual parte do arquivo filtrar. O comando ” 5G ” diz ao vim para ir para a linha 5, então agora ele sabe que é para filtrar as linhas 1 (a linha atual) até 5.

Antecipando a filtragem, o cursor cai na parte inferior da tela e a! prompt é exibido. Agora você pode digitar o nome do programa de filtro, nesse caso, classificar . Portanto, seu comando completo é o seguinte:

  ! 5Gsort <Enter>

O resultado é que o programa de classificação é executado nas 5 primeiras linhas. A saída do programa substitui essas linhas.

  linha 55 -> linha 11
	 linha 33 -> linha 22
	 linha 11 -> linha 33
	 linha 22 -> linha 44
	 linha 44 -> linha 55
	 última linha -> última linha

O comando ” !! ” filtra a linha atual através de um filtro. No Unix, o comando date imprime a hora e a data atuais. ” !! date <Enter> ” substitui a linha atual pela saída da data . Isso é útil para adicionar um carimbo de data / hora a um arquivo.

Quando não funciona

Iniciar um shell , enviá-lo texto e capturar a saída requer que o vim saiba exatamente como o shell funciona. Quando você tiver problemas com a filtragem, verifique os valores destas opções:

No Unix, isso quase nunca é um problema, porque existem dois tipos de shell: tipo ” sh ” e tipo ” csh “. O vim verifica a opção ‘ shell ‘ e define as opções relacionadas automaticamente, dependendo de ver ” csh ” em algum lugar do ‘ shell ‘.

No MS-Windows, no entanto, existem muitos shells diferentes e você pode precisar ajustar as opções para fazer a filtragem funcionar. Verifique a ajuda das opções para obter mais informações.

Saída do comando de leitura

Para ler o conteúdo do diretório atual no arquivo, use os seguintes comandos.

no Unix:

  :read! ls

no MS Windows:

  :read! dir

A saída do comando ” ls ” ou ” dir ” é capturada e inserida no texto, abaixo do cursor. É semelhante à leitura de um arquivo, exceto que o ” ! ” É usado para informar ao vim que um comando segue.

O comando pode ter argumentos. E um intervalo pode ser usado para dizer onde o vim deve colocar as linhas:

  : 0read! Date -u

Isso insere a hora e a data atuais no formato UTC na parte superior do arquivo. Se você tiver um comando de data que aceite o argumento ” -u “. Observe a diferença ao usar ” !! date “: que substituiu uma linha, enquanto ” : read! Date ” inserirá uma linha.

Escrevendo texto em um comando

O comando Unix wc conta palavras. Para contar as palavras no arquivo atual:

  :write! wc

Este é o mesmo comando de gravação de antes, mas em vez de um nome de arquivo, o caractere ” ! ” É usado e o nome de um comando externo. O texto escrito será passado para o comando especificado como sua entrada padrão. A saída pode ficar assim:

  4 47 249 

O comando wc não é detalhado . Esta saída significa que você tem 4 linhas, 47 palavras e 249 caracteres.

Cuidado com este erro:

  :write!  banheiro

Isso gravará o arquivo ” wc ” no diretório atual, com força. (O espaço em branco é importante aqui!)

Redesenhando a tela

Se o comando externo produziu uma mensagem de erro, o visor pode ter sido confuso. O vim é muito eficiente e redesenha apenas as partes da tela que ele sabe que precisam ser redesenhadas. Mas não pode saber sobre o que outro programa escreveu. Para dizer ao vim para redesenhar a tela, pressione Ctrl-L .

Truques úteis

O comando substitute pode ser usado para substituir todas as ocorrências de uma palavra por outra palavra:

  :% s / quatro / 4 / g

O intervalo ” % ” significa substituir em todas as linhas. O sinalizador ” g ” no final faz com que todas as palavras em uma linha sejam substituídas.

Isso não fará a coisa certa se o seu arquivo também contiver “trinta e quatro”. Seria substituído por “trinta4”. Para evitar isso, use o item ” \ < ” para corresponder ao início de uma palavra:

  :% s / \\ <quatro / 4 / g

Obviamente, isso ainda dá errado em “quatorze”. Use ” \> ” para corresponder ao final de uma palavra:

  :% s / \ <quatro \> / 4 / g

Se você estiver programando, poderá substituir “quatro” nos comentários, mas não no código. Como isso é difícil de especificar, adicione o sinalizador ” c ” para que o comando substituto solicite a você cada substituição:

  :% s / \ <quatro \> / 4 / gc

Substituindo em vários arquivos

Suponha que você queira substituir uma palavra em mais de um arquivo. Você pode editar cada arquivo e digitar o comando manualmente. É muito mais rápido usar a gravação e a reprodução.

Vamos supor que você tenha um diretório com arquivos C ++, todos terminando em “.cpp”. Há uma função chamada “GetResp” que você deseja renomear para “GetAnswer”.

Nota: Ao reproduzir uma sequência gravada, um erro interrompe a execução. Portanto, verifique se você não recebe uma mensagem de erro ao gravar.

Um detalhe: Se um dos arquivos .cpp não contém a palavra “GetResp”, você receberá um erro e a substituição vai parar. Para evitar isso, adicione a flag “e” ao comando substituto:

 :%s/\<GetResp\>/GetAnswer/ge

A flag ” e ” diz ao ” :substitute ” que não encontrar uma correspondencia não é um erro.

Neste próximo exemplo, vamos mudar o texto “Last, First” para “First Last”. Digamos que você tem uma lista de nomes nessa forma:

 Doe, John 
	Smith, Peter

Você quer mudar para:

  John Doe 
	 Peter Smith

Isso pode ser feito com um só comando:

 :%s/\([^,]*\), \(.*\)/\2 \1/

Let’s break this down in parts. Obviously it starts with a substitute command. The ” % ” is the line range, which stands for the whole file. Thus the substitution is done in every line in the file. The arguments for the substitute command are ” /from/to/ “. The slashes separate the “from” pattern and the “to” string. This is what the “from” pattern contains:

Vamos por partes. Começamos com um comando de substitute. O ” % ” é a extensão das linhas, que representa todo o arquivo. Logo, a substituição é feita em todas as linhas do arquivo. Os argumentos pro comando substituir são ” /from/to/ “. As barras separam o padrão “from” e a string “to”. O padrão “from” contém:

 \([^,]*\), \(.*\)

 \( \)

 [^,]

  *

  ,

 \( \)

  .

  *

Na parte do “to” temos ” \2 ” e ” \1 “. Eles são chamados de backreferences. Eles se referem ao texto correspondido pelas partes de ” \( \) ” no padrão. ” \2 ” refere-se ao texto correspondido pelo segundo ” \( \) “, que é o nome “First”. ” \1 ” refere-se ao primeiro ” \( \) “, cujo o nome é “Last”.

Você pode usar até nove backreferences na parte do “to” de um comando de substituição. ” \0 ” refere-se ao padrão correspondido completo.

Ordenar uma lista

Em um makefile você comummente tem listas de arquivos. Por exemplo:

 OBJS = \ 
		version.o \ 
		pch.o \ 
		getopt.o \ 
		util.o \ 
		getopt1.o \ 
		inp.o \ 
		patch.o \ 
		backup.o

Para ordenar essa lista, filtre o texto com o comando exterior sort:

 /^OBJS

  j

 :.,/^$/-1!sort

Isso vai pra primeira linha, onde “OBJS” é a primeira coisa da linha. Então ele vai para a próxima linha e filtra as linhas até encontrar uma linha vazia. Você também pode selecionar as linhas no Modo Visual e então usar ” !sort “. É mais fácil de digitar, mas é mais trabalhoso quando são muitas as linhas.

O resultado é o seguinte:

 OBJS = \ 
		backup.o 
		getopt.o \ 
		getopt1.o \ 
		inp.o \ 
		patch.o \ 
		pch.o \ 
		util.o \ 
		version.o \

Notice that a backslash at the end of each line is used to indicate the line continues. After sorting, this is wrong! The “backup.o” line that was at the end didn’t have a backslash. Now that it sorts to another place, it must have a backslash.

Note que a barra no fim de cada linha é usada para indicar que a linha continua. Após a ordenação isso fica errado! A linha “backup.o” era a linha final e  não tinha barra. Agora que ela foi ordenada pra outro lugar, ela deve ter uma barra.

A solução mais simples é adicionar uma barra com ” A \<Esc> “. Você pode manter a barra na última linha, mas deve se certificar que a próxima linha é vazia. Assim você não terá esse problema novamente.

Inverter a ordem das linhas

O comando :global pode ser combinado com o comando :move para mover todas as linhas antes da primeira linha, resultando num arquivo invertido. O comando é:

 :global/^/m 0

Abreviado:

 :g/^/m 0

A expressão regular ” ^ ” corresponde o começo da linha (mesmo se a linha for vazia). O comando :move move a linha para a “linha 0”, para que a linha correspondida atual seja a primeira do arquivo. Como o comando :global não é confundido pela mudança de numeração nas linhas, :global continua correspondendo todas as linhas restantes e as colocando no começo do arquivo.

Isso também funciona numa série de linhas. Primeiro mova para acima da primeira linha e marque com “mt”. Então mova o cursor para a ultima linha da série e digite:

 :'t+1,.g/^/m 't

Contar palavras

As vezes você pode ter que escrever um texto com número máximo de palavras. O vim pode contar as palavras pra você.

Quando quiser contar todas as palavras de um arquivo, use o seguinte comando:

 g Ctrl-G

Não digite um espaço após o  g , Isso só foi feito para deixar o comando mais legível.

A saída é assim:

 Col 1 of 0; Line 141 of 157; Word 748 of 774; Byte 4489 of 4976 

Você pode ver em qual palavra está (748), e o número total de palavras no arquivo (774).

Quando o texto é só parte do arquivo, você pode mover pro começo do texto, digitar ” g Ctrl-G “, mover pro fim do texto, e novamente digitar ” g Ctrl-G ” , e fazer a conta mentalmente do número de palavras. Porém existe um jeito mais fácil. Com o Modo Visual, selecione o texto no qual você quer contar as palavras. Então digite g Ctrl-G . O resultado:

 Selected 5 of 293 Lines; 70 of 1884 Words; 359 of 10928 Bytes 

Achar uma página man

Enquanto você edita scripts shell e programas C e você está usando um comando ou função para o qual você quer o manual (Isso se aplica ao Linux, não ao MS Windows). Vamos usar primeiramente o jeito simples: mova o cursor para a palavra a qual você quer ajuda e digite K .

O vim vai chamar a página man externa. Se ela for encontrada, então ele a mostrará. Isso usa o pager normal para andar pelo texto. Quando você chegar ao fim pressionando <Enter> você voltará ao vim .

A disvantagem é que você não pode ver o manual e o texto no qual está trabalhando ao mesmo tempo. Existe um truque para fazer o manual aparecer em uma janela do vim. Primeiro, carregue o plugin man filetype:

 :runtime! ftplugin/man.vim

Ponha este comando no seu vimrc se você for fazer isso frequentemente. Agora você pode usar o comando ” :Man ” para abrir uma janela com o manual:

 :Man csh

Você pode se mover e o texto fica destacado, o que te permite achar a informação que procurava. Use Ctrl-W w para pular para a janela com o texto no qual você trabalhava anteriormente.

Para achar um manual numa seção específica, coloque o número da seção primeiro. Por exemplo, para olhar a seção 3 do comando ” echo “:

 :Man 3 echo

Para pular para outra página man, que normalmente pode ser encontrada na forma “word(1)”, pressione Ctrl-] nela. Outros comandos ” :Man ” vão usar a mesma janela.

Para mostrar a página man da palavra que está sobre o cursor, use o comando \K .

(Se você redefiniu o <Leader> , use-o ao invés da barra). Por exemplo, você quer saber o valor de retorno de ” strstr() ” enquanto edita a linha:

 if ( strstr (input, "aap") == ) 

Mova o cursor para baixo de ” strstr ” e digite ” \K “. Uma janela vai aparecer com a página man de strstr() .

Excluir vazios

Algumas pessoas não gostam de espaços vazios no fim de linhas. Para remover o espaço do fim de cada linha, execute o seguinte comando:

 :%s/\s\+$//

The line range “%” is used, thus this works on the whole file. O padrão que o comando ” :substitute ” corresponde é ” \s\+$ “. Isso acha os espaços em branco (\s), 1 ou mais (\+), antes do fim de linha ($).

A parte “to” do comando de substituição é vaiza: “//”. Logo substituindo por nada, deletando o espaço em branco correspondente.

Outro uso desnecessário de espaços em branco é antes de tabulações. Normalmente eles podem ser deletados sem alterar o número de espaços em branco. Mas não sempre! Logo, você pode fazer isso manualmente. Use este comando de busca: ” / “. Não da pra ver, mas tem um espaço antes da tabulação nesse comando. Logo é ” /<Space><Tab> “. Agora use ” x ” para deletar o espaço e certifcar-se que o número não mudará. Você pode ter que inserir uma tabulação caso mude. Digite ” n ” para achar a próxima correspondencia. Repita até não achar mais correspondencias.

Achar onde uma palavra é usada

Se você é um usuário de UNIX, você pode combinar o vim e o comando grep para editar todos os arquivos que contém certa palavra. Isso é extremamente útil se você está trabalhando num programa e quer ver ou editar todos os arquivos que contém alguma variável específica.

Por exemplo, suponha que você queira editar todos os arquivos de programa C que contem a palavra “frame_counter”. Para fazer isso, use o comando:

 vim `grep -l frame_counter *.c`

Vamos olhar esse comando com detalhes. O comando grep procura num grupo de arquivos certa palavra. Como o argumento -l é usado, o comando vai apenas listar os arquivos que contem a palavra e não imprime as linhas correspondentes. A palavra que ele busca é “frame_counter”. Isso pode ser feito com qualquer expressão regular. Nota: O que o grep usa para expressões regulares não é exatamente igual ao que o vim usa.

Todo o comando é cercado por backticks (” ` “). Isso fala para a shell do UNIX rodar o comando e fingir que os resultados foram escritos na linha de comando. Então o que acontece é que o comando grep seja rodado e produza uma lista de arquivos, esses arquivos são colocados na linha de comando do vim. Isso resulta no vim editar os arquivos que o grep passou como argumento. Você pode então usar comandos como ” :next ” e ” :first ” para olhar os arquivos.

Achando cada linha

O comando acima só encontra os arquivos que contem a palavra. Você ainda tem que achar a palvra dentro dos arquivos.

vim tem um comando interno que pode ser usado para procurar uma string num conjunto de arquivos. Se você quiser achar todas as ocorrências de “error_string” em todos arquivos de programa C, por exemplo, entre o seguitne comando:

 :grep error_string *.c

Isso causa o vim a buscar a string “error_string” em todos os arquivos especificados (*.c). O editor vai abrir o primeiro arquivo no qual correspondencias foram encontradas e posicionar o cursos na primeira correspondencia. Para ir para a próxima correspondência (não importa em qual arquivo ela esteja), use o comando ” :cnext ” .Para ir para a anterior, use o comando ” :cprev “. Use ” :clist ” para ver todas as correspondencias e onde elas estão.

O comando ” :grep ” use o comando externo grep (no UNIX) ou findstr (no Windows). Você pode mudar isso marcando a opção ‘ grepprg ‘.

Abreviações de Linha de Comando

Alguns dos comandos ” : ” são bem longos. Nós já mencionamos que ” :substitute ” pode ser abreviado para ” :s “. Isso é um mecanismo genérico, todos comandos ” : ” podem ser abreviados.

Qual curto pode ser um comando? Existem 26 letras, e muito mais comandos que isso. Por exemplo, ” :set ” também começa com ” :s “, mas ” :s ” não roda um comando ” :set “. Em vez disso ” :set ” pode ser abreviado para ” :se “.

Quando uma abreviação serve pra dois comandos, ela pode ser usada para apenas um. Não existe uma lógica por trás, temos que aprender todos. Nos arquivos de ajuda a menor abreviação é mencionada. Por exemplo:

 :s[ubstitute]

Isso significa que a menor forma de ” :substitute ” é ” :s “. Os caracteres subsequentes são desnecessários. Assim” :su ” e ” :sub ” também funcionam.

No manual usaremos ou o nome completo do comando, ou uma abreviação legível. Por exemplo, ” :function ” pode ser abreviado para ” :fu “. Mas como fica pouco descritivo, usaremos ” :fun “.

É recomandado que scripts vim usem o comando completo. Isso torna a legibilidade e portabilidade maiores. Exceto para comando muito usados como ” :w ” (” :write “) e ” :r ” (” :read “).

Um comando particularmente confuso é o ” :end “, que pode significar ” :endif “, ” :endwhile ” ou ” :endfunction “. Então, sempre use o nome completo.

Nomes de Opção Curta

No manual os nomes completos são usados. Muitas opções também possuem nomes curtos. Diferente dos comandos ” : ” , só há uma abreviação que funciona. Por exemplo, a abreviação de ‘autoindent’ é ‘ai’. Logo, ambos fazem a mesma coisa:

 :set autoindent
:set ai

Complementação de Linha de Comando

Esse é um dos features que por sí só traz razão para usar o vim ao invés do Vi.

Suponha que você tem um diretório que contém os arquivos:

  info.txt
	intro.txt
	bodyofthepaper.txt

Para editar o último, use o comando:

 :edit bodyofthepaper.txt

Mas como é fácil de digitar isso errado, utilize:

 :edit b<Tab>

Isso resultará no mesmo comando. O que aconteceu? O <Tab> completa a palavra no cursor. Neste caso ” b “. O vim olha no diretório por arquivos que comecem com ” b ” e completa para você.

Agora digite:

 :edit i<Tab>

vim vai soltar um beep, e te dar:

 :edit info.txt

O beep significa que mais de uma correspondencia foi encontrada. Ele mostra a primeira correspondencia (alfabeticamente). Se você apertar <Tab> novamente, você terá:

 :edit intro.txt

Assim, apertar <Tab> vai ciclar dentre as opções.

Apertar <Tab> na ultima correspondencia, vai te levar de volta para o que foi originalmente digitado:

 :edit i

E depois começa de novo. Use Ctrl-P para ver a lista na ordem contrária:

 <──────────────────── <Tab> ──────────────────────────┐
								   |
		 <Tab> ──> <Tab> ──>
	:edit i :edit info.txt :edit intro.txt
		  <── Ctrl-P <── Ctrl-P
	    |
	   └─────────────────────── Ctrl-P ─────────────────────>

Contexto de Comando

Quando você digita ” :set i ” ao invés de ” :edit i ” e apertar <Tab> você recebe:

 :set icon

Por que não recebemos ” :set info.txt “? Por que o vim tem compleção sensível ao contexto. A palavra que o vim busca depende do comando que a subcede. O comando vim sabe que você não pode dar um rquivo pro comando ” :set ” , mas você pode passar um nome de opção.

Novamente, se você apertar <Tab> , o vim vai ciclar as correspondencias. Como podem ter muitas, é melhor digitar mais caracteres antes:

 :set isk<Tab>

Dá:

 :set iskeyword

Agora digite ” = ” e aperte <Tab> :

 :set iskeyword=@ ,48-57,_,192-255

O que acontece é que o vim te da o valor antigo da opção. Agora você pode edita-la.

O que é completado por <Tab> é o que o vim espera naquele lugar.  Em algumas situações, você não vai receber o que quer. Isso é porque o vim não sabe o que você quer ou porque a lista de completação não foi implementada para o caso. Nesse caso você receberá <Tab> inserido (mostrado como ^I ).

Ver Correspondencias de Lista

Quando tem muitas ocorrências é útil ver uma lista delas. Faça isso apertando Ctrl-D . Por exemplo, pressinar Ctrl-D após:

 :set is

resulta em:

 :set is
incsearch isfname isident iskeyword isprint
:set is

vim lista as correspondencias e te retorna o que você havia digitado. Agora você pode checar a lista pelo item desejado. Se ele não estiver lá use <BS> para corrigir a palavra.

Se você prestou atenção, vai perceber que “incsearch” não começa com “is”. Nesse caso “is” representa a abreviação de “incsearch”. Muitas opções possuem nomes longes e curtos. O vim é esperto o suficiente pra saber que você pode querer por o nome longo da abreviação.

Comandos relacionados

ed – Um simples editor de texto.
emacs – Um editor de texto altamente extensível.
ex – modo editor de linha do editor de texto vi.
pico – Um simples editor de texto.