Git diff contre une cachette

Comment puis-je voir les modifications que le non-stashing apportera à l'arborescence de travail actuelle? Je voudrais savoir quelles modifications seront apportées avant de les appliquer!

Voir la cachette la plus récente:

git stash show -p

Voir une cachette arbitraire:

git stash show -p stash@{1}

Depuis les git stashpages de manuel:

Par défaut, la commande affiche le diffstat, mais elle accepte tout format connu pour git diff (par exemple, git stash show -p stash @ {1} pour afficher le deuxième stash le plus récent sous forme de patch).

Pour voir la cachette la plus récente:

git stash show -p

Pour voir une cachette arbitraire:

git stash show -p stash@{1}

De plus, j'utilise git diff pour comparer le stash avec n'importe quelle branche.

Vous pouvez utiliser:

git diff stash@{0} master

Pour voir toutes les modifications par rapport au maître de branche.


Ou vous pouvez utiliser:

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

Pour trouver facilement uniquement les noms de fichiers modifiés.

Si la branche sur laquelle vos modifications cachées sont basées a changé entre-temps, cette commande peut être utile:

git diff stash@{0}^!

Cela compare la cachette à la validation sur laquelle elle est basée.

Si votre arbre de travail est sale , vous pouvez le comparer à une stash en validant d'abord l'arbre de travail sale, puis en le comparant à la stash. Ensuite, vous pouvez annuler la validation avec l'arborescence de travail sale (car vous ne voudrez peut-être pas avoir cette validation sale dans votre journal de validation).

Vous pouvez également utiliser l'approche suivante pour comparer deux stashes l'un avec l'autre (dans ce cas, vous venez de sauter l'un des stashes au début).

• Engagez votre arbre de travail sale:

  git add .
  git commit -m "Dirty commit"
  

• Diff la cachette avec ce commit:

  git diff HEAD stash@{0}
  

• Ensuite, après, vous pouvez annuler le commit et le remettre dans le répertoire de travail:

  git reset --soft HEAD~1
  git reset .
  

Maintenant, vous avez différencié l'arbre de travail sale avec votre cachette et vous êtes revenu à l'endroit où vous étiez au départ.

La réponse de @ Magne est la seule à date (très tardive) qui répond à l'interprétation la plus flexible / utile de la question, mais c'est un peu plus compliqué que nécessaire. Plutôt que de valider et de réinitialiser, stockez simplement votre copie de travail, comparez, puis décompressez.

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

Cela vous montre les différences entre le haut de la pile de stash et votre dossier de travail en faisant temporairement les modifications de votre dossier de travail devenir le haut de la pile de stash (stash @ {0}), en déplaçant le haut d'origine vers le bas (stash @ {1} ) puis en comparant en utilisant le haut d'origine dans la position «nouveau jeu» afin de voir les changements qui résulteraient de son application au-dessus de votre travail actuel.

"Mais si je n'ai pas de travail en cours?" Ensuite, vous êtes dans le cas ennuyeux normal. Utilisez simplement la réponse de @ Amber

git stash show

ou la réponse de @ czerasz

git diff stash@{0}

ou admettez que le stockage et le désarchivage sont rapides et faciles de toute façon, il vous suffit de décompresser les modifications et de les inspecter. Si vous ne les voulez pas pour le moment, jetez-les (l'index / le dossier de travail actuel change). En entier c'est

git stash apply
git diff
git reset
git checkout

Cela fonctionne pour moi sur la version 1.8.5.2 de git:

git diff stash HEAD

Au cas où, pour comparer un fichier dans l'arborescence de travail et dans la cachette, utilisez la commande ci-dessous

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

Si vous avez des outils pour diff (comme au-delà de comparer)

git difftool stash HEAD

Une façon de le faire sans bouger quoi que ce soit est de profiter du fait que l' patchon peut lire les diff de git (diff unifiés en gros)

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

Cela vous montrera un aperçu étape par étape de ce que le correctif ferait normalement. L'avantage supplémentaire est que le correctif ne s'empêchera pas non plus d'écrire le correctif dans l'arborescence de travail, si pour une raison quelconque vous avez vraiment besoin de git pour arrêter la validation avant de modifier, allez-y et supprimez --dry- exécutez et suivez les instructions détaillées.

En combinant ce que j'ai appris dans ce fil et dans celui-ci , quand je veux voir "ce qui est à l'intérieur de la cachette", je lance d'abord:

git stash show stash@{0}

Cela montrera quels fichiers ont été modifiés. Ensuite, pour obtenir un joli diff visuel dans un difftool, je fais:

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

Cela affichera toutes les différences à la fois de la cachette donnée par rapport à son parent.

Vous pouvez configurer l'outil diff dans ~/.gitconfig, par exemple avec Meld :

...
[diff]
    tool = meld

FWIW Cela peut être un peu redondant pour toutes les autres réponses et est très similaire à la réponse acceptée qui est parfaite; mais peut-être que cela aidera quelqu'un.

git stash show --helpvous donnera tout ce dont vous avez besoin; y compris les informations sur le spectacle caché.

afficher [<stash>]

Affichez les modifications enregistrées dans la sauvegarde sous forme de différence entre l'état stocké et son parent d'origine. Lorsque non est indiqué, affiche le dernier. Par défaut, la commande affiche le diffstat, mais elle accepte tout format connu pour git diff (par exemple, git stash show -p stash @ {1} pour afficher le deuxième stash le plus récent sous forme de patch). Vous pouvez utiliser les variables de configuration stash.showStat et / ou stash.showPatch pour modifier le comportement par défaut.

Elle la liste des cachettes

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

Alors, obtenez le numéro de réserve et faites:

Tu peux faire:

 git stash show -p stash@{1}

Mais si vous voulez un diff (c'est différent pour montrer la cachette, c'est pourquoi j'écris cette réponse. DiffConsidérez le code actuel dans votre branche et showmontrez juste ce que vous appliquerez )

Vous pouvez utiliser:

git diff stash@{0}

ou

git diff stash@{0} <branch name>

Une autre chose intéressante à faire est:

git stash apply
git stash apply stash@{10}

Cela applique le stash sans le supprimer de la liste, vous pouvez git checkout .supprimer ces modifications ou si vous êtes heureux git stash drop stash@{10}de supprimer un stash de la liste.

De là, je ne recommande jamais d'utiliser git stash popet d'utiliser une combinaison de git stash applyet git stash dropSi vous appliquez une cachette dans la mauvaise branche ... eh bien, il est parfois difficile de récupérer votre code.

Selon ce avec quoi vous voulez comparer la cachette (arbre de travail local / commit parent / commit head), il existe en fait plusieurs commandes disponibles, parmi lesquelles la bonne vieille git diffet la plus spécifique 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       ║   /               ║
╚══════════════════════╩═══════════════════════════════╩═══════════════════╝

Bien qu'il git stash showsemble plus convivial à première vue, il git diffest en fait plus puissant en ce qu'il permet de spécifier des noms de fichiers pour une différence plus ciblée. J'ai personnellement configuré des alias pour toutes ces commandes dans mon plugin zsh git .