Git diff contra un alijo

Respuestas:

1873

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

Ámbar
fuente
72
stash@{0}es el predeterminado; solo necesita un argumento si desea ver las reservas anteriores.
Cascabel
52
Derecha. Simplemente lo suministré para que quedara claro cómo mirar otros escondites además {0}.
Ámbar
74
Esto no mostrará la diferencia entre el alijo y el directorio de trabajo actual, sino entre el alijo y su padre original. ¿Derecha? Desde la página de manual: "Muestra los cambios registrados en el alijo como una diferencia entre el estado escondido y su padre original".
Magne
14
@Amber: es cierto, aunque si su árbol de trabajo actual está sucio, es importante y lo hace un poco más complicado. Llegué a ese punto desde ese ángulo, y encontré un procedimiento que compartí en mi respuesta a continuación.
Magne
66
¿Qué significa el -psoporte?
Gerald
308

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.

czerasz
fuente
10
Esto no responde a la pregunta específica. Si creó el alijo desde el maestro (para guardar el trabajo para más adelante), realice algunas confirmaciones para otro trabajo en el maestro, luego haga git diff stash@{0} master, obtendrá una diferencia de su alijo contra el maestro actual (que incluye el trabajo realizado en el maestro después del alijo fue hecho), no los archivos / líneas que cambiaría el alijo, de eso se trata la pregunta.
Tom De Leu
52
Me alegra que hayas respondido la pregunta incluso si no fue una respuesta a la pregunta exacta. Dio más información, y creo que es genial saber cómo obtener una diferencia entre una rama y cualquier otra rama con la que quieras compararla. También me gustó aprender la bandera de solo nombre :)
Rebekah Waterbury
66
Esto también permite observar las diferencias utilizando un visor de diferencias personalizado, por ejemplogit difftool --tool=... stash@{0} HEAD
Andre Holzner
99
@TomDeLeu Buena observación y un punto importante. Para comparar un artículo oculto con su padre, esto parece funcionar:git diff stash@{0}^ stash@{0}
erikprice
1
Además, puede agregar el nombre git diff stash@{0} master -- filenamede archivo para obtener los cambios en un archivo específico.
David
104

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.

t.heintz
fuente
tan bueno que agregué un alias a ~/.gitconfig:laststash = diff stash@{0}^!
sbeam
55
Par perfecto: git difftool stash^!para la diferencia del último alijo contra la confirmación en la que se basó, git difftool stash HEADpara la diferencia del último alijo contra la confirmación actual (alijo @ {n} para las
reservas
17
¡Para aquellos que fueron como yo y nunca han visto el ^! antes: commit ^! es un especificador de rango que significa: este commit, pero ninguno de sus padres.
Jonathan Gawrych
"git diff stash @ {0} ^!" se reduce a "git diff stash @ {0} ^ stash @ {0} ~ 1 ^ stash @ {0} ~ 2 ......." pero como git diff toma solo 2 commits, muestra la diferencia entre stash @ {0} y ^ stash @ {0} ~ 1 y mira el ^ al comienzo de la segunda confirmación no hace ninguna diferencia y git lo ignora.
Naga Kiran
Prefiero esta versión para poder usar mi herramienta diff preferida (¡Más allá de Comparar, por supuesto!). Esto también muestra el cambio en este alijo que creo que es la pregunta original, en oposición a una alternativa mencionada en los comentarios anteriores "git diff stash @ {X} ^ stash @ {X}" que muestra más que solo el diff escondido.
user107172
44

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.

Magne
fuente
¿Hay alguna manera de hacer esto, pero solo para ver una diferencia de los archivos que se cambiarían por lo que hay en el alijo?
lagweezle
En 2020 esto es mucho más simple; mira mi respuesta actualizada .
David Deprost
Interesante, no lo sabía git stash show -l . ¿Difiere el último alijo contra la copia de trabajo (sucia)? ¿Cómo lo usas sin conseguirlo error: switch l requires a value?
Magne
Sí, de hecho, difiere de la copia de trabajo (posiblemente sucia). Lo usas simplemente ingresando git stash show -l. En cuanto a por qué no funciona para ti, ¿solo puedo adivinar que podrías estar en una versión anterior de git? Estoy en git v2.20.1, y funciona perfectamente sin errores.
David Deprost
25

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
SensorSmith
fuente
3
Este enfoque simple (esconder y luego comparar con otro escondite) es seguro y fácil de entender. Para algunos casos de uso, es posible que desee almacenar también archivos sin git stash save -u
seguimiento
19

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

git diff stash HEAD
Rimian
fuente
2
¡Engañoso! La pregunta es: ¿cómo puedo ver los cambios que se realizarán en el árbol de trabajo actual? Esto muestra la diferencia entre el alijo y la CABEZA que puede ser MUY diferente de lo que se aplicará git stash apply.
MikeJansen
Lea la pregunta más "¡Me gustaría saber qué cambios se realizarán antes de aplicarlos!". Estoy proporcionando una respuesta rápida a esto.
yerlilbilgin
También puede ver que todas las otras respuestas son de alguna manera sobre diferenciar la cabeza actual (o conjunto de trabajo) contra el alijo. ¿Por qué solo mi respuesta es engañosa? Eso no es justo.
yerlilbilgin
@yerlilbilgin Vea mi respuesta en su respuesta a continuación.
MikeJansen
Podemos omitir HEAD, es por defecto, ¿no?
Al.G.
10

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)
Pramod BR
fuente
9

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

git difftool stash HEAD
yerlilbilgin
fuente
1
¡Engañoso! La pregunta es: ¿cómo puedo ver los cambios que se realizarán en el árbol de trabajo actual? Esto muestra la diferencia entre el alijo y la CABEZA que puede ser MUY diferente de lo que se aplicará git stash apply.
MikeJansen
1
Si cree que esto es engañoso, verifique todas las demás respuestas. ¡Eso no es justo!
yerlilbilgin
1
Notarás que copié ese mismo comentario a la otra respuesta, que fue igualmente engañoso (más o menos la misma respuesta). Otras respuestas que ya tenían un comentario similar lo dejé solo. Si comprende cómo funciona git stash, se dará cuenta de que diferenciar el alijo contra HEAD no es lo que se aplica (que es lo que pide el OP). El "alijo" real es la diferencia entre el compromiso de alijo y lo que estaba antes. Este parche luego se aplica a la CABEZA. Entonces, si desea saber qué solicitó el OP, debe mostrar la diferencia entre el alijo y el compromiso antes, lo que hacen las respuestas correctas.
MikeJansen
1
Esto responde la pregunta más directamente que cualquiera de las otras respuestas largas (innecesariamente), y hace exactamente lo que el OP pidió, salvo eliminar HEAD. Podría modificar la respuesta de @ yerlilbilgin para eliminar HEAD, pero creo que cualquiera que use git puede entender esa parte y alargar la respuesta la haría menos legible. No hay culpa en @yerlibilgin.
Sridhar Sarnobat
4

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.

xenithorb
fuente
2

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
Ferrard
fuente
1

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.

Rockin4Life33
fuente
1

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.

Raúl Martín
fuente
1

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 .

David Deprost
fuente