Git diff contra un alijo

¿Cómo puedo ver los cambios que hará la ocultación en el árbol de trabajo actual? ¡Me gustaría saber qué cambios se harán antes de aplicarlos!

Ver el alijo más reciente:

git stash show -p

Ver un alijo arbitrario:

git stash show -p stash@{1}

De las git stashpáginas del manual:

Por defecto, el comando muestra el diffstat, pero aceptará cualquier formato conocido por git diff (por ejemplo, git stash show -p stash @ {1} para ver el segundo escondite más reciente en forma de parche).

Para ver el alijo más reciente:

git stash show -p

Para ver un alijo arbitrario:

git stash show -p stash@{1}

Además, uso git diff para comparar el alijo con cualquier rama.

Puedes usar:

git diff stash@{0} master

Para ver todos los cambios en comparación con el maestro de sucursal.


O puedes usar:

git diff --name-only stash@{0} master

Para encontrar fácilmente solo los nombres de archivos modificados.

Si la rama en la que se basan sus cambios escondidos ha cambiado mientras tanto, este comando puede ser útil:

git diff stash@{0}^!

Esto compara el alijo contra el compromiso en el que se basa.

Si su árbol de trabajo está sucio , puede compararlo con un alijo al confirmar primero el árbol de trabajo sucio y luego compararlo con el alijo. Después, puede deshacer la confirmación con el árbol de trabajo sucio (ya que es posible que no desee tener esa confirmación sucia en su registro de confirmación).

También puede usar el siguiente enfoque para comparar dos escondites entre sí (en cuyo caso, solo debe abrir uno de los escondites al principio).

• Comete tu árbol de trabajo sucio:

  git add .
  git commit -m "Dirty commit"
  

• Difunde el alijo con ese commit:

  git diff HEAD stash@{0}
  

• Luego, luego, puede revertir la confirmación y volver a colocarla en el directorio de trabajo:

  git reset --soft HEAD~1
  git reset .
  

Ahora ha diferenciado el árbol de trabajo sucio con su alijo y ha vuelto a donde estaba inicialmente.

La respuesta de @ Magne es la única hasta la fecha (muy tardía) que responde a la interpretación más flexible / útil de la pregunta, pero es bastante más complicada de lo necesario. En lugar de comprometerse y restablecer, solo guarde su copia de trabajo, compare y luego descanse.

git stash save "temp"
git diff stash@{0} stash@{1}
git stash pop

Eso le muestra las diferencias entre la parte superior de la pila de alijo y su carpeta de trabajo al hacer que los cambios de la carpeta de trabajo se conviertan temporalmente en la parte superior de la pila de alijo (alijo @ {0}), moviendo la tapa original hacia abajo (alijo @ {1} ) y luego compara el uso de la parte superior original en la posición 'nuevo conjunto' para que veas los cambios que resultarían de aplicarlo sobre tu trabajo actual.

"¿Pero qué pasa si no tengo ningún trabajo actual?" Entonces estás en el caso aburrido normal. Solo usa la respuesta de @ Amber

git stash show

o la respuesta de @ czerasz

git diff stash@{0}

o admitir que guardar y deshacer es rápido y fácil de todos modos, solo tiene que guardar los cambios e inspeccionarlos. Si no los quiere en este momento, deséchelos (el índice actual / la carpeta de trabajo cambia). En su totalidad eso es

git stash apply
git diff
git reset
git checkout

Esto funciona para mí en git versión 1.8.5.2:

git diff stash HEAD

Por si acaso, para comparar un archivo en el árbol de trabajo y en el escondite, use el siguiente comando

git diff stash@{0} -- fileName (with path)

Si tiene herramientas para diff (como más allá de comparar)

git difftool stash HEAD

Una forma de hacer esto sin mover nada es aprovechar el hecho de que patchpuede leer los git diff (básicamente diferenciados unificados)

git stash show -p | patch -p1 --verbose --dry-run

Esto le mostrará una vista previa paso a paso de lo que normalmente haría el parche. El beneficio adicional de esto es que el parche tampoco evitará que lo escriba en el árbol de trabajo, si por alguna razón realmente necesita que git se calle sobre comprometerse antes de modificar, continúe y elimine --dry- corre y sigue las instrucciones detalladas.

Combinando lo que aprendí en este hilo y en este , cuando quiero ver "qué hay dentro del alijo", primero ejecuto:

git stash show stash@{0}

Eso mostrará qué archivos fueron modificados. Luego, para obtener un buen visual diff en una herramienta de herramientas, hago:

git difftool --dir-diff stash@{0} stash@{0}^

Esto mostrará todas las diferencias a la vez del alijo dado contra su padre.

Puede configurar la herramienta diff en ~/.gitconfig, por ejemplo, con Meld :

...
[diff]
    tool = meld

FWIW Esto puede ser un poco redundante para todas las otras respuestas y es muy similar a la respuesta aceptada que es acertada; pero tal vez ayude a alguien.

git stash show --helpte dará todo lo que necesitas; incluyendo información del show de alijo.

mostrar [<stash>]

Muestra los cambios registrados en el alijo como una diferencia entre el estado escondido y su padre original. Cuando no se da, muestra el último. Por defecto, el comando muestra el diffstat, pero aceptará cualquier formato conocido por git diff (por ejemplo, git stash show -p stash @ {1} para ver el segundo escondite más reciente en forma de parche). Puede usar las variables de configuración stash.showStat y / o stash.showPatch para cambiar el comportamiento predeterminado.

Ella la lista de alijo

git stash list 
stash@{0}: WIP on feature/blabla: 830335224fa Name Commit
stash@{1}: WIP on feature/blabla2: 830335224fa Name Commit 2

Entonces obtenga el número de alijo y haga:

Tu puedes hacer:

 git stash show -p stash@{1}

Pero si desea un diff (esto es diferente para mostrar el alijo, es por eso que escribo esta respuesta. DiffConsidere el código actual en su rama y showsolo muestre lo que aplicará )

Puedes usar:

git diff stash@{0}

o

git diff stash@{0} <branch name>

Otra cosa interesante que hacer es:

git stash apply
git stash apply stash@{10}

Esto aplica el alijo sin eliminarlo de la lista, puede git checkout .eliminar esos cambios o si está contento git stash drop stash@{10}de eliminar un alijo de la lista.

Desde aquí, nunca recomiendo usar git stash popy usar una combinación de git stash applyy git stash dropsi aplica un alijo en la rama incorrecta ... bueno, a veces es difícil recuperar su código.

Dependiendo de con qué desee comparar el alijo (árbol de trabajo local / confirmación principal / confirmación principal), en realidad hay varios comandos disponibles, entre los que se encuentran los más antiguos git diffy los más específicos git stash show:

╔══════════════════════╦═══════════════════════════════╦═══════════════════╗
║ Compare stash with ↓ ║ git diff                      ║ git stash show    ║
╠══════════════════════╬═══════════════════════════════╬═══════════════════╣
║ Local working tree   ║ git diff stash@{0}            ║ git stash show -l ║
║----------------------║-------------------------------║-------------------║
║ Parent commit        ║ git diff stash@{0}^ stash@{0} ║ git stash show -p ║
║----------------------║-------------------------------║-------------------║
║ HEAD commit          ║ git diff stash@{0} HEAD       ║   /               ║
╚══════════════════════╩═══════════════════════════════╩═══════════════════╝

Si bien git stash showparece más fácil de usar a primera vista, en git diffrealidad es más poderoso ya que permite especificar nombres de archivo para una diferencia más enfocada. Personalmente configuré alias para todos estos comandos en mi complemento zsh git .