¿Puedo ver los cambios antes de guardar mi archivo en Vim?

Yo uso Vim Abro un archivo. Lo edito y quiero ver lo que he editado antes de guardarlo.

¿Cómo puedo hacer esto en Vim?

http://vim.wikia.com/wiki/Diff_current_buffer_and_the_original_file

Aquí hay una función y un comando para ver una diferencia entre el archivo editado actualmente y su versión no modificada en el sistema de archivos. Simplemente colóquelo en su vimrc o en el directorio de complementos, abra un archivo, realice algunas modificaciones sin guardarlas y hágalo :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 salir de la vista de diferencias, puede usar el :diffoffcomando.

A continuación se muestra una función similar, adaptada para imitar el 'cvs diff'comando ...

:w !diff % -

Porque algunas personas preguntaron acerca de una explicación para el comando

:w !diff % -

Aquí está mi intento de escribir una respuesta más detallada:

Supongo que está trabajando en un sistema cate echoinstalado (por ejemplo, casi cualquier GNU / Linux, Mac OS, BSD y otros sistemas similares a UNIX).

El comando anterior funciona de la siguiente manera:

1. La sintaxis para guardar un archivo en vim es:

   :w <filename>
   

2. La sintaxis para ejecutar un comando de shell en vim es:

   :!<command>
   

3. Dentro del entorno de shell emitido por vim %sucede que apunta al nombre de archivo actual. Puede verificar esto ejecutando lo siguiente:

   :!echo %
   

   Esto debería generar el nombre de archivo (o un error, si vim se ejecutó sin un nombre de archivo).

   Usando cat también podemos generar el contenido del archivo:

   :!cat %
   

   Esto debería devolver el contenido de los archivos en su último estado guardado o un error si nunca se ha guardado.

4. El programa diff puede leer desde la entrada estándar (stdin). Su página de manual dice lo siguiente:

   [...] Si un ARCHIVO es '-', lea la entrada estándar. [...]

5. La ejecución del comando guardar sin un nombre de archivo, sino más bien un comando de shell detrás de él, hace que vim escriba el contenido de los archivos en stdin del shell en lugar de guardarlo en un archivo físico. Puede verificar esto ejecutando

   :w !cat
   

   Esto siempre debe imprimir el contenido actual de los archivos (que en su lugar se habría escrito en un archivo).

Poniéndolo junto (o tl; dr): el archivo se "guarda" en stdin, diff se ejecuta con el nombre de archivo y stdin como entrada.

Saber esto también podría comparar archivos con vimdiff haciendo algo como esto: esta es solo una idea que no desea hacer esto:

:w !cat > /tmp/tempFile && vimdiff /tmp/tempFile % && rm /tmp/tempFile

(Luego abra readonly y cierre vimdiff usando :qall)

Siempre me han gustado los cambios : agradable, simple, funciona.

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

Obtenga lo siguiente y 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()

No es exactamente lo que estás buscando, pero SCMDiff.vim es realmente genial. Una pulsación de tecla, y resalta su archivo actual con la revisión de la cabeza en un repositorio de control de fuente. Está destinado a funcionar con muchos SCMS. Lo uso con fuerza.

Hay un complemento, basado en diferentes respuestas aquí: https://github.com/gangleri/vim-diffsaved

Proporciona el :w !diff % -método y el más complicado diffthis.

Aparte de eso, unotree permite esto también, pero también mucho más (difiere entre diferentes puntos de control de deshacer). Similar a Gundo .

Puedo recomendar el complemento histwin .

Si bien no difiere de la versión guardada actual del archivo (como las otras respuestas), puede modificar los cambios desde que comenzó a editar e incluso reproducir los cambios en orden. La diferencia se muestra si ahorra de forma intermedia.

Además, muestra una lista de todas las ramas del historial de deshacer y le permite cambiar o diferenciar entre ellas.

PD: Si bien el complemento no rastrea automáticamente los momentos en el historial de edición desde cada cambio de archivo, puede "etiquetar" explícitamente el momento en que guarda el archivo para que luego pueda verlo, si así lo desea. Tal vez esto podría ser automatizado?

Si desea usar vim para comparar, como en vimdiff, puede hacer algo como esto:

Edite su .vimrc y agregue:

nmap <F8> :w !vim -M -R - -c ":vnew % \| windo diffthis"<CR><CR>

A partir de ahí, verá sus cambios y puede salir de la vista de diferencias usando qallcomo en vimdiff presionando F8 en modo comando. Reemplace F8 con cualquier tecla que desee.

Editar: Se agregó -M para no permitir ninguna modificación, ya que no se guarda.

git admite el siguiente comando

:w !git diff --no-index -- % -

asignarlo a un comando agregando lo siguiente a su ~ / .vimrc

command GitDiff execute "w !git diff --no-index -- % -"

Ahora ejecutar se :GitDiffconvierte en un pequeño comando útil para mostrar rápidamente la diferencia antes de cada guardado.

Puede hacer que vim cree una última copia de seguridad y una copia de seguridad original con:

:set backup
:set patchmode=.orig 

A partir de entonces, puede abrirlos en una división:

:vsp %:p~ or :vsp %:.orig

Y a partir de ahí hacer:

:vimdiff in each buffer

Si no tiene restos, pero quiere vimdiff, también puede hacer lo siguiente:

ggVGy    # copy the whole buffer
:vnew    # open a split
CTRL-W w # switch to it
shift-P  # paste at start

y luego hacer: diffthis en cada división

Los cambios que acaba de editar [ tampón ], es decir, aquellos que difieren de la última versión guardada (en el trabajo dir ectory), éstos pueden diferir con la última versión de índice ( Git ). Mapeé ambos:

" 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()

Ejemplo de vimdiff vs Gdiff.

• vimdiff:
• Gdiff: al confirmar los cambios, solo ve Gdiff, lo que podría o podría tener los mismos cambios que vimdiff:

Además, para facilitar el vimdiffarchivo de homónimo en otra ruta:

    " 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

Siga lo anterior sugiere que uso git diff que me gusta mucho:

:w !git diff  % -