Eu ouvi muito sobre o Vim , prós e contras. Parece que você deve ser (como desenvolvedor) mais rápido com o Vim do que com qualquer outro editor. Estou usando o Vim para fazer algumas coisas básicas e, na melhor das hipóteses, sou 10 vezes menos produtivo com o Vim.

As duas únicas coisas com as quais você deve se preocupar ao falar sobre velocidade (você pode não se importar o suficiente com elas, mas deveria) são:

1. Usar as mãos esquerda e direita como alternativa é a maneira mais rápida de usar o teclado.
2. Nunca tocar no mouse é a segunda maneira de ser o mais rápido possível. Demora muito tempo para você mover sua mão, pegar o mouse, movê-lo e trazê-lo de volta para o teclado (e muitas vezes é necessário olhar para o teclado para ter certeza de que você retornou sua mão corretamente ao lugar certo)

Aqui estão dois exemplos que demonstram por que sou muito menos produtivo com o Vim.

Copiar / Recortar e colar. Eu faço isso o tempo todo. Com todos os editores contemporâneos, você pressiona Shift com a mão esquerda e move o cursor com a mão direita para selecionar o texto. Então Ctrl+ Ccopia, você move o cursor e Ctrl+ Vpastas.

Com o Vim é horrível:

• yy copiar uma linha (você quase nunca deseja a linha inteira!)
• [number xx]yypara copiar xxlinhas no buffer. Mas você nunca sabe exatamente se selecionou o que queria. Muitas vezes eu tenho que fazer [number xx]ddentão upara desfazer!

Outro exemplo? Pesquise e substitua.

• No PSPad : Ctrl+ f, digite o que deseja pesquisar e pressione Enter.
• No Vim:, /digite o que deseja pesquisar e, se houver alguns caracteres especiais colocados \antes de cada caractere especial, pressione Enter.

E tudo com o Vim é assim: parece que eu não sei como lidar com isso da maneira certa.

NB: Eu já li a folha de dicas do Vim :)

Minha pergunta é:

Qual é a maneira como você usa o Vim que o torna mais produtivo do que com um editor contemporâneo?

Seu problema com o Vim é que você não grok vi .

Você menciona cortar yye reclamar que quase nunca deseja cortar linhas inteiras. De fato, os programadores, editando o código-fonte, muitas vezes desejam trabalhar em linhas inteiras, intervalos de linhas e blocos de código. No entanto, yyé apenas uma das muitas maneiras de puxar o texto para o buffer de cópia anônimo (ou "registrar", como é chamado no vi ).

O "zen" do vi é que você está falando um idioma. A inicial yé um verbo. A declaração yyé sinônimo de y_. O ydobrou para facilitar a digitação, pois é uma operação tão comum.

Isso também pode ser expresso como dd P(exclua a linha atual e cole uma cópia de volta no lugar; deixar uma cópia no registro anônimo como efeito colateral). Os ye d"verbos" tomar qualquer movimento como o "sujeito". Assim, yWé "puxar daqui (o cursor) até o final da palavra atual / seguinte (grande)" e y'aé "puxar daqui para a linha que contém a marca denominada ' a '".

Se você entender apenas os movimentos básicos do cursor para cima, baixo, esquerda e direita, o vi não será mais produtivo do que uma cópia do "bloco de notas" para você. (Ok, você ainda terá o destaque da sintaxe e a capacidade de lidar com arquivos maiores que uns 45KB ou mais; então trabalhe comigo aqui).

vi possui 26 "marcas" e 26 "registros". Uma marca é definida para qualquer local do cursor usando o mcomando Cada marca é designada por uma única letra minúscula. Assim, madefine a marca ' a ' para o local atual e mzdefine a marca ' z '. Você pode ir para a linha que contém uma marca usando o 'comando (aspas simples). Assim, 'amove-se para o início da linha que contém a marca ' a '. Você pode ir para o local preciso de qualquer marca usando o `comando (aspas). Assim `z, moverá diretamente para o local exato da marca ' z '.

Por serem "movimentos", eles também podem ser usados ​​como sujeitos para outras "declarações".

Portanto, uma maneira de cortar uma seleção arbitrária de texto seria largar uma marca (eu costumo usar ' a ' como minha "primeira marca", ' z ' como minha próxima marca, ' b ' como outra e ' e ' como outro (não me lembro de ter usado interativamente mais de quatro marcas em 15 anos de uso do vi ; cria-se as próprias convenções sobre como as marcas e os registros são usados ​​por macros que não perturbam o contexto interativo). para a outra extremidade do texto desejado; podemos começar em qualquer extremidade, não importa. Em seguida, podemos simplesmente usar d`apara recortar ou y`acopiar. Portanto, todo o processo possui cinco pressionamentos de tecla (seis se começamos em "insert"). "modo e necessário paraEscfora do modo de comando). Uma vez que tenhamos cortado ou copiado, em seguida, colando em uma cópia é uma única tecla: p.

Eu digo que essa é uma maneira de cortar ou copiar texto. No entanto, é apenas um de muitos. Frequentemente, podemos descrever de maneira mais sucinta o intervalo de texto sem mover o cursor e soltar uma marca. Por exemplo, se eu estou em um parágrafo de texto que posso usar {e }movimentos para o início ou fim do parágrafo, respectivamente. Então, para mover um parágrafo de texto, eu o cortei usando { d}(3 pressionamentos de tecla). (Se já estiver na primeira ou na última linha do parágrafo, posso simplesmente usar d}ou d{respectivamente.

A noção de "parágrafo" assume como padrão algo que geralmente é intuitivamente razoável. Assim, muitas vezes funciona tanto para código quanto para prosa.

Freqüentemente conhecemos algum padrão (expressão regular) que marca uma extremidade ou a outra do texto em que estamos interessados. Procurar para frente ou para trás são movimentos no vi . Assim, eles também podem ser usados ​​como "sujeitos" em nossas "declarações". Então, eu posso usar d/foopara cortar da linha atual para a próxima linha que contém a string "foo" e y?barcopiar da linha atual para a linha mais recente (anterior) que contém "bar". Se não quiser linhas inteiras, ainda posso usar os movimentos de pesquisa (como declarações próprias), largar minha (s) marca (s) e usar os `xcomandos conforme descrito anteriormente.

Além de "verbos" e "sujeitos", o vi também possui "objetos" (no sentido gramatical do termo). Até agora, descrevi apenas o uso do registro anônimo. No entanto, eu posso usar qualquer um dos 26 registros "nomeados" prefixando a referência "objeto" com "(o modificador de aspas duplas). Portanto, se eu usar "add, estou cortando a linha atual no registro ' a ' e, se usar "by/foo, estou puxando uma cópia do texto daqui para a próxima linha que contém "foo" no registro ' b '. Para colar a partir de um registo I simplesmente prefixar a pasta com a mesma sequência de modificador: "apcola uma cópia da ' um ' registo'"bPcola uma cópia de ' b ' antes da linha atual.

Essa noção de "prefixos" também adiciona os análogos dos "adjetivos" gramaticais e dos "advérbios" à linguagem da "manipulação de texto". A maioria dos comandos (verbos) e movimento (verbos ou objetos, dependendo do contexto) também podem usar prefixos numéricos. 3Jsignifica "unir as próximas três linhas" e d5}significa "excluir da linha atual até o final do quinto parágrafo abaixo daqui".

Isso tudo é nível intermediário vi . Nada disso é específico do Vim e existem truques muito mais avançados no vi, se você estiver pronto para aprendê-los. Se você dominar apenas esses conceitos intermediários, provavelmente descobrirá que raramente precisa escrever macros porque a linguagem de manipulação de texto é suficientemente concisa e expressiva para fazer a maioria das coisas com bastante facilidade usando a linguagem "nativa" do editor.

Uma amostra de truques mais avançados:

Existem vários :comandos, principalmente a :% s/foo/bar/gtécnica de substituição global. (Isso não é avançado, mas outros :comandos podem ser). Todo o :conjunto de comandos foi herdado historicamente pelas encarnações anteriores do vi como os utilitários ed (editor de linha) e, posteriormente, o ex (editor de linha estendida). Na verdade, vi é assim chamado porque é a interface visual para ex .

:comandos normalmente operam sobre linhas de texto. ed e ex foram escritos em uma época em que as telas dos terminais eram incomuns e muitos terminais eram dispositivos "teletype" (TTY). Por isso, era comum trabalhar com cópias impressas do texto, usando comandos por meio de uma interface extremamente concisa (as velocidades de conexão comuns eram de 110 baud ou aproximadamente 11 caracteres por segundo - o que é mais lento que um datilógrafo rápido; sessões interativas para vários usuários; além disso, muitas vezes havia alguma motivação para economizar papel).

Portanto, a sintaxe da maioria dos :comandos inclui um endereço ou intervalo de endereços (número da linha) seguido por um comando. Naturalmente, pode-se usar números de linhas literais: :127,215 s/foo/barpara alterar a primeira ocorrência de "foo" em "bar" em cada linha entre 127 e 215. Também se pode usar algumas abreviações como .ou $para as linhas atuais e últimas, respectivamente. Também se pode usar prefixos relativos +e -se referir a compensações antes ou antes da linha atual, respectivamente. Assim: :.,$jsignificando "da linha atual até a última linha, junte todos eles em uma linha". :%é sinônimo de :1,$(todas as linhas).

Os comandos :... ge :... vdão algumas explicações, pois são incrivelmente poderosos. :... gé um prefixo para "globalmente" aplicar um comando subseqüente a todas as linhas que correspondem a um padrão (expressão regular) enquanto :... vaplica esse comando a todas as linhas que NÃO correspondem ao padrão especificado ("v" de "conVerse"). Como com outros comandos ex, estes podem ser prefixados por referências de endereçamento / intervalo. Assim, :.,+21g/foo/dsignifica "excluir quaisquer linhas que contenham a string" foo "da atual até as próximas 21 linhas" enquanto :.,$v/bar/dsignifica "daqui até o final do arquivo, exclua quaisquer linhas que NÃO contenham a string" bar ".

É interessante que o comando comum do Unix grep foi realmente inspirado por este comando ex (e é nomeado após a maneira como foi documentado). O comando ex:g/re/p (grep) foi a maneira como eles documentaram como "globalmente" "imprimir" linhas contendo uma "expressão regular" (re). Quando ed e ex foram usados, o :pcomando foi um dos primeiros que alguém aprendeu e, geralmente, o primeiro usado ao editar qualquer arquivo. Foi assim que você imprimiu o conteúdo atual (geralmente apenas uma página cheia de cada vez usando :.,+25pou algo parecido).

Observe que :% g/.../dou (sua contraparte inversa / inversa: :% v/.../dsão os padrões de uso mais comuns. No entanto, existem alguns outros excomandos que vale a pena lembrar:

Podemos usar mpara mover linhas e junir linhas. Por exemplo, se você tem uma lista e deseja separar todos os itens correspondentes (ou inversamente NÃO correspondentes a algum padrão) sem excluí-los, pode usar algo como: :% g/foo/m$... e todas as linhas "foo" serão movidas para o final do arquivo. (Observe a outra dica sobre como usar o final do seu arquivo como um espaço temporário). Isso preservará a ordem relativa de todas as linhas "foo" e as extrairá do restante da lista. (Isso seria equivalente a fazer algo como: 1G!GGmap!Ggrep foo<ENTER>1G:1,'a g/foo'/d(copie o arquivo para sua própria cauda, ​​filtre a cauda grepe exclua todas as coisas da cabeça).

Para unir linhas normalmente, posso encontrar um padrão para todas as linhas que precisam ser unidas ao seu antecessor (todas as linhas que começam com "^" em vez de "^ *" em uma lista de marcadores, por exemplo). Nesse caso, eu usaria: :% g/^ /-1j(para cada linha correspondente, suba uma linha e junte-se a elas). (BTW: para listas de bala tentando procurar as linhas de bala e juntar-se para a próxima não funciona para algumas razões ... ele pode se juntar a uma linha de bala para outro, e não vai aderir a qualquer linha de bala para todos de suas continuações; funcionará apenas em pares nas partidas).

Quase desnecessário mencionar que você pode usar nosso velho amigo s(substituto) com os comandos ge v(global / converse-global). Normalmente você não precisa fazer isso. No entanto, considere alguns casos em que você deseja executar uma substituição apenas em linhas que correspondam a algum outro padrão. Freqüentemente, você pode usar um padrão complicado com capturas e usar referências anteriores para preservar as partes das linhas que você NÃO deseja alterar. No entanto, muitas vezes será mais fácil separar a partida da substituição: :% g/foo/s/bar/zzz/g- para cada linha que contém "foo" substitua todas as "barras" por "zzz". (Algo como:% s/\(.*foo.*\)bar\(.*\)/\1zzz\2/gfuncionaria apenas para os casos aquelas instâncias de "bar" que foram PRECEDIDAS por "foo" na mesma linha; já é desajeitado o suficiente e precisaria ser distorcido para capturar todos os casos em que "bar" precedeu "foo")

O ponto é que há mais do que apenas p, se dlinhas no exconjunto de comandos.

Os :endereços também podem se referir a marcas. Assim, você pode usar: :'a,'bg/foo/jpara unir qualquer linha que contenha a string foo à sua linha subseqüente, se estiver entre as linhas entre as marcas ' a ' e ' b '. (Sim, todos os exexemplos de comandos anteriores podem ser limitados a subconjuntos das linhas do arquivo prefixando esses tipos de expressões de endereçamento).

Isso é bastante obscuro (eu só usei algo assim algumas vezes nos últimos 15 anos). No entanto, admitirei livremente que muitas vezes fiz coisas de forma interativa e interativa que provavelmente poderiam ter sido feitas com mais eficiência se eu tivesse tempo para pensar no encantamento correto.

Outro comando vi ou ex muito útil é :rler o conteúdo de outro arquivo. Assim: :r fooinsere o conteúdo do arquivo chamado "foo" na linha atual.

Mais poderoso é o :r!comando. Isso lê os resultados de um comando. É o mesmo que suspender a sessão do vi , executar um comando, redirecionar sua saída para um arquivo temporário, retomar a sua sessão do vi e ler o conteúdo do temp. Arquivo.

Ainda mais poderosos são os comandos !(bang) e :... !( ex bang). Eles também executam comandos externos e lêem os resultados no texto atual. No entanto, eles também filtram seleções do nosso texto através do comando! Podemos ordenar todas as linhas em nosso arquivo 1G!Gsort( Gé o comando vi "goto"; o padrão é ir para a última linha do arquivo, mas pode ser prefixado por um número de linha, como 1, a primeira linha). Isso é equivalente à variante ex:1,$!sort . Os escritores costumam usar !os utilitários Unix fmt ou fold para reformatar ou "agrupar palavras" seleções de texto. Uma macro muito comum é{!}fmt(reformate o parágrafo atual). Às vezes, os programadores o usam para executar seu código, ou apenas partes dele, por meio de recuo ou outras ferramentas de reformatação de código.

Usar os comandos :r!e !significa que qualquer utilitário ou filtro externo pode ser tratado como uma extensão do nosso editor. Ocasionalmente, eu os usei com scripts que extraíam dados de um banco de dados ou com comandos wget ou lynx que extraíram dados de um site ou comandos ssh que extraíram dados de sistemas remotos.

Outro comando ex útil é :so(abreviação de :source). Isso lê o conteúdo de um arquivo como uma série de comandos. Quando você começar a vi normalmente, implicitamente, realiza uma :sourceem ~/.exinitrcarquivo (e Vim normalmente faz isso em ~/.vimrc, naturalmente). O uso disso é que você pode alterar o perfil do editor em tempo real, fornecendo simplesmente um novo conjunto de macros, abreviações e configurações do editor. Se você é sorrateiro, pode até usar isso como um truque para armazenar sequências de comandos de edição ex para aplicar a arquivos sob demanda.

Por exemplo, eu tenho um arquivo de sete linhas (36 caracteres) que executa um arquivo no wc e insere um comentário no estilo C na parte superior do arquivo que contém esses dados de contagem de palavras. Posso aplicar essa "macro" a um arquivo usando um comando como:vim +'so mymacro.ex' ./mytarget

(A +opção de linha de comando para vi e Vim é normalmente usada para iniciar a sessão de edição em um determinado número de linha. No entanto, é um fato pouco conhecido que se pode seguir +qualquer expressão / comando ex válido , como um comando "source" como Eu fiz aqui; para um exemplo simples, tenho scripts que invocam: vi +'/foo/d|wq!' ~/.ssh/known_hostspara remover uma entrada do meu arquivo de hosts conhecidos SSH de maneira não interativa enquanto estou reinventando um conjunto de servidores).

Geralmente é muito mais fácil escrever essas "macros" usando Perl, AWK, sed (que é, de fato, como grep um utilitário inspirado no comando ed ).

O @comando é provavelmente o comando vi mais obscuro . Ocasionalmente, ministrando cursos avançados de administração de sistemas por quase uma década, conheci muito poucas pessoas que já o usaram. @executa o conteúdo de um registro como se fosse um comando vi ou ex .
Exemplo: Costumo usar: :r!locate ...para encontrar algum arquivo no meu sistema e ler seu nome no meu documento. A partir daí, excluo quaisquer ocorrências estranhas, deixando apenas o caminho completo para o arquivo em que estou interessado. Em vez de trabalhar Tabminuciosamente em cada componente do caminho (ou pior, se estiver preso em uma máquina sem o suporte à conclusão da guia em sua cópia do vi ) eu apenas uso:

1. 0i:r(para transformar a linha atual em um comando válido : r ),
2. "cdd (para excluir a linha no registro "c") e
3. @c execute esse comando.

São apenas 10 pressionamentos de tecla (e a expressão "cdd @cé efetivamente uma macro de dedo para mim, para que eu possa digitá-la quase tão rapidamente quanto qualquer palavra comum de seis letras).

Um pensamento sóbrio

Eu apenas arranhei a superfície do poder do vi e nada do que descrevi aqui faz parte das "melhorias" para as quais o vim é nomeado! Tudo o que descrevi aqui deve funcionar em qualquer cópia antiga do vi de 20 ou 30 anos atrás.

Existem pessoas que usaram consideravelmente mais o poder do vi do que eu jamais usarei.

Você está falando sobre a seleção e cópia de texto, acho que você deveria dar uma olhada no Modo Visual Vim .

No modo visual, você pode selecionar o texto usando os comandos do Vim e pode fazer o que quiser com a seleção.

Considere os seguintes cenários comuns:

Você precisa selecionar o próximo parêntese correspondente.

Você poderia fazer:

• v% se o cursor estiver entre parênteses inicial / final
• vib se o cursor estiver dentro do bloco de parênteses

Você deseja selecionar o texto entre aspas:

• vi " para aspas duplas
• vi ' para aspas simples

Você deseja selecionar um bloco de chaves (muito comum em idiomas no estilo C):

• viB
• vi{

Você deseja selecionar o arquivo inteiro:

• ggVG

A seleção do bloco visual é outro recurso realmente útil, pois permite selecionar uma área retangular do texto, basta pressionar Ctrl- Vpara iniciá-lo e, em seguida, selecionar o bloco de texto desejado e executar qualquer tipo de operação, como puxar, excluir, colar, editar etc. É ótimo editar texto orientado a colunas .

Algumas dicas de produtividade:

Movimentos inteligentes

• *e #procure a palavra sob o cursor para frente / para trás.
• w para a próxima palavra
• W para a próxima palavra separada por espaço
• b/ epara o início / fim da palavra atual. ( B/ apenas Epara espaço separado)
• gg/ Gpula para o início / fim do arquivo.
• % pule para a correspondência {..} ou (..), etc.
• {/ }pula para o próximo parágrafo.
• '. volte para a última linha editada.
• g; pule de volta para a última posição editada.

Comandos de edição rápida

• I insira no início.
• A acrescente ao fim.
• o/ Oabre uma nova linha depois / antes da atual.
• v/ V/ Ctrl+VModo visual (para selecionar texto!)
• Shift+R substituir texto
• C alterar parte restante da linha.

Combinando comandos

A maioria dos comandos aceita uma quantidade e direção, por exemplo:

• cW = alterar até o final da palavra
• 3cW = alterar 3 palavras
• BcW = para iniciar a palavra completa, altere a palavra completa
• ciW = altera a palavra interior.
• ci" = mudar interior entre ".."
• ci( = alterar texto entre (..)
• ci<= altera o texto entre <..> (necessidades set matchpairs+=<:>no vimrc)
• 4dd = excluir 4 linhas
• 3x = excluir 3 caracteres.
• 3s = substitua 3 caracteres.

Comandos úteis do programador

• rsubstitua um caractere (por exemplo, rdsubstitui o caractere atual por d).
• ~ muda caso.
• J junta duas linhas
• Ctrl + A / Ctrl + X aumenta / diminui um número.
• . repita o último comando (uma macro simples)
• == recuar linha de correção
• > bloco de indentação (no modo visual)
• < bloco unindent (no modo visual)

Gravação de macro

• Pressione q[ key ]para iniciar a gravação.
• Em seguida, pressione qpara parar a gravação.
• A macro pode ser reproduzida com @[ key ].

Usando comandos e movimentos muito específicos, o VIM pode reproduzir essas ações exatas para as próximas linhas. (por exemplo, A para acrescentar até o fim, b/ epara mover o cursor para o início ou o fim de uma palavra, respectivamente)

Exemplo de configurações bem construídas

# reset to vim-defaults
if &compatible          # only if not set before:
  set nocompatible      # use vim-defaults instead of vi-defaults (easier, more user friendly)
endif

# display settings
set background=dark     # enable for dark terminals
set nowrap              # dont wrap lines
set scrolloff=2         # 2 lines above/below cursor when scrolling
set number              # show line numbers
set showmatch           # show matching bracket (briefly jump)
set showmode            # show mode in status bar (insert/replace/...)
set showcmd             # show typed command in status bar
set ruler               # show cursor position in status bar
set title               # show file in titlebar
set wildmenu            # completion with menu
set wildignore=*.o,*.obj,*.bak,*.exe,*.py[co],*.swp,*~,*.pyc,.svn
set laststatus=2        # use 2 lines for the status bar
set matchtime=2         # show matching bracket for 0.2 seconds
set matchpairs+=<:>     # specially for html

# editor settings
set esckeys             # map missed escape sequences (enables keypad keys)
set ignorecase          # case insensitive searching
set smartcase           # but become case sensitive if you type uppercase characters
set smartindent         # smart auto indenting
set smarttab            # smart tab handling for indenting
set magic               # change the way backslashes are used in search patterns
set bs=indent,eol,start # Allow backspacing over everything in insert mode

set tabstop=4           # number of spaces a tab counts for
set shiftwidth=4        # spaces for autoindents
#set expandtab           # turn a tabs into spaces

set fileformat=unix     # file mode is unix
#set fileformats=unix,dos    # only detect unix file format, displays that ^M with dos files

# system settings
set lazyredraw          # no redraws in macros
set confirm             # get a dialog when :q, :w, or :wq fails
set nobackup            # no backup~ files.
set viminfo='20,\"500   # remember copy registers after quitting in the .viminfo file -- 20 jump links, regs up to 500 lines'
set hidden              # remember undo after quitting
set history=50          # keep 50 lines of command history
set mouse=v             # use mouse in visual mode (not normal,insert,command,help mode


# color settings (if terminal/gui supports it)
if &t_Co > 2 || has("gui_running")
  syntax on          # enable colors
  set hlsearch       # highlight search (very useful!)
  set incsearch      # search incremently (search while typing)
endif

# paste mode toggle (needed when using autoindent/smartindent)
map <F10> :set paste<CR>
map <F11> :set nopaste<CR>
imap <F10> <C-O>:set paste<CR>
imap <F11> <nop>
set pastetoggle=<F11>

# Use of the filetype plugins, auto completion and indentation support
filetype plugin indent on

# file type specific settings
if has("autocmd")
  # For debugging
  #set verbose=9

  # if bash is sh.
  let bash_is_sh=1

  # change to directory of current file automatically
  autocmd BufEnter * lcd %:p:h

  # Put these in an autocmd group, so that we can delete them easily.
  augroup mysettings
    au FileType xslt,xml,css,html,xhtml,javascript,sh,config,c,cpp,docbook set smartindent shiftwidth=2 softtabstop=2 expandtab
    au FileType tex set wrap shiftwidth=2 softtabstop=2 expandtab

    # Confirm to PEP8
    au FileType python set tabstop=4 softtabstop=4 expandtab shiftwidth=4 cinwords=if,elif,else,for,while,try,except,finally,def,class
  augroup END

  augroup perl
    # reset (disable previous 'augroup perl' settings)
    au!  

    au BufReadPre,BufNewFile
    \ *.pl,*.pm
    \ set formatoptions=croq smartindent shiftwidth=2 softtabstop=2 cindent cinkeys='0{,0},!^F,o,O,e' " tags=./tags,tags,~/devel/tags,~/devel/C
    # formatoption:
    #   t - wrap text using textwidth
    #   c - wrap comments using textwidth (and auto insert comment leader)
    #   r - auto insert comment leader when pressing <return> in insert mode
    #   o - auto insert comment leader when pressing 'o' or 'O'.
    #   q - allow formatting of comments with "gq"
    #   a - auto formatting for paragraphs
    #   n - auto wrap numbered lists
    #   
  augroup END


  # Always jump to the last known cursor position. 
  # Don't do it when the position is invalid or when inside
  # an event handler (happens when dropping a file on gvim). 
  autocmd BufReadPost * 
    \ if line("'\"") > 0 && line("'\"") <= line("$") | 
    \   exe "normal g`\"" | 
    \ endif 

endif # has("autocmd")

As configurações podem ser armazenadas em todo o ~/.vimrcsistema ou, em /etc/vimrc.localseguida, lidas no /etc/vimrcarquivo usando:

source /etc/vimrc.local

(você precisará substituir o #caractere de comentário "para que ele funcione no VIM, eu queria destacar aqui a sintaxe adequada).

Os comandos que listei aqui são bem básicos e os principais que eu uso até agora. Eles já me deixam bem mais produtivo, sem precisar conhecer todas as coisas chiques.

O mecanismo Control+ Ré muito útil :-) No modo de inserção ou modo de comando (ou seja, na :linha ao digitar comandos), continue com um registro numerado ou nomeado:

• a- zos registros nomeados
• " o registro sem nome, contendo o texto da última exclusão ou puxão
  
• % o nome do arquivo atual
  
• # o nome do arquivo alternativo
  
• * o conteúdo da área de transferência (X11: seleção primária)
  
• + o conteúdo da área de transferência
  
• / o último padrão de pesquisa
  
• : a última linha de comando
  
• . o último texto inserido
  
• - a última exclusão pequena (menos de uma linha)
  
• =5*5 insira 25 no texto (mini-calculadora)

Veja :help i_CTRL-Re :help c_CTRL-Rpara obter mais detalhes e bisbilhotar nas proximidades para obter mais vantagens CTRL-R.

Vim Plugins

Há muitas boas respostas aqui, e uma surpreendente sobre o zen do vi. Uma coisa que não vejo mencionada é que o vim é extremamente extensível através de plugins. Existem scripts e plugins para fazer todo tipo de loucura que o autor original nunca considerou. Aqui estão alguns exemplos de plugins vim incrivelmente úteis:

rails.vim

O Rails.vim é um plugin criado pelo tpope. É uma ferramenta incrível para pessoas que desenvolvem trilhos. Faz coisas mágicas sensíveis ao contexto que permitem que você pule facilmente de um método em um controlador para a visualização associada, para um modelo e para testes de unidade desse modelo. Ele salvou dezenas, senão centenas de horas, como desenvolvedor de trilhos.

gist.vim

Este plug-in permite que você selecione uma região de texto no modo visual e digite um comando rápido para publicá-lo no gist.github.com . Isso permite um acesso fácil à pasta, o que é incrivelmente útil se você estiver colaborando com alguém por meio de IRC ou IM.

space.vim

Este plugin fornece funcionalidade especial para a barra de espaço. Ele transforma a barra de espaço em algo análogo ao período, mas, em vez de repetir ações, repete movimentos. Isso pode ser muito útil para percorrer rapidamente um arquivo da maneira que você definir em tempo real.

surround.vim

Este plugin permite trabalhar com texto delimitado de alguma forma. Ele fornece objetos que denotam coisas dentro de parênteses, coisas dentro de aspas, etc. Pode ser útil para manipular texto delimitado.

supertab.vim

Esse script traz a funcionalidade sofisticada de conclusão de guias para o vim. O material de preenchimento automático já está presente no núcleo do vim, mas isso o leva a uma guia rápida, em vez de vários atalhos de várias marcas diferentes. Muito útil e incrivelmente divertido de usar. Embora não seja o intellisense do VS, é um grande passo e traz uma grande parte da funcionalidade que você gostaria de esperar de uma ferramenta de conclusão de guias.

syntastic.vim

Essa ferramenta traz comandos de verificação de sintaxe externa para o vim. Eu não o usei pessoalmente, mas ouvi grandes coisas a respeito e é difícil vencer o conceito. Verificar a sintaxe sem ter que fazê-lo manualmente economiza muito tempo e pode ajudar a detectar erros sintáticos quando você os apresenta, e não quando você finalmente pára para testar.

fugitive.vim

Acesso direto ao git de dentro do vim. Novamente, eu não usei este plug-in, mas posso ver o utilitário. Infelizmente estou em uma cultura em que o svn é considerado "novo", então provavelmente não verei o git funcionando por algum tempo.

nerdtree.vim

Um navegador de árvore para vim. Comecei a usar isso recentemente, e é realmente útil. Permite colocar uma exibição em árvore em uma divisão vertical e abrir arquivos facilmente. Isso é ótimo para um projeto com muitos arquivos de origem entre os quais você costuma pular.

FuzzyFinderTextmate.vim

Este é um plugin não mantido, mas ainda incrivelmente útil. Ele fornece a capacidade de abrir arquivos usando uma sintaxe descritiva "difusa". Isso significa que, em uma árvore esparsa de arquivos, você precisa digitar apenas caracteres suficientes para desambiguar os arquivos nos quais você está interessado do resto da sujeira.

Conclusão

Existem muitas ferramentas incríveis disponíveis para o vim. Tenho certeza de que apenas arranhei a superfície aqui e vale a pena procurar ferramentas aplicáveis ​​ao seu domínio. A combinação do poderoso conjunto de ferramentas tradicionais do vi, aprimoramentos do vim e plugins que estendem o vim ainda mais, é uma das maneiras mais poderosas de editar texto já concebido. O Vim é facilmente tão poderoso quanto emacs, eclipse, visual studio e textmate.

obrigado

Agradeço a duwanis por suas configurações do vim, das quais aprendi muito e peguei emprestada a maioria dos plugins listados aqui.

. Repita o último comando de alteração de texto

Economizo muito tempo com este.

O modo visual foi mencionado anteriormente, mas o modo visual do bloco economizou muito tempo ao editar colunas de tamanho fixo no arquivo de texto. (acessado com Ctrl-V).

gi

Ir para a última localização editada (muito útil se você realizou alguma pesquisa e deseja voltar à edição)

^ P e ^ N

Complete o texto anterior (^ P) ou o próximo (^ N).

^ O e ^ I

Vá para o local anterior ( ^O- "O"para antigo) ou para o próximo ( ^I- "I"próximo a "O"). Quando você realiza pesquisas, edita arquivos, etc., pode navegar por esses "saltos" para frente e para trás.

Eu descobri recentemente este site: http://vimcasts.org/

É muito novo e realmente muito bom. O cara que está executando o site mudou de textmate para vim e hospeda muito bom e concisa transmissões em tópicos específicos do vim. Confira!

CTRL+A incrementa o número em que você está.

Tudo no modo Normal:

f <char> para ir para a próxima instância de um caractere específico na linha atual e ; repetir.

F <char> para mover para a instância anterior de um caractere específico na linha atual e ; repetir.

Se usado de maneira inteligente, os dois acima podem fazer você se mover rapidamente em uma linha.

* em uma palavra para procurar a próxima instância.

# em uma palavra para procurar a instância anterior.

Sessão

uma. salvar sessão

: MKS sessionname

b. força a sessão de salvamento

: mks! nome da sessão

c. carregar sessão

gvim ou vim -S sessionname

Adicionando e subtraindo

uma. Adicionando e subtraindo

CTRL-A; Adicione [contagem] ao número ou caractere alfabético no ou após o cursor. {não no Vi

CTRL-X; Subtrai [contagem] do número ou caractere alfabético no ou após o cursor. {não no Vi}

b. Desmapeamento de teclas da janela

Na janela, Ctrl-A já está mapeado para a seleção completa de arquivos que você precisa remover o mapeamento no arquivo rc. marque mswin.vim como parte do mapeamento CTRL-A como comentário ou adicione seu arquivo rc com unmap

c. Com macro

O comando CTRL-A é muito útil em uma macro. Exemplo: Siga as etapas a seguir para fazer uma lista numerada.

1. Crie a primeira entrada da lista, verifique se ela começa com um número.
2. qa - inicia a gravação no buffer 'a'
3. Y - arranque a entrada
4. p - coloque uma cópia da entrada abaixo da primeira
5. CTRL-A - incrementa o número
6. q - parar a gravação
7. @a - repita os tempos de arranque, colocação e incremento

Na semana passada, no trabalho, nosso projeto herdou muito código Python de outro projeto. Infelizmente, o código não se encaixou em nossa arquitetura existente - tudo foi feito com variáveis ​​e funções globais, que não funcionariam em um ambiente multithread.

Tínhamos ~ 80 arquivos que precisavam ser reformulados para serem orientados a objetos - todas as funções foram movidas para classes, parâmetros alterados, instruções de importação adicionadas etc. Temos uma lista de cerca de 20 tipos de correções que precisavam ser feitas em cada arquivo. Eu estimaria que fazê-lo manualmente, uma pessoa poderia fazer talvez 2 a 4 por dia.

Então eu fiz o primeiro manualmente e depois escrevi um script vim para automatizar as alterações. A maioria era uma lista de comandos do vim, por exemplo

" delete an un-needed function "
g/someFunction(/ d

" add wibble parameter to function foo "
%s/foo(/foo( wibble,/

" convert all function calls bar(thing) into method calls thing.bar() "
g/bar(/ normal nmaf(ldi(`aPa.

O último merece um pouco de explicação:

g/bar(/  executes the following command on every line that contains "bar("
normal   execute the following text as if it was typed in in normal mode
n        goes to the next match of "bar(" (since the :g command leaves the cursor position at the start of the line)
ma       saves the cursor position in mark a
f(       moves forward to the next opening bracket
l        moves right one character, so the cursor is now inside the brackets
di(      delete all the text inside the brackets
`a       go back to the position saved as mark a (i.e. the first character of "bar")
P        paste the deleted text before the current cursor position
a.       go into insert mode and add a "." 

Para algumas transformações mais complexas, como a geração de todas as instruções de importação, incorporei algum python no script vim.

Depois de algumas horas de trabalho, tive um script que fará pelo menos 95% da conversão. Acabei de abrir um arquivo no vim, em seguida, corro :source fixit.vime o arquivo é transformado em um piscar de olhos.

Ainda temos o trabalho de alterar os 5% restantes que não valiam a pena automatizar e de testar os resultados, mas, ao passar um dia escrevendo esse script, estimo que economizamos semanas de trabalho.

É claro que seria possível automatizar isso com uma linguagem de script como Python ou Ruby, mas levaria muito mais tempo para escrever e seria menos flexível - o último exemplo teria sido difícil, já que apenas a regex não seria capaz de lidar com isso. colchetes aninhados, por exemplo, para converter bar(foo(xxx))em foo(xxx).bar(). Vim foi perfeito para a tarefa.

Use o gerenciador de arquivos embutido! O comando é :Exploree permite que você navegue pelo seu código-fonte muito, muito rápido. Eu tenho esses mapeamentos no meu .vimrc:

map <silent> <F8>   :Explore<CR>
map <silent> <S-F8> :sp +Explore<CR>

O explorer também permite que você faça modificações no arquivo. Vou postar algumas das minhas teclas favoritas. Pressionar <F1>exibirá a lista completa:

• - : O mais útil: Altere para o diretório superior ( cd ..)
• mf : marcar um arquivo
• D : Exclua os arquivos marcados ou o arquivo em que o cursor está, se nada estiver marcado.
• R : renomeie o arquivo no qual o cursor está.
• d : Crie um novo diretório no diretório atual
• % : Crie um novo arquivo no diretório atual

Eu sou um membro da American Cryptogram Association. A revista bimestral inclui mais de 100 criptogramas de vários tipos. Aproximadamente 15 deles são "criptoaritmos" - vários tipos de problemas aritméticos com letras substituídas pelos dígitos. Dois ou três deles são sudokus, exceto com letras em vez de números. Quando a grade estiver concluída, as nove letras distintas soletrarão uma palavra ou palavras, em alguma linha, diagonal, espiral etc., em algum lugar da grade.

Em vez de trabalhar com lápis ou digitar os problemas manualmente, faço o download dos problemas na área de membros do site deles.

Ao trabalhar com esses sudokus, uso o vi, simplesmente porque estou usando recursos que o vi possui e que poucos outros editores possuem. Principalmente na conversão da grade com letras em uma grade numerada, porque acho mais fácil resolver e, em seguida, a grade numerada concluída de volta na grade com letras para encontrar a (s) palavra (s) da solução.

O problema é formatado como nove grupos de nove letras, com -s representando os espaços em branco, escritos em duas linhas. O primeiro passo é formatá-los em nove linhas de nove caracteres cada. Não há nada de especial nisso, basta inserir oito quebras de linha nos locais apropriados.

O resultado será semelhante a este:

T-O-----C
-E-----S-
--AT--N-L
---NASO--
---E-T---
--SPCL---
E-T--OS--
-A-----P-
S-----C-T

Portanto, o primeiro passo para converter isso em números é fazer uma lista das letras distintas. Primeiro, faço uma cópia do bloco. Posiciono o cursor na parte superior do bloco e digito :y}}p. :me coloca no modo de comando, ypuxa o próximo comando de movimento. Como }é uma mudança para o final do próximo parágrafo, y}puxa o parágrafo. }depois move o cursor para o final do parágrafo e pcola o que havíamos puxado logo após o cursor. Então y}}pcria uma cópia do próximo parágrafo e termina com o cursor entre as duas cópias.

Em seguida, devo transformar uma dessas cópias em uma lista de letras distintas. Esse comando é um pouco mais complexo:

:!}tr -cd A-Z | sed 's/\(.\)/\1\n/g' | sort -u | tr -d '\n'

:novamente me coloca no modo de comando. !indica que o conteúdo do próximo puxão deve ser canalizado através de uma linha de comando. }puxa o próximo parágrafo, e a linha de comando usa o trcomando para remover tudo, exceto letras maiúsculas, o sedcomando para imprimir cada letra em uma única linha e o sortcomando para classificar essas linhas, remover duplicatas e remover tra linha as novas linhas, deixando as nove letras distintas em uma única linha, substituindo as nove linhas que compunham o parágrafo originalmente. Neste caso, as letras são: ACELNOPST.

O próximo passo é fazer outra cópia da grade. E, em seguida, usar as letras Acabei identificados para substituir cada uma dessas cartas com um dígito de 1 a 9. Isso é simples: :!}tr ACELNOPST 0-9. O resultado é:

8-5-----1
-2-----7-
--08--4-3
---4075--
---2-8---
--7613---
2-8--57--
-0-----6-
7-----1-8

Isso pode ser resolvido da maneira usual ou inserido em qualquer solucionador de sudoku que você preferir. A solução concluída pode ser convertida novamente em letras com :!}tr 1-9 ACELNOPST.

Existe um poder no vi que é correspondido por muito poucos outros. O maior problema é que apenas alguns dos livros, tutoriais, sites, arquivos de ajuda, etc. do vi não tocam a superfície do que é possível.

Manipulações de texto em massa!

Através de macros:

• Comece com a gravação: qq
• Fazer coisas
• Pare de gravar: q
• Repita: @q(a primeira vez), @@depois disso.
• Repita 20 vezes: 20@@

Ou através de expressões regulares:

• Substitua as coisas: :%s/[fo]+/bar/g

(Mas esteja avisado: se você fizer o último, terá 2 problemas :).)

Eu descobri recentemente q:. Ele abre a "janela de comando" e mostra os comandos mais recentes do modo ex (modo de comando). Você pode mover-se normalmente na janela e pressionar <CR>executa o comando. Você pode editar, etc. também. Inestimável quando você está mexendo com algum comando ou regex complexo e não deseja redigitar a coisa toda, ou se a coisa complexa que você quer fazer é 3 comandos de volta. É quase como o bash set -o vi, mas para o próprio vim (heh!).

Veja os :help q:bits mais interessantes para ir e voltar.

Acabei de descobrir a omnicompleção do Vim outro dia e, embora admita que estou um pouco confuso com o que faz, tive resultados surpreendentemente bons apenas pressionando Ctrl+ x Ctrl+ uou Ctrl+ n/ Ctrl+ pno modo de inserção. Não é bem o IntelliSense , mas ainda estou aprendendo.

Experimente! :help ins-completion

Estes não são atalhos, mas estão relacionados:

1. Tornar capslock um ESC adicional (ou Ctrl)
2. mapeie o líder para "," (vírgula), com este comando: deixe mapleader = ","

Eles aumentam minha produtividade.

Outro vi "atalho" útil que costumo usar é 'xp'. Isso irá trocar o caractere sob o cursor pelo próximo caractere.

<Ctrl> + W, V para dividir a tela verticalmente
<Ctrl> + W, W para alternar entre as janelas

! python% [args] para executar o script que estou editando nesta janela

ZF no modo visual para dobrar linhas arbitrárias

Modo Visual

Como várias outras pessoas disseram, o modo visual é a resposta para o seu problema de copiar / recortar e colar. O Vim fornece 'v', 'V' e Cv. As letras minúsculas 'v' no vim são essencialmente iguais às teclas Shift do bloco de notas. O bom é que você não precisa pressioná-lo. Você pode usar qualquer técnica de movimento para navegar eficientemente até o ponto inicial (ou final) da sua seleção. Em seguida, pressione 'v' e use técnicas de movimento eficientes novamente para navegar até o outro extremo da sua seleção. Então 'd' ou 'y' permite cortar ou copiar essa seleção.

A vantagem do modo visual do vim sobre a descrição de Jim Dennis de cortar / copiar / colar no vi é que você não precisa obter o local exatamente correto. Às vezes, é mais eficiente usar um movimento rápido para chegar à vizinhança geral de onde você deseja ir e refinar isso com outros movimentos do que pensar em um comando de movimento único mais complexo que o leva exatamente aonde você quer ir.

A desvantagem de usar o modo visual extensivamente dessa maneira é que ele pode se tornar uma muleta que você usa o tempo todo, o que impede você de aprender novos comandos vi (m) que podem permitir que você faça as coisas com mais eficiência. No entanto, se você é muito proativo em aprender novos aspectos do vi (m), isso provavelmente não afetará muito.

Também enfatizarei que os modos de linha visual e de bloco visual oferecem variações sobre o mesmo tema que pode ser muito poderoso ... especialmente o modo de bloco visual.

Sobre o uso eficiente do teclado

Também discordo de sua afirmação de que alternar mãos é a maneira mais rápida de usar o teclado. Tem um elemento de verdade nele. Falando de maneira geral, o uso repetido da mesma coisa é lento. O exemplo mais significativo desse princípio é que as teclas consecutivas digitadas com o mesmo dedo são muito lentas. Sua afirmação provavelmente decorre da tendência natural de usar o s / dedo / mão / transformação nesse padrão. Até certo ponto, está correto, mas no extremo extremamente alto do espectro de eficiência está incorreto.

Basta perguntar a qualquer pianista. Pergunte-lhes se é mais rápido tocar uma sucessão de algumas notas alternando entre mãos ou usando dedos consecutivos de uma única mão em sequência. A maneira mais rápida de digitar 4 teclas não é alternar as mãos, mas digitá-las com 4 dedos da mesma mão em ordem crescente ou decrescente (chame isso de "corrida"). Isso deve ser evidente depois de considerar essa possibilidade.

O problema mais difícil é otimizar para isso. É muito fácil otimizar a distância absoluta no teclado. Vim faz isso. É muito mais difícil otimizar no nível "executar", mas o vi (m) com a edição modal oferece uma chance melhor de você fazer isso do que qualquer abordagem não modal (ahem, emacs) jamais poderia.

No Emacs

Para que os fanáticos do emacs desconsiderem completamente todo o meu post por causa desse último comentário entre parênteses, sinto que devo descrever a raiz da diferença entre as religiões emacs e vim. Nunca falei nas guerras dos editores e provavelmente não farei isso de novo, mas nunca ouvi ninguém descrever as diferenças dessa maneira, então aqui vai. A diferença é a seguinte compensação:

O Vim oferece eficiência incomparável de edição de texto bruto O Emacs oferece capacidade incomparável de personalizar e programar o editor

Os fanáticos cegos do vim alegam que o vim tem uma linguagem de script. Mas é uma linguagem obscura e ad-hoc que foi projetada para servir o editor. O Emacs tem Lisp! Disse o suficiente. Se você não aprecia o significado dessas duas últimas frases ou deseja aprender o suficiente sobre programação funcional e Lisp para desenvolver essa apreciação, use o vim.

Os fanáticos do emacs alegam que o emacs tem o modo viper e, portanto, é um superconjunto do vim. Mas o modo viper não é padrão. Meu entendimento é que o modo viper não é usado pela maioria dos usuários do emacs. Como não é o padrão, a maioria dos usuários do emacs provavelmente não desenvolve uma verdadeira apreciação pelos benefícios do paradigma modal.

Na minha opinião, essas diferenças são ortogonais. Acredito que os benefícios do vim e do emacs, como afirmei, são válidos. Isso significa que o editor final ainda não existe. Provavelmente é verdade que o emacs seria a plataforma mais fácil para basear o editor definitivo. Mas a edição modal não está enraizada na mentalidade do emacs. A comunidade emacs pode se mover dessa maneira no futuro, mas isso não parece muito provável.

Portanto, se você quiser eficiência de edição bruta, use o vim. Se você deseja o melhor ambiente para scripts e programação, o seu editor usa o emacs. Se você quiser alguns dos dois com ênfase na capacidade de programação, use o emacs com o modo viper (ou programe seu próprio modo). Se você quer o melhor dos dois mundos, está sem sorte por enquanto.

Passe 30 minutos fazendo o tutorial do vim (execute o vimtutor em vez do vim no terminal). Você aprenderá os movimentos básicos e algumas teclas, isso o tornará pelo menos tão produtivo com o vim quanto com o editor de texto usado anteriormente. Depois disso, leia a resposta de Jim Dennis novamente :)

Qual é a maneira como você usa o Vim que o torna mais produtivo do que com um editor contemporâneo?

Ser capaz de executar edições complexas e repetitivas com muito poucas teclas (geralmente usando macros ). Dê uma olhada no VimGolf para testemunhar o poder do Vim!

Após mais de dez anos de uso quase diário, é difícil imaginar o uso de qualquer outro editor.

Use \cem qualquer lugar da pesquisa para ignorar maiúsculas e minúsculas (substituindo as configurações de caixa de ignorância ou caixa inteligente). Por exemplo, /\cfooou /foo\cirá corresponder foo, Foo, fOO, FOO, etc.

Use \Cem qualquer lugar da pesquisa para forçar a correspondência entre maiúsculas e minúsculas. Por exemplo, /\Cfooou /foo\Ccorresponderá apenas a foo.

Fiquei surpreso ao encontrar ninguém mencionar o tmovimento. Eu freqüentemente o uso com listas de parâmetros na forma de dt,ouyt,

Estranho, ninguém mencionou ctags. Faça o download de "ctags exuberantes" e coloque-o à frente da versão pré-instalada de baixa qualidade que você já possui em seu caminho de pesquisa. Cd na raiz do que você está trabalhando; por exemplo, a distribuição do kernel do Android. Digite "ctags -R". para criar um índice de arquivos de origem em qualquer lugar abaixo desse diretório em um arquivo chamado "tags". Ele contém todas as tags, não importa o idioma nem o local do diretório, em um arquivo, portanto, o trabalho entre idiomas é fácil.

Em seguida, abra o vim nessa pasta e leia: help ctags para alguns comandos. Alguns eu uso com frequência:

• Coloque o cursor em uma chamada de método e digite CTRL-] para ir para a definição do método.

• Digite: ta name para ir para a definição de name.

Recuo automático:

gg(vá para o início do documento)
=(recuo na hora!)
shift-g(vá para o final do documento)

Você precisará do 'recuo do plug-in de tipo de arquivo' no seu .vimrcarquivo e provavelmente das configurações apropriadas de 'shiftwidth' e 'expandtab'.

Você perguntou sobre atalhos produtivos, mas acho que sua verdadeira pergunta é: vim vale a pena? A resposta para esta pergunta do stackoverflow é -> "Sim"

Você deve ter notado duas coisas. O Vim é poderoso e é difícil de aprender. Muito do seu poder está na capacidade de expansão e na combinação infinita de comandos. Não se sinta sobrecarregado. Vai devagar. Um comando, um plug-in de cada vez. Não exagere.

Todo esse investimento que você coloca no vim pagará mil vezes. Você ficará dentro de um editor de texto por muitas e muitas horas antes de morrer. Vim será seu companheiro.

Vários buffers e, em particular, um salto rápido entre eles para comparar dois arquivos com :bpe :bn(corretamente remapeados para um único Shift+ pou Shift+ n)

vimdiff mode (divide em dois buffers verticais, com cores para mostrar as diferenças)

Cópia de área com Ctrl+v

E, finalmente, a conclusão da guia dos identificadores (procure por "mosh_tab_or_complete"). Isso é uma mudança de vida.

Concordo com o pôster principal - the : r! comando é muito útil.

Na maioria das vezes eu o uso para "colar" coisas:

:r!cat
**Ctrl-V to paste from the OS clipboard**
^D

Dessa forma, eu não tenho que mexer :set paste.