Respostas:
http://vim.wikia.com/wiki/Diff_current_buffer_and_the_original_file
Aqui está uma função e um comando para ver uma diferença entre o arquivo atualmente editado e sua versão não modificada no sistema de arquivos. Basta colocar isso no seu vimrc ou no diretório do plugin, abrir um arquivo, fazer algumas modificações sem salvá-las e fazer
:DiffSaved
.function! s:DiffWithSaved() let filetype=&ft diffthis vnew | r # | normal! 1Gdd diffthis exe "setlocal bt=nofile bh=wipe nobl noswf ro ft=" . filetype endfunction com! DiffSaved call s:DiffWithSaved()
Para sair da exibição diff, você pode usar o
:diffoff
comandoAbaixo está uma função semelhante, adaptada para imitar o
'cvs diff'
comando ...
:w !diff % -
diff
. %
refere-se ao caminho do arquivo aberto no momento. Por que tudo isso é um argumento para o :w
comando? Além disso, como é -
atribuído ao conteúdo do buffer de trabalho? Isso é automático no vim, que o conteúdo do buffer (ou talvez um intervalo específico no buffer) seja atribuído ao stdin para comandos do shell?
:w
porque estamos escrevendo o arquivo no comando (on stdin
). No comando, -
diz para ler stdin
.
:w !git diff % -
para uma versão colorida, se você tiver o git instalado!
fatal: bad flag '-' used after filename
quando executo :w !git diff % -
.
Porque algumas pessoas perguntaram sobre uma explicação para o comando
:w !diff % -
Aqui está minha tentativa de escrever uma resposta mais detalhada:
Suponho que você esteja trabalhando em um sistema com cat
e echo
instalado (por exemplo, quase todos os sistemas GNU / Linux, Mac OS, BSD e outros sistemas similares ao UNIX).
O comando acima funciona da seguinte maneira:
A sintaxe para salvar um arquivo no vim é:
:w <filename>
A sintaxe para executar um comando shell no vim é:
:!<command>
O ambiente do shell emitido pelo vim %
aponta para o nome do arquivo atual. Você pode verificar isso executando o seguinte:
:!echo %
Isso deve gerar o nome do arquivo (ou um erro, se o vim foi executado sem um nome de arquivo).
Usando cat, também podemos gerar o conteúdo do arquivo:
:!cat %
Isso deve retornar o conteúdo dos arquivos em seu último estado salvo ou um erro se nunca tiver sido salvo.
O diff do programa pode ler da entrada padrão (stdin). Sua página de manual afirma o seguinte:
[...] Se um ARQUIVO for '-', leia a entrada padrão. [...]
A execução do comando save sem um nome de arquivo, mas um comando shell atrás dele faz com que o vim grave o conteúdo dos arquivos no stdin do shell, em vez de salvá-lo em um arquivo físico. Você pode verificar isso executando
:w !cat
Isso sempre deve imprimir o conteúdo atual dos arquivos (que seria gravado em um arquivo).
Reunindo (ou tl; dr): O arquivo é "salvo" no stdin, o diff é executado com o nome do arquivo e o stdin como entrada.
Saber que este também pode comparar arquivos com o vimdiff, fazendo algo assim - isso é apenas uma ideia de que você não deseja fazer isso:
:w !cat > /tmp/tempFile && vimdiff /tmp/tempFile % && rm /tmp/tempFile
(Em seguida, abra o modo somente leitura e feche o vimdiff usando :qall
)
vim - -c ":vnew $1 |windo diffthis"
, tornando-executável, salvando-o no PATH como, por exemplo, vimdiffWithStdin
e em seguida, comparando com o seguinte comando no vim::w !vimdiffWithStdin %
:w !vimdiff % /dev/stdin
. Não sei se existe um truque semelhante para o Windows.
Eu sempre gostei de mudanças - agradável, simples, funciona.
:DiffChangesDiffToggle
.
de vimrc_example.vim:
" Convenient command to see the difference between the current buffer and the
" file it was loaded from, thus the changes you made.
if !exists(":DiffOrig")
command DiffOrig vert new | set bt=nofile | r # | 0d_ | diffthis
\ | wincmd p | diffthis
endif
w !diff % -
é que ele funciona fontes mais remotas também (por exemplo: vim sftp://example.com/foo.txt
)
Crie o seguinte e use: Comando DIFF
function! s:diff()
let tmpa = tempname()
let tmpb = tempname()
earlier 100h
exec 'w '.tmpa
later 100h
exec 'w '.tmpb
update
exec 'tabnew '.tmpa
diffthis
vert split
exec 'edit '.tmpb
diffthis
endfunction
command! -nargs=0 DIFF call <SID>diff()
Não é exatamente o que você está procurando, mas o SCMDiff.vim é muito legal. Um pressionamento de tecla e destaca o arquivo atual com a revisão principal em um repositório de controle de origem. Ele deve funcionar com muitos SCMS. Eu uso com força.
Existe um plugin com base em respostas diferentes aqui: https://github.com/gangleri/vim-diffsaved
Ele fornece o :w !diff % -
método e o mais envolvido diffthis
.
Além disso, o undotree também permite isso, mas também muito mais (difere entre diferentes pontos de verificação de desfazer). Semelhante ao Gundo .
Eu posso recomendar o plugin histwin .
Embora não seja diferente da versão salva atual do arquivo (como as outras respostas), ela pode vimdiff as alterações desde que você começou a editar e até reproduzir as alterações em ordem. A diferença mostra se você salva intermediários.
Além disso, ele exibe uma lista de todas as ramificações do histórico de desfazer e permite alternar ou diferenciar entre elas.
PS: Embora o plug-in não rastreie automaticamente momentos no histórico de edição, pois todos os arquivos são alterados, você pode "marcar" explicitamente o momento em que salvar o arquivo, para depois poder vimdiff com ele, se desejar. Talvez isso possa ser automatizado?
Se você deseja usar o vim para comparação como no vimdiff, você pode fazer algo assim:
Edite seu arquivo .vimrc e adicione:
nmap <F8> :w !vim -M -R - -c ":vnew % \| windo diffthis"<CR><CR>
A partir daí, você verá suas alterações e poderá sair da visualização diff usando qall
como no vimdiff pressionando F8 no modo de comando. Substitua F8 por qualquer tecla que desejar.
Edit: Adicionado -M para proibir qualquer modificação, porque não é salvo.
Vim: Error reading input, exiting...
Alguma idéia do que está errado aqui?
O git suporta o seguinte comando
:w !git diff --no-index -- % -
mapeie-o para um comando adicionando o seguinte ao seu ~ / .vimrc
command GitDiff execute "w !git diff --no-index -- % -"
Agora, a execução :GitDiff
se torna um pequeno comando útil para mostrar rapidamente o diff antes de cada salvamento.
Você pode fazer com que o vim crie um último backup e backup original com:
:set backup
:set patchmode=.orig
Depois disso, você pode abri-los em uma divisão:
:vsp %:p~ or :vsp %:.orig
E a partir daí faça:
:vimdiff in each buffer
Se você estiver morto, sem sobras, mas quiser o vimdiff, também poderá:
ggVGy # copy the whole buffer
:vnew # open a split
CTRL-W w # switch to it
shift-P # paste at start
e faça: diffthis em cada divisão
Alterações que você acabou de editar [ buffer ], ou seja, aquelas que diferem da última versão salva (no diretório de trabalho ), podem ser diferentes da última versão de índice ( Git ). Mapeei os dois:
" Find diff inbetween currrent buffer and ... A{last index version} vs B{last saved version in working directory}
" - A{last index version}: the file as you last commited it
" git diff to vimdiff against the index version of the file:
nnoremap <leader>gd <Esc>:Gvdiff<CR><Esc>:echo "currentBuffer vs lastIndexVersion (last commited)"<CR>
" - B{last saved version in working directory}: the file you last :w,
" not neccesary commited it (not commited for sure if it is in NO git project)
" https://vim.fandom.com/wiki/Diff_current_buffer_and_the_original_file
nnoremap <leader>gd2 <Esc>:DiffSaved<CR><Esc>:echo "currentBuffer vs lastSaved (not neccesary equal to last commited)"<CR>
function! s:DiffWithSaved()
let filetype=&ft
diffthis
vnew | r # | normal! 1Gdd
diffthis
exe "setlocal bt=nofile bh=wipe nobl noswf ro ft=" . filetype
endfunction
com! DiffSaved call s:DiffWithSaved()
Exemplo de vimdiff vs Gdiff.
Além disso, para facilitar o vimdiff
arquivo homônimo em outro caminho:
" vimdiff homonym file
nnoremap <leader>dh <Esc>:vsplit %:p:h/../__/%:t <bar> :windo diffthis<Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left><Left>
"E.g."$ vim /path01/proj02_pg064/processorder.php
":vsplit %:p:h/../proj01_pg05/%:t | :windo diffthis
Gdiff
se possível e caso contrário (por exemplo, não um projeto Git), então execute a :vimdiff
. Com try-catch-endtry
. Mas dessa maneira, :DiffWithSaved
em um projeto Git, não existe.
:w !diff % -
superior quando você está usando o vim em um grande número de caixas sempre variável e que você não pode alterar facilmente o .vimrc? (Desde que tenham diff instalado.)