Respostas:
Veja o esconderijo mais recente:
git stash show -p
Veja um esconderijo arbitrário:
git stash show -p stash@{1}
Das git stash
páginas de manual:
Por padrão, o comando mostra o diffstat, mas aceita qualquer formato conhecido pelo git diff (por exemplo, git stash show -p stash @ {1} para exibir o segundo stash mais recente no formato de patch).
stash@{0}
é o padrão; você só precisa de um argumento se quiser examinar os stashes anteriores.
{0}
.
-p
significa?
Para ver o esconderijo mais recente:
git stash show -p
Para ver um estoque arbitrário:
git stash show -p stash@{1}
Além disso, eu uso o git diff para comparar o esconderijo com qualquer ramo.
Você pode usar:
git diff stash@{0} master
Ver todas as alterações comparadas ao mestre da filial.
Ou você pode usar:
git diff --name-only stash@{0} master
Para encontrar facilmente apenas nomes de arquivos alterados.
git diff stash@{0} master
, obtenha um diff do seu stash em relação ao mestre atual (que inclui o trabalho realizado no mestre após o stash foi feita), não os arquivos / linhas que o stash alteraria, e é disso que se trata a questão.
git difftool --tool=... stash@{0} HEAD
git diff stash@{0}^ stash@{0}
git diff stash@{0} master -- filename
para obter as alterações em um arquivo específico.
Se o ramo em que as alterações armazenadas em cache são baseadas foi alterado, esse comando pode ser útil:
git diff stash@{0}^!
Isso compara o stash com o commit em que ele se baseia.
~/.gitconfig
:laststash = diff stash@{0}^!
git difftool stash^!
para diff do último esconderijo contra a comprometer-se com base em, git difftool stash HEAD
por diff do último esconderijo contra a corrente commit (esconderijo @ {n} para esconderijos anteriores)
Se a sua árvore de trabalho estiver suja , você poderá compará-la com um stash confirmando primeiro a árvore de trabalho suja e comparando-a com o stash. Posteriormente, você pode desfazer o commit com a árvore de trabalho suja (já que você pode não querer ter esse commit sujo no log de confirmação).
Você também pode usar a abordagem a seguir para comparar dois stashes um com o outro (nesse caso, basta colocar um dos stashes primeiro).
Confirme sua árvore de trabalho suja:
git add .
git commit -m "Dirty commit"
Diff o stash com esse commit:
git diff HEAD stash@{0}
Depois, você pode reverter o commit e colocá-lo novamente no diretório de trabalho:
git reset --soft HEAD~1
git reset .
Agora você diferenciou a árvore de trabalho suja com seu estoque e voltou para onde estava inicialmente.
git stash show -l
. Difere o último esconderijo contra a cópia de trabalho (suja)? Como você o usa sem obter error: switch l requires a value
?
git stash show -l
. Quanto ao motivo pelo qual isso não funciona para você, só posso supor que você esteja em uma versão mais antiga do git? Estou no git v2.20.1 e funciona perfeitamente, sem erros.
A resposta de @ Magne é a única data (muito tarde) que responde à interpretação mais flexível / útil da pergunta, mas é um pouco mais complicada do que o necessário. Em vez de confirmar e redefinir, apenas armazene sua cópia de trabalho, compare e desinstale.
git stash save "temp"
git diff stash@{0} stash@{1}
git stash pop
Isso mostra as diferenças entre a parte superior da pilha stash e sua pasta de trabalho, transformando temporariamente as alterações da pasta de trabalho na parte superior da pilha stash (stash @ {0}), movendo a parte superior original para baixo (stash @ {1} ), comparando usando a parte superior original na posição 'novo conjunto' para ver as alterações que resultariam da aplicação na parte superior do seu trabalho atual.
"Mas e se eu não tiver nenhum trabalho atual?" Então você está no caso chato normal. Basta usar a resposta de @ Amber
git stash show
ou a resposta de @ czerasz
git diff stash@{0}
ou admitir que esconder e desmascarar é rápido e fácil de qualquer maneira, basta descartar as alterações e inspecioná-las. Se você não os quiser no momento, jogue-os fora (o índice atual / pasta de trabalho muda). Na íntegra isso é
git stash apply
git diff
git reset
git checkout
git stash save -u
Isso funciona para mim no git versão 1.8.5.2:
git diff stash HEAD
git stash apply
.
Se você possui ferramentas para diff (como além da comparação)
git difftool stash HEAD
git stash apply
.
HEAD
. Eu poderia modificar a resposta de @erlilbilgin para remover o HEAD, mas acho que qualquer pessoa que use o git pode descobrir essa parte e me prolongar a resposta tornaria menos legível. Não há culpa em @yerlibilgin.
Uma maneira de fazer isso sem mover nada é tirar vantagem do fato de que você patch
pode ler os git diffs (diffs unificados basicamente)
git stash show -p | patch -p1 --verbose --dry-run
Isso mostrará uma visualização passo a passo do que o patch normalmente faria. O benefício adicional disso é que o patch também não impedirá a gravação do patch na árvore de trabalho. Se, por algum motivo, você realmente precisar do git para calar a boca sobre cometer antes da modificação, vá em frente e remova --dry- execute e siga as instruções detalhadas.
Combinando o que aprendi neste tópico e neste , quando quero ver "o que há dentro do esconderijo", primeiro executo:
git stash show stash@{0}
Isso mostrará quais arquivos foram modificados. Então, para obter um bom visual diff em um difftool, eu faço:
git difftool --dir-diff stash@{0} stash@{0}^
Isso exibirá todas as diferenças de uma vez do estoque fornecido contra seu pai.
Você pode configurar a ferramenta diff ~/.gitconfig
, por exemplo, com Meld :
...
[diff]
tool = meld
FWIW Isso pode ser um pouco redundante para todas as outras respostas e é muito semelhante à resposta aceita no local; mas talvez ajude alguém.
git stash show --help
lhe dará tudo que você precisa; incluindo informações sobre o show stash.
mostre [<stash>]
Mostre as alterações registradas no stash como uma diferença entre o estado stashed e seu pai original. Quando não é dado, mostra o mais recente. Por padrão, o comando mostra o diffstat, mas aceita qualquer formato conhecido pelo git diff (por exemplo, git stash show -p stash @ {1} para exibir o segundo stash mais recente no formato de patch). Você pode usar as variáveis de configuração stash.showStat e / ou stash.showPatch para alterar o comportamento padrão.
Ela a lista de esconderijo
git stash list
stash@{0}: WIP on feature/blabla: 830335224fa Name Commit
stash@{1}: WIP on feature/blabla2: 830335224fa Name Commit 2
Portanto, obtenha o número do stash e faça:
Você pode fazer:
git stash show -p stash@{1}
Mas se você quiser um diff (isso é diferente para mostrar o stash, é por isso que escrevo esta resposta. Diff
Considere o código atual em seu ramo e show
apenas mostre o que você aplicará )
Você pode usar:
git diff stash@{0}
ou
git diff stash@{0} <branch name>
Outra coisa interessante a fazer é:
git stash apply
git stash apply stash@{10}
Isso aplica o stash sem removê-lo da lista, você pode git checkout .
remover essas alterações ou, se estiver feliz git stash drop stash@{10}
em remover um stash da lista.
A partir daqui, nunca recomendo usar git stash pop
e usar uma combinação de git stash apply
e git stash drop
Se você aplicar um esconderijo no ramo errado ... bem, às vezes é difícil recuperar seu código.
Dependendo do que você deseja comparar o stash (árvore de trabalho local / commit pai / head commit), na verdade existem vários comandos disponíveis, entre os quais o bom git diff
e o mais específico 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 ║ / ║
╚══════════════════════╩═══════════════════════════════╩═══════════════════╝
Embora git stash show
pareça mais amigável à primeira vista, git diff
é realmente mais poderoso, pois permite especificar nomes de arquivos para uma comparação mais focada. Pessoalmente, configurei aliases para todos esses comandos no meu plugin zsh git .