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!
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!
Réponses:
Voir la cachette la plus récente:
git stash show -p
Voir une cachette arbitraire:
git stash show -p stash@{1}
Depuis les git stash
pages 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).
stash@{0}
est la valeur par défaut; vous n'avez besoin d'un argument que si vous souhaitez consulter les masques précédents.
{0}
.
-p
stand?
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.
git diff stash@{0} master
, vous obtenez un diff de votre cachette par rapport au maître actuel (qui inclut le travail effectué sur le maître après la cachette a été fait), pas les fichiers / lignes que la cachette changerait, c'est de cela qu'il s'agit.
git difftool --tool=... stash@{0} HEAD
git diff stash@{0}^ stash@{0}
git diff stash@{0} master -- filename
de fichier pour obtenir les modifications dans un fichier spécifique.
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.
~/.gitconfig
:laststash = diff stash@{0}^!
git difftool stash^!
pour le diff du dernier stash contre la validation sur laquelle il était basé, git difftool stash HEAD
pour le diff du dernier stash contre le commit actuel (stash @ {n} pour les stashes précédents)
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.
git stash show -l
. Est-ce que la dernière cachette diffère de la copie de travail (sale)? Comment l'utilisez-vous sans obtenir error: switch l requires a value
?
git stash show -l
. Quant à savoir pourquoi cela ne fonctionne pas pour vous, je peux seulement deviner que vous pourriez être sur une ancienne version de git? Je suis sur git v2.20.1, et cela fonctionne parfaitement sans erreurs.
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
git stash save -u
Cela fonctionne pour moi sur la version 1.8.5.2 de git:
git diff stash HEAD
git stash apply
.
Si vous avez des outils pour diff (comme au-delà de comparer)
git difftool stash HEAD
git stash apply
.
HEAD
. Je pourrais modifier la réponse de @ yerlilbilgin pour supprimer HEAD mais je pense que toute personne qui utilise git peut comprendre cette partie et moi allonger la réponse la rendrait moins lisible. Pas de blâme sur @yerlibilgin.
Une façon de le faire sans bouger quoi que ce soit est de profiter du fait que l' patch
on 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 --help
vous 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. Diff
Considérez le code actuel dans votre branche et show
montrez 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 pop
et d'utiliser une combinaison de git stash apply
et git stash drop
Si 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 diff
et 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 show
semble plus convivial à première vue, il git diff
est 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 .