fbpx

Comandos Linux – Comando vim

Comando Linux vim

comando 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.

  arquivo vim

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

arquivo …Uma lista de um ou mais nomes de arquivos. O primeiro será o arquivo atual e será lido no buffer. O cursor será posicionado na primeira linha do buffer. Você pode acessar os outros arquivos com o comando ” : next “. Para editar um arquivo que começa com um traço, preceda a lista de arquivos com um traço duplo (”  “).
Um único traço especifica que o arquivo a ser editado deve ser lido a partir da entrada padrão .
-t { tag }O arquivo a ser editado e a posição inicial do cursor dependem de uma “tag”, uma espécie de rótulo de goto . A { tag } é pesquisada no arquivo de tags, o arquivo associado se torna o arquivo atual e o comando associado é executado. Principalmente, isso é usado para programas em C ; nesse caso, { tag } pode ser um nome de função . O efeito é que o arquivo que contém essa função se torna o arquivo atual e o cursor é posicionado no início da função. Para obter mais informações no vim , use o comando ” : help tag- command”.
-q [ arquivo de erro ]Inicie no modo quickFix. O arquivo errorfile é lido e o primeiro erro é exibido. Se o arquivo de erro for omitido, o nome do arquivo será obtido na opção ‘ errorfile ‘ (o padrão é ” errors.err ” na maioria dos sistemas). Erros adicionais podem ser saltados para com o comando ” : cn “. Para obter mais informações no vim , use o comando ” : help quickfix “.

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:

nome do comandocomportamento
vimExecução “normal”. Tudo é o padrão.
exComece no modo Ex . Vá para o modo Normal com o comando ” : vi “. Também pode ser feito com o argumento ” -e “.
VisãoInicie no modo somente leitura. Você estará protegido contra a gravação dos arquivos. Também pode ser feito com o argumento ” -R “.
gvim , gviewA versão da GUI (se instalada). Inicia uma nova janela. Também pode ser feito com o argumento ” -g “.
evim , eviewExecuta a GUI vim no “modo fácil”. Este comando é um modo simplificado de operação do vim , que é muito parecido com um editor de texto normal. É o mesmo que executar o vim com o argumento ” -y “.
rvim , rview , rgvim , rgviewComo o acima, mas executando no modo “restrito”. Não será possível iniciar comandos do shell a partir do vim ou suspender o vim . É o mesmo que especificar o argumento ” -Z “.

Sintaxe

  vim [ opções ] [ arquivo ..]
  vim [ opções ] -
  tag vim [ opções ] -t
  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.

+ [ num ]Para o primeiro arquivo, o cursor será posicionado na linha num . Se num estiver faltando, o cursor será posicionado na última linha.
+ / { pat }Para o primeiro arquivo, o cursor será posicionado na primeira ocorrência de { pat }. No <v> vim, use o comando ” : help search-pattern ” para os padrões de pesquisa disponíveis.
+ { comando }, -c { comando }command } será executado após a leitura do primeiro arquivo. command } é interpretado como um comando ex . Se o { comando } contiver espaços, ele deverá ser colocado entre aspas duplas (isso depende do shell usado). Por exemplo:

  vim "+ set si" main.c

Você pode usar até 10 comandos ” + ” ou ” -c “.

-S { arquivo }file } será originado após a leitura do primeiro arquivo. Isso é equivalente a -c “origem {arquivo}” . arquivo } não pode começar com ‘  ‘. Se { arquivo } for omitido, “Session.vim” será usado (funciona apenas quando -S é o último argumento).
–cmd { command }Como usar ” -c “, mas o comando é executado imediatamente antes de processar qualquer arquivo vimrc . Você pode usar até 10 desses comandos, independentemente dos comandos ” -c “.
-UMASe o vim foi compilado com suporte árabe para editar arquivos orientados da direita para a esquerda e mapeamento de teclado árabe, esta opção inicia o vim no modo árabe, ou seja, ‘ árabe ‘ está definido. Caso contrário, uma mensagem de erro é fornecida e o vim é interrompido.
-bModo binário . Algumas opções serão definidas para possibilitar a edição de um arquivo binário ou executável.
-CModo compatível. Define a opção ‘ compatível ‘. Isso fará com que o vim se comporte principalmente como o Vi , mesmo que exista um arquivo .vimrc .
-dComece no modo diff . Deve haver dois, três ou quatro argumentos de nome de arquivo. O vim abrirá todos os arquivos e mostrará diferenças entre eles. Funciona como vimdiff .
-d { dispositivo }Abra { dispositivo } para uso como um terminal (apenas no Amiga ).
-DModo de depuração . Vá para o modo de depuração ao executar o primeiro comando a partir de um script .
-eInicie o vim no modo ex , como se o executável fosse chamado ” ex “.
-EInicie o vim no modo ex aprimorado, como se o executável fosse chamado ” exim “.
-fModo de primeiro plano. Para a versão da GUI, o vim não bifurca e desconecta do shell em que foi iniciado. No Amiga, o vim não é reiniciado para abrir uma nova janela. Esta opção deve ser usada quando o vim for executado por um programa que aguardará a conclusão da sessão de edição (por exemplo, correio ). No Amiga, os comandos ” : sh ” e ” :! ” Não funcionarão.
–noforkModo de primeiro plano. Para a versão da GUI, o vim não se bifurca e desconecta do shell em que foi iniciado.
-FSe o vim foi compilado com o suporte do FKMAP para editar arquivos orientados da direita para a esquerda e mapeamento de teclado farsi, esta opção inicia o vim no modo farsi, ou seja, ‘ fkmap ‘ e ‘ rightleft ‘ estão definidos. Caso contrário, uma mensagem de erro é fornecida e o vim é interrompido.
-gSe o vim foi compilado com suporte à GUI, essa opção ativará a GUI. Se nenhum suporte GUI foi compilado, uma mensagem de erro é fornecida e o vim é interrompido.
-hAjude um pouco sobre os argumentos e as opções da linha de comando. Depois que esse vim sai.
-HSe o vim foi compilado com o suporte RIGHTLEFT para editar arquivos orientados da direita para a esquerda e mapear o teclado hebraico, esta opção inicia o vim no modo hebraico, ou seja, ‘ hkmap ‘ e ‘ rightleft ‘ estão definidos. Caso contrário, uma mensagem de erro é fornecida e o vim é interrompido.
-i { viminfo }Quando o uso do arquivo viminfo está ativado, essa opção define o nome do arquivo a ser usado, em vez do padrão ” ~ / .viminfo “. Isso também pode ser usado para ignorar o uso do arquivo .viminfo , dando o nome ” NONE “.
-EUO mesmo que -r .
-euModo Lisp . Ativa as opções ‘ lisp ‘ e ‘ showmatch ‘.
-mA modificação de arquivos está desativada. Redefine a opção ‘ gravar ‘. Você ainda pode modificar o buffer, mas não é possível gravar um arquivo.
-MModificações não permitidas. As opções ‘ modificável ‘ e ‘ gravação ‘ serão desabilitadas, de modo que as alterações não são permitidas e os arquivos não podem ser gravados. Observe que essas opções podem ser definidas para permitir fazer modificações.
-NModo não compatível. Redefina a opção ‘ compatível ‘. Isso fará com que o vim se comporte um pouco melhor, mas menos compatível com o Vi , mesmo que não exista um arquivo .vimrc .
-nNenhum arquivo de troca será usado. A recuperação após uma falha será impossível. Prático, se você deseja editar um arquivo em uma mídia muito lenta (por exemplo, disquete). Também pode ser feito com ” : set uc = 0 “. Pode ser desfeito com ” : set uc = 200 “.
-nbTorne-se um servidor editor para o NetBeans.
-o [ N ]Abra N janelas empilhadas. Quando N for omitido, abra uma janela para cada arquivo.
-O [ N ]Abra N janelas lado a lado. Quando N for omitido, abra uma janela para cada arquivo.
-p [ N ]Abra as guias N. Quando N for omitido, abra uma guia para cada arquivo.
-RModo somente leitura. A opção ‘ somente leitura ‘ será definida. Você ainda pode editar o buffer, mas será impedido de substituir acidentalmente um arquivo. Se você deseja substituir um arquivo, adicione um ponto de exclamação ao comando Ex , como em ” : w! “. A opção -R também implica a opção -n (veja abaixo). A opção ‘ somente leitura ‘ pode ser redefinida com ” : set noro “. Veja ” : help ‘readonly’ “.
-rListar arquivos de troca, com informações sobre como usá-los para recuperação.
-r { arquivo }Modo de recuperação. O arquivo de troca é usado para recuperar uma sessão de edição com falha. O arquivo de troca é um arquivo com o mesmo nome que o arquivo de texto com ” .swp ” anexado. Veja ” : ajude a recuperação “.
-sModo silencioso. Somente quando iniciado como ” Ex ” ou quando a opção ” -e ” foi fornecida antes da opção ” -s “.
-s { scriptin }O arquivo de script { scriptin } é lido. Os caracteres no arquivo são interpretados como se você os tivesse digitado. O mesmo pode ser feito com o comando ” : source! {Scriptin} “. Se o final do arquivo for alcançado antes da saída do editor, outros caracteres serão lidos no teclado.
-T { terminal }Diz ao nome do terminal que você está usando. Necessário apenas quando o modo automático não funciona. Deve ser um terminal conhecido pelo vim (embutido) ou definido no arquivo termcap ou terminfo .
-u { vimrc }Use os comandos no arquivo { vimrc } para inicializações. Todas as outras inicializações são ignoradas. Use isso para editar um tipo especial de arquivo. Também pode ser usado para pular todas as inicializações, dando o nome ” NONE “. Veja ” : ajuda na inicialização ” no vim para mais detalhes.
-U { gvimrc }Use os comandos no arquivo { gvimrc } para inicializações da GUI. Todas as outras inicializações da GUI são ignoradas. Também pode ser usado para pular todas as inicializações da GUI, dando o nome ” NONE “. Veja ” : help gui-init ” no vim para mais detalhes.
-V [ N ]Verbose . Envie mensagens sobre quais arquivos são originados e para ler e gravar um arquivo viminfo . O número opcional N é o valor para ‘ detalhado ‘. O padrão é 10 .
-vInicie o vim no modo Vi , assim como o executável foi chamado ” vi “. Isso só tem efeito quando o executável é chamado ” ex “.
-w { scriptout }Todos os caracteres que você digita são gravados no arquivo { scriptout }, até você sair do vim . Isso é útil se você deseja criar um arquivo de script para ser usado com ” vim -s ” ou ” : source! “. Se o arquivo { scriptout } existir, os caracteres serão anexados.
-W { scriptout }Como -w , mas um arquivo existente é substituído.
-xUse criptografia ao gravar arquivos. Solicitará uma chave de criptografia.
-XNão conecte ao servidor X. Diminui o tempo de inicialização em um terminal, mas o título da janela e a área de transferência não serão utilizados.
-yInicie o vim no modo fácil, assim como o executável foi chamado ” evim ” ou ” eview “. Faz com que o vim se comporte como um editor de clique e digitação.
-ZModo restrito. Funciona como o executável começa com ” r “.
Indica o final das opções. Os argumentos após isso serão tratados como um nome de arquivo. Isso pode ser usado para editar um nome de arquivo que comece com um ‘  ‘.
–echo-widApenas GUI GTK: reproduza o ID da janela na saída padrão.
–SocorroDê uma mensagem de ajuda e saia, como ” -h “.
–literalTome os argumentos do nome do arquivo literalmente, não expanda curingas . Isso não tem efeito no Unix, onde o shell expande curingas.
–nopluginIgnore o carregamento de plug-ins. Implícito por -u NENHUM .
–controlo remotoConecte-se a um servidor vim e faça-o editar os arquivos fornecidos no restante dos argumentos. Se nenhum servidor for encontrado, um aviso será dado e os arquivos serão editados no vim atual.
–remote-expr { expr }Conecte-se a um servidor vim , avalie { expr } nele e imprima o resultado no stdout.
–remote-send { keys }Conecte-se a um servidor vim e envie { keys } para ele.
–remote-silentComo –remote , mas sem o aviso quando nenhum servidor for encontrado.
–remote-waitComo –remote , mas o vim não sai até que os arquivos tenham sido editados.
–remote-wait-silentComo –remote-wait , mas sem o aviso quando nenhum servidor for encontrado.
–Lista de servidoresListe os nomes de todos os servidores vim que podem ser encontrados.
–servername { name }Use { name } como o nome do servidor. Usado para o vim atual, a menos que seja usado com um argumento –remote , é o nome do servidor ao qual se conectar.
–socketid { id }Apenas GTK GUI: Use o mecanismo GtkPlug para executar o gvim em outra janela.
–versãoImprima as informações da versão e saia.

Acessando a Ajuda no vim

Digite ” : help ” no vim para começar. Digite ” : assunto da ajuda ” 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:

hesquerda
jbaixa
kacima
eudireito

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. 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 ee

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:

  linha "usr_03.txt" 233 de 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 ‘ número ‘. Isso exibe um número de linha na frente de cada linha:

  : definir número

Para desligar novamente:

  : definir 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 :

  : definir régua

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 |
 └─────────────────┘ └──────────────────┘

The ” zt ” command puts the cursor line at the top, ” zb ” at the bottom. To always keep a few lines of context around the cursor, use the ‘ scrolloff ‘ option (” :set scrolloff “).

Simple Searches

To search for a string , use the ” / string ” command. To find the word “include”, for example, use the command:

 /include

You will notice that when you type the ” / ” the cursor jumps to the last line of the vim window, like with colon commands. That is where you type the word. You can press the backspace key (backarrow or <BS> ) to make corrections. Use the <Left> and <Right> cursor keys when necessary. Pressing <Enter> executes the command.

Note: The characters .*[]^%/\?~$ have special meanings. If you want to use them in a search you must put a \ in front of them; ver abaixo.

To find the next occurrence of the same string use the ” n ” command. Use this to find the first “#include” after the cursor:

 /#include

And then type ” n ” several times. You move to each “#include” in the text. You can also use a count if you know which match you want. Thus ” 3n ” finds the third match. Using a count with ” / ” doesn’t work.

The ” ? ” command works like ” / ” but searches backwards:

 ?word

The ” N ” command repeats the last search the opposite direction. Thus using ” N ” after a ” / ” command search backwards, using ” N ” after ” ? ” searches forward.

Ignoring Case

Normally you have to type exactly what you want to find. If you don’t care about upper or lowercase in a word, set the ‘ ignorecase ‘ option:

 :set ignorecase

If you now search for “word”, it will also match “Word” and “WORD”. To match case again:

 :set noignorecase

História

Suppose you do three searches:

 /one
 /two
 /three

Now let’s start searching by typing a simple ” / ” without pressing <Enter> . If you press <Up> (the cursor key), vim puts ” /three ” on the command line. Pressing <Enter> at this point searches for three. If you do not press <Enter> , but press <Up> instead, vim changes the prompt to ” /two “. Another press of <Up> moves you to ” /one “.

You can also use the <Down> cursor key to move through the history of search commands in the other direction.

If you know what a previously used pattern starts with, and you want to use it again, type that character before pressing <Up> . With the previous example, you can type ” /o<Up> ” and vim will put ” /one ” on the command line.

The commands starting with ” : ” also have a history. That allows you to recall a previous command and execute it again. These two histories are separate.

Searching For A Word In The Text

Suppose you see the word “TheLongFunctionName” in the text and you want to find the next occurrence of it. You could type ” /TheLongFunctionName “, but that’s a lot of typing.

There is an easier way: Position the cursor on the word and use the ” * ” command. vim will grab the word under the cursor and use it as the search string.

The ” # ” command does the same in the other direction. You can prepend a count: ” 3* ” searches for the third occurrence of the word under the cursor.

Searching For Whole Words

If you type ” /the ” it will also match “there”. To only find words that end in “the” use:

 /the\>

The ” \> ” notation is a special marker that only matches at the end of a word. Similarly ” \< ” only matches at the begin of a word. Thus to search for the word “the” only:

 /\<the\>

This does not match “there” or “soothe”. Notice that the ” * ” and ” # ” commands use these start-of-word and end-of-word markers to only find whole words (you can use ” g* ” and ” g# ” to match partial words).

Highlighting Matches

While editing a program you see a variable called “nr”. You want to check where it’s used. You could move the cursor to “nr” and use the ” * ” command and press ” n ” to go along all the matches.

Existe outro caminho. Type this command:

 :set hlsearch

If you now search for ” nr “, vim will highlight all matches. That is a very good way to see where the variable is used, without the need to type commands.

To switch this off:

 :set nohlsearch

Then you need to switch it on again if you want to use it for the next search command. If you only want to remove the highlighting, use this command:

 :nohlsearch

This doesn’t reset the option. Instead, it disables the highlighting. As soon as you execute a search command, the highlighting will be used again. Also, for the ” n ” and ” N ” commands.

Tuning Searches

There are a few options that change how searching works. These are the essential ones:

 :set incsearch

This makes vim display the match for the string while you are still typing it. Use this to check if the right match will be found. Then press <Enter> to really jump to that location. Or type more to change the search string.

 :set nowrapscan

This stops the search at the end of the file. Or, when you are searching backwards, at the start of the file. The ‘ wrapscan ‘ option is on by default, thus searching wraps around the end of the file.

Intermezzo

If you like one of the options mentioned before, and set it each time you use vim , you can put the command in your vim startup file.

If you need to learn where the startup file is, use this command:

 :scriptnames

Edit the file, for example with:

 :edit ~/.vimrc

Then add a line with the command to set the option, just like you typed it in vim . Exemplo:

 Go:set hlsearch <Esc>

” G ” moves to the end of the file. ” o ” starts a new line, where you type the ” :set ” command. You end insert mode with <Esc> . Then write the file:

  ZZ

If you now start vim again, the ‘ hlsearch ‘ option will already be set.

Simple Search Patterns

The vim editor uses regular expressions (“Regex”) to specify what to search for. Regular expressions are an extremely powerful and compact way to specify a search pattern.

Regex: Beginning And End Of A Line

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 ” cm ” 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

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á:

  Senhora

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

  mim

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

  é

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:

A posição do cursor antes de saltar.
A posição do cursor na última edição do arquivo.
[Início da última alteração.
]Fim da última alteração.

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:

cO operador de mudança.
2wMova duas palavras (elas são excluídas e o modo Inserir iniciado).
estarInserir este texto.
<Esc>Voltar ao modo normal.

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:

Comando:Apoia:Descrição:
xd1Exclua o caractere sob o cursor.
XdhExclua o caractere à esquerda do cursor.
Dd $Excluir para final da linha.
Cc $Mude para o final da linha.
sc1Mude um caractere.
SccMude uma linha inteira.

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:

/ quatro <Enter>Encontre a primeira string “quatro”.
cwfive <Esc>Mude a palavra para “cinco”.
nEncontre os próximos “quatro”.
.Repita a alteração para “cinco”.
nEncontre os próximos “quatro”.
.Repita a alteração.

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. 
		  ------->
		  soldar
 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:

  deixe sqr = LongVariable * 
		  -------------->
		  y2w
	 deixe sqr = LongVariable * 
			  p
	 deixe 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 aa
         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:

  "* aa

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:

xExclua o caractere sob o cursor (abreviação de ” dl “).
XExclua o caractere antes do cursor (abreviação de ” dh “).
DExclua do cursor até o final da linha (abreviação de ” d $ “).
dwExclua do cursor para o próximo início da palavra.
dbExclua do cursor para o início anterior da palavra.
diwExclua a palavra sob o cursor (excluindo espaço em branco).
dawExclua a palavra sob o cursor (incluindo espaço em branco).
dGExclua até o final do arquivo.
dggExclua até o início do arquivo.

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:

~Mude a caixa do caractere sob o cursor e mova o cursor para o próximo caractere. Este não é um operador (a menos que ‘ tildeop ‘ esteja definido), portanto, você não pode usá-lo com um comando de movimento. Ele funciona no modo Visual e muda de maiúsculas e minúsculas para todo o texto selecionado.
EuInicie o modo Inserir depois de mover o cursor para o primeiro não espaço em branco na linha.
UMAInicie o modo Inserir depois de mover o cursor para o final da linha.

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:

  : editar $ 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 :

  definir 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:

<F5>A tecla de função F5 . Essa é a tecla de gatilho que faz com que o comando seja executado à medida que a tecla é pressionada.
eu {<Esc>Insira o caractere { . tecla <Esc> termina o modo Inserir.
eVá para o final da palavra.
a} <Esc>Anexe } à palavra.

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 \ pi (<Esc> e a) <Esc>
  : map \ ci {<Esc> e a} <Esc>

Você precisa digitar \ ep op 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:

sistemadiretório de plugins
Unix~ / .vim / plugin /
PC e OS / 2$ HOME / vimfiles / plugin ou $ VIM / vimfiles / plugin
amigas: vimfiles / plugin
Macintosh$ VIM: vimfiles: plugin
Mac OS X~ / .vim / plugin /
RISC-OSOpções: vimfiles.plugin

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:

  : plugin de tipo de arquivo ativado

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:

  : ajuda 'embrulhar'

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:

  : defina 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:

  : definir 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:

  : definir 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:

  : defina 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:

  : defina whatwrap = b, s, <,>

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

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

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

Usando destaque de sintaxe

Tudo começa com um comando simples:

  : sintaxe habilitada

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
    habilitar sintaxe
 fim se

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:

  : definir fundo = escuro

E para um fundo claro:

  : definir fundo = luz

Certifique-se de colocar isso antes do comando ” : syntax enable “, caso contrário as cores já terão sido definidas. Você pode fazer ” : redefinir sintaxe ” 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:

prazoatributos em um terminal P&B
ctermatributos em um terminal colorido
ctermfgcor de primeiro plano em um terminal de cores
ctermbgcor de fundo em um terminal colorido
guiatributos na GUI
guifgcor de primeiro plano na GUI
guibgcor de fundo na GUI

Por exemplo, para tornar os comentários verdes:

  : destaque Comentário ctermfg = verde guifg = verde

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

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

  meu esquema de cores

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

  : sintaxe de tempo de execução / 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:

  : editar 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:

  : ajuda E37

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

  :Escreva

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

  :editar!  foo.txt

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

  : ocultar edição 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:

  :Próximo

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:

  :Próximo!

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:

  :Escreva
  :Próximo

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”. The output might look like this:

 one.c [two.c] three.c

These are the files you started vim with. The one you are currently editing, “two.c”, is in square brackets.

Moving From File To File

To go back one file:

 :previous

This is just like the ” :next ” command, except that it moves in the other direction. Again, there is a shortcut command for when you want to write the file first:

 :wprevious

To move to the very last file in the list:

 :last

And to move back to the first one again:

 :first

There is no ” :wlast ” or ” :wfirst ” command however.

You can use a count for ” :next ” and ” :previous “. To skip two files forward:

 :2next

Arquivos de backup

Usually vim does not produce a backup file. If you want to have one, all you need to do is execute the following command:

 :set backup

The name of the backup file is the original file with a tilde (” ~ “) added to the end. If your file is named data.txt , for example, the backup file name is data.txt~ . If you do not like the fact that the backup files end with ~ , you can change the extension:

 :set backupext=.bak

This will use data.txt.bak instead of data.txt~ .

Another option that matters here is ‘ backupdir ‘. It specifies where the backup file is written. The default, to write the backup in the same directory as the original file, will mostly be the right thing.

When the ‘ backup ‘ option isn’t set but the ‘ writebackup ‘ is, vim will still create a backup file. However, it is deleted as soon as writing the file was completed successfully. This functions as a safety against losing your original file when writing fails in some way (disk full is the most common cause).

If you are editing source files, you might want to keep the file before you make any changes. But the backup file will be overwritten each time you write the file. Thus it only contains the previous version, not the first one.

To make vim keep the original file, set the ‘patchmode’ option. This specifies the extension used for the first backup of a changed file. Usually you would do this:

 :set patchmode=.orig

When you now edit the file data.txt for the first time, make changes and write the file, vim will keep a copy of the unchanged file under the name ” data.txt.orig “.

If you make further changes to the file, vim will notice that ” data.txt.orig ” already exists and leave it alone. Further backup files will then be called ” data.txt~ ” (or whatever you specified with ‘ backupext ‘).

If you leave ‘ patchmode ‘ empty (that is the default), the original file will not be kept.

Using Registers

When you want to copy several pieces of text from one file to another, having to switch between the files and writing the target file takes a lot of time. To avoid this, copy each piece of text to its own register.

A register is a place where vim stores text. Here we will use the registers named a to z (later you will find out there are others). Let’s copy a sentence to the f register (f for First):

 "fyas

The ” yas ” command yanks a sentence like before. It’s the “f that tells vim the text should be place in the f register. This must come just before the yank command.

Now yank three whole lines to the l register ( l for line):

 "l3Y

The count could be before the “l just as well. To yank a block of text to the b (for block) register:

 Ctrl-Vjjww"by

Notice that the register specification “b is just before the “y” command. This is required. If you would have put it before the “w” command, it would not have worked.

Now you have three pieces of text in the f , l and b registers. Edit another file, move around and place the text where you want it:

 "fp

Again, the register specification “f comes before the ” p ” command.

You can put the registers in any order. And the text stays in the register until you yank something else into it. Thus you can put it as many times as you like.

When you delete text, you can also specify a register. Use this to move several pieces of text around. For example, to delete-a-word and write it in the w register:

 "wdaw

Again, the register specification comes before the delete command ” d “.

Viewing A File Read-Only

Sometimes you only want to see what a file contains, without the intention to ever write it back. There is the risk that you type ” :w ” without thinking and overwrite the original file anyway. To avoid this, edit the file read-only.

To start vim in readonly mode, use this command:

 vim -R file

On Unix this command should do the same thing:

 view file

You are now editing “file” in read-only mode. When you try using “:w” you will get an error message and the file won’t be written.

When you try to make a change to the file vim gives you a warning:

 W10: Warning: Changing a readonly file

The change will be done though. This allows for formatting the file, for example, to be able to read it easily.

If you make changes to a file and forgot that it was read-only, you can still write it. Add the ! to the write command to force writing.

If you really want to forbid making changes in a file, do this:

 vim -M file

Now every attempt to change the text will fail. The help files are like this, for example. If you try to make a change you get this error message:

 E21: Cannot make changes, 'modifiable' is off

You could use the -M argument to set up vim to work in a viewer mode. This is only voluntary though, since these commands will remove the protection:

 :set modifiable
 :set write

Saving As A New File Name

A clever way to start editing a new file is by using an existing file that contains most of what you need. For example, you start writing a new program to move a file. You know that you already have a program that copies a file, thus you start with:

 :edit copy.c

You can delete the stuff you don’t need. Now you need to save the file under a new name. The ” :saveas ” command can be used for this:

 :saveas move.c

vim will write the file under the given name, and edit that file. Thus the next time you do ” :write “, it will write ” move.c “. ” copy.c ” remains unmodified.

When you want to change the name of the file you are editing, but don’t want to write the file, you can use this command:

 :file move.c

vim will mark the file as “not edited”. This means that vim knows this is not the file you started editing. When you try to write the file, you might get this message:

 E13: File exists (use ! to override)

This protects you from accidentally overwriting another file.

Splitting Windows

The easiest way to open a new window is to use the following command:

 :split

This command splits the screen into two windows and leaves the cursor in the top one:

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

What you see here is two windows on the same file. The line with “====” is that status line. It displays information about the window above it. In practice the status line will be in reverse video.

The two windows allow you to view two parts of the same file. For example, you could make the top window show the variable declarations of a program, and the bottom one the code that uses these variables.

The Ctrl-W w command can be used to jump between the windows. If you are in the top window, Ctrl-W w jumps to the window below it. If you are in the bottom window it will jump to the first window. Ctrl-W Ctrl-W does the same thing, in case you let go of the Ctrl key a bit later.

To close a window, use the command:

 :close

Actually, any command that quits editing a file works, like ” :quit ” and ” ZZ “. But ” :close ” prevents you from accidentally exiting vim when you close the last window.

If you have opened a whole bunch of windows, but now want to concentrate on one of them, this command will be useful:

 :only

This closes all windows, except for the current one. If any of the other windows has changes, you will get an error message and that window won’t be closed.

Splitting A Window On Another File

The following command opens a second window and starts editing the given file:

 :split two.c

If you were editing one.c , then the result looks like this:

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

To open a window on a new, empty file, use this:

 :new

You can repeat the “:split” and “:new” commands to create as many windows as you like.

Window Size

The ” :split ” command can take a number argument. If specified, this will be the height of the new window. For example, the following opens a new window three lines high and starts editing the file alpha.c :

 :3split alpha.c

For existing windows you can change the size in several ways. When you have a working mouse, it is easy: Move the mouse pointer to the status line that separates two windows, and drag it up or down.

To increase the size of a window: Ctrl-W +

To decrease it: Ctrl-W –

Both of these commands take a count and increase or decrease the window size by that many lines. Thus ” 4 Ctrl-W + ” make the window four lines higher.

To set the window height to a specified number of lines: {height}Ctrl-W _

That’s: a number {height} , Ctrl-W and then an underscore. To make a window as high as it can be, use the Ctrl-W _ command without a count.

Using The Mouse

In vim you can do many things very quickly from the keyboard. Unfortunately, the window resizing commands require quite a bit of typing. In this case, using the mouse is faster. Position the mouse pointer on a status line. Now press the left mouse button and drag. The status line moves, thus making the window on one side higher and the other smaller.

Opções

The ‘ winheight ‘ option can be set to a minimal desired height of a window and ‘ winminheight ‘ to a hard minimum height. Likewise, there is ‘ winwidth ‘ for the minimal desired width and ‘ winminwidth ‘ for the hard minimum width. The ‘ equalalways ‘ option, when set, makes vim equalize the windows sizes when a window is closed or opened.

Vertical splits

The ” :split ” command creates the new window above the current one. To make the window appear at the left side, use:

 :vsplit

ou:

 :vsplit two.c

The result looks something like this:

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

Actually, the || lines in the middle will be in reverse video. This is called the vertical separator. It separates the two windows left and right of it.

There is also the ” :vnew ” command, to open a vertically split window on a new, empty file. Another way to do this:

 :vertical new

The ” :vertical ” command can be inserted before another command that splits a window. This will cause that command to split the window vertically instead of horizontally. If the command doesn’t split a window, it works unmodified.

Moving Between Windows

Since you can split windows horizontally and vertically as much as you like, you can create almost any layout of windows. Then you can use these commands to move between them:

Ctrl-W hmove to the window on the left
Ctrl-W jmove to the window below
Ctrl-W kmove to the window above
Ctrl-W lmove to the window on the right
Ctrl-W tmove to the TOP window
Ctrl-W bmove to the BOTTOM window

You will notice the same letters as used for moving the cursor. And the cursor keys can also be used, if you like.

Moving windows

You have split a few windows, but now they are in the wrong place. Then you need a command to move the window somewhere else. For example, you have three windows like this:

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

Clearly the last one should be at the top. Go to that window (using Ctrl-W w ) and the type this command: Ctrl-W K

This uses the uppercase letter K . What happens is that the window is moved to the very top. You will notice that K is again used for moving upwards. When you have vertical splits, Ctrl-W K moves the current window to the top and make it occupy the full width of the vim window. If this is your layout:

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

Then using Ctrl-W K in the middle window ( three.c ) will result in:

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

The other three similar commands (you can probably guess these now):

Ctrl-W Hmove window to the far left
Ctrl-W Jmove window to the bottom
Ctrl-W Lmove window to the far right

Commands For All Windows

When you have several windows open and you want to quit vim , you can close each window separately. A quicker way is using this command:

 :qall

This stands for “quit all”. If any of the windows contain changes, vim will not exit. The cursor will automatically be positioned in a window with changes. You can then either use ” :write ” to save the changes, or ” :quit! ” to throw them away.

If you know there are windows with changes, and you want to save all these changes, use this command:

 :wall

This stands for “write all”. But actually, it only writes files with changes. The vim command knows it doesn’t make sense to write files that were not changed.

And then there is the combination of ” :qall ” and ” :wall “: the “write and quit all” command:

 :wqall

This writes all modified files and quits vim .

Finally, there is a command that quits vim and throws away all changes:

 :qall!

Be careful, there is no way to undo this command!

Opening A Window For All Files

To make vim open a window for each file, start it with the ” -o ” argument:

 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======================|
	 |  |
	└───────────────────────────────┘

The ” -O ” argument is used to get vertically split windows.

When vim is already running, the ” :all ” command opens a window for each file in the argument list. ” :vertical all ” does it with vertical splits.

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 ):

 vimdiff main.c~ main.c

vim will start, with two windows side by side. You will only see the line in which you added characters, and a few lines above and below it.

 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==============|
	 |  |
	└─────────────────────────────────────────┘

This picture doesn’t show the highlighting, use the vimdiff command for a better look.

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 In 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:

  : editar 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:

  : editar 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:

  : definir 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:

  Faz

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:

0 0Nunca
1somente quando houver janelas divididas (o padrão)
2sempre

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:

: leftabove {cmd}esquerda ou acima da janela atual
: aboveleft {cmd}idem
: rightbelow {cmd}direita ou abaixo da janela atual
: abaixo da direita {cmd}idem
: topleft {cmd}na parte superior ou esquerda da janela do vim
: botright {cmd}na parte inferior ou direita da janela do vim

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:

  : separador de separadores

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:

qaComece a gravar uma macro no registro a .
^Mover para o início da linha.
i # include “<Esc>Insira a string #include “ no início da linha.
$Mover para o final da linha.
um “<Esc>Anexe as aspas duplas de caracteres (  ) ao final da linha.
jVá para a próxima linha.
qPare de gravar a macro.

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:

GVá para o final do arquivo.
o <Esc>Crie uma linha vazia.
“npColoque o texto do registro n . Agora você vê os comandos digitados como texto no arquivo.
{Editar% s}Mude os comandos que estavam errados. É como editar texto.
0 0Vá para o início da linha.
“ny $Arranque os comandos corrigidos no registro n .
ddExclua a linha de rascunho.

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:

  :% substituto / Professor / Professor /

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 / Professor / 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 / Professor / 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:

ySim; faça essa alteração.
nNão; pule esta partida.
umaTudo; faça essa alteração e todas as restantes sem confirmação adicional.
qSair; não faça mais alterações.
euÚltimo; faça essa alteração e saia.
Ctrl-ERole o texto uma linha acima.
Ctrl-YRole o texto uma linha para baixo.

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 / ^ os / estes /

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):

  :'tb

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:

~caso de troca ( a -> A e A -> a )
vocêfazer maiúsculas ( a -> A e A -> A )
vocêfaça minúsculas ( a -> a e A -> a )

Preenchendo um personagem

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).

Mudança

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:

  : defina 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:

  :., $ tempo de gravação

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:

  : coleção de gravação

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 ‘:

  : defina a largura do texto = 72

Para verificar o valor atual de ‘ textwidth ‘:

  : definir largura do texto

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.

  classificar <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:

‘ concha ‘especifica o programa que o vim usa para executar programas externos.
‘ shellcmdflag ‘argumento para passar um comando para o shell
‘ shellquote ‘citação a ser usada em torno do comando
‘ shellxquote ‘citação a ser usada em torno do comando e redirecionamento
‘ shelltype ‘tipo de concha (apenas para o Amiga)
‘ concha ‘use barras no comando (apenas para MS-Windows e similares)
‘ shellredir ‘sequência usada para gravar a saída do comando em um arquivo

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:

  : leia! ls

no MS Windows:

  : leia! 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:

  : escrever! 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:

  :Escreva!  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”.

vim * .cppInicie o vim , definindo a lista de argumentos para conter todos os arquivos C ++. Agora você está no primeiro arquivo.
qqIniciar a gravação no registro q
:% s / \ <GetResp \> / GetAnswer / gFaça as substituições no primeiro arquivo.
: wnextEscreva este arquivo e vá para o próximo.
qPare de gravar.
@qExecute o registro q . Isso repetirá a substituição e ” : wnext “. Você pode verificar se isso não produz uma mensagem de erro.
999@qExecute o registro q nos arquivos restantes. No último arquivo, você receberá uma mensagem de erro, porque ” : wnext ” não pode passar para o próximo arquivo. Isso interrompe a execução e tudo é feito.

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.

There is one catch: If one of the .cpp files does not contain the word “GetResp”, you will get an error and replacing will stop. To avoid this, add the ” e ” flag to the substitute command:

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

The ” e ” flag tells ” :substitute ” that not finding a match is not an error.

In this next example, let’s change the text “Last, First” to “First Last”. Let’s say you have a list of names in this form:

 Doe, John 
	Smith, Peter

You want to change that to:

  John Doe 
	 Peter Smith

This can be done with just one command:

 :%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:

The whole search string is:
 \([^,]*\), \(.*\)
The first part between \( \) matches “Last”:
 \( \)
by matching anything but a comma:
 [^,]
…any number of times:
  *
…then matching a ” , ” literally:
  ,
The second part between \( \) matches “First”:
 \( \)
by matching any character:
  .
…any number of times:
  *

In the “to” part we have ” \2 ” and ” \1 “. These are called backreferences. They refer to the text matched by the ” \( \) ” parts in the pattern. ” \2 ” refers to the text matched by the second ” \( \) “, which is the “First” name. ” \1 ” refers to the first ” \( \) “, which is the “Last” name.

You can use up to nine backreferences in the “to” part of a substitute command. ” \0 ” stands for the whole matched pattern.

Sort a list

In a Makefile you often have a list of files. Por exemplo:

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

To sort this list, filter the text through the external sort command:

 /^OBJS
  j
 :.,/^$/-1!sort

This goes to the first line, where “OBJS” is the first thing in the line. Then it goes one line down and filters the lines until the next empty line. You could also select the lines in Visual mode and then use ” !sort “. That’s easier to type, but more work when there are many lines.

The result is this:

 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.

The simplest solution is to add the backslash with ” A \<Esc> “. You can keep the backslash in the last line, if you make sure an empty line comes after it. That way you don’t have this problem again.

Reverse line order

The :global command can be combined with the :move command to move all the lines before the first line, resulting in a reversed file. O comando é:

 :global/^/m 0

Abbreviated:

 :g/^/m 0

The ” ^ ” regular expression matches the beginning of the line (even if the line is blank). The :move command moves the matching line to after the mythical zeroth line, so the current matching line becomes the first line of the file. As the :global command is not confused by the changing line numbering, :global proceeds to match all remaining lines of the file and puts each as the first.

This also works on a range of lines. First move to above the first line and mark it with “mt”. Then move the cursor to the last line in the range and type:

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

Count words

Sometimes you have to write a text with a maximum number of words. vim can count the words for you.

When the whole file is what you want to count the words in, use this command:

 g Ctrl-G

Do not type a space after the g , this is just used here to make the command easy to read.

A saída é assim:

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

You can see on which word you are (748), and the total number of words in the file (774).

When the text is only part of a file, you could move to the start of the text, type ” g Ctrl-G “, move to the end of the text, type ” g Ctrl-G ” again, and then use your brain to compute the difference in the word position. That’s a good exercise, but there is an easier way. With Visual mode, select the text you want to count words in. Then type g Ctrl-G . The result:

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

Find A man Page

While editing a shell script or C program, you are using a command or function that you want to find the man page for (this applies to Linux, not MS Windows). Let’s first use a simple way: Move the cursor to the word you want to find help on and press K .

vim will run the external man program on the word. If the man page is found, it is displayed. This uses the normal pager to scroll through the text (mostly the more program). When you get to the end pressing <Enter> will get you back into vim .

A disadvantage is that you can’t see the man page and the text you are working on at the same time. There is a trick to make the man page appear in a vim window. First, load the man filetype plugin:

 :runtime! ftplugin/man.vim

Put this command in your vimrc file if you intend to do this often. Now you can use the ” :Man ” command to open a window on a man page:

 :Man csh

You can scroll around and the text is highlighted, which allows you to find the help you were looking for. Use Ctrl-W w to jump to the window with the text you were working on.

To find a man page in a specific section, put the section number first. For example, to look in section 3 for ” echo “:

 :Man 3 echo

To jump to another man page, which is in the text with the typical form “word(1)”, press Ctrl-] on it. Further ” :Man ” commands will use the same window.

To display a man page for the word under the cursor, use the command \K .

(If you redefined the <Leader> , use it instead of the backslash). For example, you want to know the return value of ” strstr() ” while editing this line:

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

Move the cursor to somewhere on ” strstr ” and type ” \K “. A window will open to display the man page for strstr() .

Trim blanks

Some people find spaces and tabs at the end of a line useless, wasteful, and ugly. To remove whitespace at the end of every line, execute the following command:

 :%s/\s\+$//

The line range “%” is used, thus this works on the whole file. The pattern that the ” :substitute ” command matches with is ” \s\+$ “. This finds white space characters (\s), 1 or more of them (\+), before the end-of-line ($).

The “to” part of the substitute command is empty: “//”. Thus it replaces with nothing, effectively deleting the matched white space.

Another wasteful use of spaces is placing them before a tab. Often these can be deleted without changing the amount of white space. But not always! Therefore, you can best do this manually. Use this search command: ” / “. You cannot see it, but there is a space before a tab in this command. Thus it’s ” /<Space><Tab> “. Now use ” x ” to delete the space and check that the amount of white space doesn’t change. You might have to insert a tab if it does change. Type ” n ” to find the next match. Repeat this until no more matches can be found.

Find where a word is used

If you are a UNIX user, you can use a combination of vim and the grep command to edit all the files that contain a given word. This is extremely useful if you are working on a program and want to view or edit all the files that contain a specific variable.

For example, suppose you want to edit all the C program files that contain the word “frame_counter”. To do this you use the command:

 vim `grep -l frame_counter *.c`

Let’s look at this command in detail. The grep command searches through a set of files for a given word. Because the -l argument is specified, the command will only list the files containing the word and not print the matching lines. The word it is searching for is “frame_counter”. Actually, this can be any regular expression. Note: What grep uses for regular expressions is not exactly the same as what vim uses.

The entire command is enclosed in backticks (” ` “). This tells the UNIX shell to run this command and pretend that the results were typed on the command line. So what happens is that the grep command is run and produces a list of files, these files are put on the vim command line. This results in vim editing the file list that is the output of grep . You can then use commands like ” :next ” and ” :first ” to browse through the files.

Finding Each Line

The above command only finds the files in which the word is found. You still have to find the word within the files.

vim has a built-in command that you can use to search a set of files for a given string. If you want to find all occurrences of “error_string” in all C program files, for example, enter the following command:

 :grep error_string *.c

This causes vim to search for the string “error_string” in all the specified files (*.c). The editor will now open the first file where a match is found and position the cursor on the first matching line. To go to the next matching line (no matter in what file it is), use the ” :cnext ” command. To go to the previous match, use the ” :cprev ” command. Use ” :clist ” to see all the matches and where they are.

The ” :grep ” command uses the external commands grep (on Unix) or findstr (on Windows). You can change this by setting the option ‘ grepprg ‘.

Command Line Abbreviations

Some of the ” : ” commands are really long. We already mentioned that ” :substitute ” can be abbreviated to ” :s “. This is a generic mechanism, all ” : ” commands can be abbreviated.

How short can a command get? There are 26 letters, and many more commands. For example, ” :set ” also starts with ” :s “, but ” :s ” doesn’t start a ” :set ” command. Instead ” :set ” can be abbreviated to ” :se “.

When the shorter form of a command could be used for two commands, it stands for only one of them. There is no logic behind which one, you have to learn them. In the help files the shortest form that works is mentioned. Por exemplo:

 :s[ubstitute]

This means that the shortest form of ” :substitute ” is ” :s “. The following characters are optional. Thus ” :su ” and ” :sub ” also work.

In the user manual we will either use the full name of command, or a short version that is still readable. For example, ” :function ” can be abbreviated to ” :fu “. But since most people don’t understand what that stands for, we will use ” :fun “. vim doesn’t have a ” :funny ” command, otherwise ” :fun ” would be confusing too.

It is recommended that in vim scripts you write the full command name. That makes it easier to read back when you make later changes. Except for some often used commands like ” :w ” (” :write “) and ” :r ” (” :read “).

A particularly confusing one is ” :end “, which could stand for ” :endif “, ” :endwhile ” or ” :endfunction “. Therefore, always use the full name.

Short Option Names

In the user manual the long version of the option names is used. Many options also have a short name. Unlike ” : ” commands, there is only one short name that works. For example, the short name of ‘autoindent’ is ‘ai’. Thus these two commands do the same thing:

 :set autoindent
:set ai

Command Line Completion

This is one of those vim features that, by itself, is a reason to switch from Vi to vim . Once you have used this, you can’t do without.

Suppose you have a directory that contains these files:

  info.txt
	intro.txt
	bodyofthepaper.txt

To edit the last one, you use the command:

 :edit bodyofthepaper.txt

It’s easy to type this wrong. A much quicker way is:

 :edit b<Tab>

Which will result in the same command. O que aconteceu? The <Tab> key does completion of the word before the cursor. In this case ” b “. vim looks in the directory and finds only one file that starts with a ” b “. That must be the one you are looking for, thus vim completes the file name for you.

Now type:

 :edit i<Tab>

vim will beep, and give you:

 :edit info.txt

The beep means that vim has found more than one match. It then uses the first match it found (alphabetically). If you press <Tab> again, you get:

 :edit intro.txt

Thus, if the first <Tab> doesn’t give you the file you were looking for, press it again. If there are more matches, you will see them all, one at a time.

If you press <Tab> on the last matching entry, you will go back to what you first typed:

 :edit i

Then it starts all over again. Thus vim cycles through the list of matches. Use Ctrl-P to go through the list in the other direction:

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

Command Context

When you type ” :set i ” instead of ” :edit i ” and press <Tab> you get:

 :set icon

Hey, why didn’t you get ” :set info.txt “? That’s because vim has context sensitive completion. The kind of words vim will look for depends on the command before it. The vim command knows that you cannot use a file name just after a ” :set ” command, but you can use an option name.

Again, if you repeat typing the <Tab> , vim will cycle through all matches. There are quite a few, it’s better to type more characters first:

 :set isk<Tab>

Dá:

 :set iskeyword

Now type ” = ” and press <Tab> :

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

What happens here is that vim inserts the old value of the option. Now you can edit it.

What is completed with <Tab> is what vim expects in that place. Just try it out to see how it works. In some situations, you will not get what you want. That’s either because vim doesn’t know what you want, or because completion was not implemented for that situation. In that case you will get a <Tab> inserted (displayed as ^I ).

Viewing List Matches

When there are many matches, you would like to see an overview. Do this by pressing Ctrl-D . For example, pressing Ctrl-D after:

 :set is

resulta em:

 :set is
incsearch isfname isident iskeyword isprint
:set is

vim lists the matches and then comes back with the text you typed. You can now check the list for the item you wanted. If it isn’t there, you can use <BS> to correct the word. If there are many matches, type a few more characters before pressing <Tab> to complete the rest.

If you have watched carefully, you will have noticed that “incsearch” doesn’t start with “is”. In this case “is” stands for the short name of “incsearch”. Many options have a short and a long name. vim is clever enough to know that you might have wanted to expand the short name of the option into the long name.

Há mais

The Ctrl-L command completes the word to the longest unambiguous string. If you type ” :edit i ” and there are files “info.txt” and “info_backup.txt” you will get ” :edit info “.

The ‘ wildmode ‘ option can be used to change the way completion works. The ‘ wildmenu ‘ option can be used to get a menu-like list of matches. Use the ‘ suffixes ‘ option to specify files that are less important and appear at the end of the list of files. The ‘ wildignore ‘ option specifies files that are not listed at all.

Exemplos

  vim

Launches vim , placing you in normal mode with a new document.

 vim document.txt

Inicia o vim e abre o arquivo document.txt , ou um documento em branco, se document.txt ainda não existir.

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.

25 de novembro de 2019

Sobre nós

A Linux Force Brasil é uma empresa que ama a arte de ensinar. Nossa missão é criar talentos para a área de tecnologia e atender com excelência nossos clientes.

CNPJ: 13.299.207/0001-50
SAC:         0800 721 7901

sac@linuxforce.com.br

Comercial: 11 3796-7900

Suporte:    11 3796-5900
contato@linuxforce.com.br

Últimos Tweets

Erro ao receber tweets

Administrador Online

Não há usuários online neste momento
Copyright © Linux Force Security - Desde 2011.