Como Verificar se um Git Stash Contém Alterações Específicas

Introdução

Neste laboratório, você aprenderá como inspecionar o conteúdo de um Git stash para determinar se ele contém alterações específicas. Começaremos fazendo e guardando (stashing) algumas alterações em um repositório de exemplo.

Em seguida, você usará o comando git stash show -p para visualizar o diff detalhado do stash mais recente, permitindo que você veja as linhas exatas que foram adicionadas, removidas ou modificadas. Finalmente, você explorará como examinar múltiplos stashes para encontrar as alterações que você está procurando.

Executar git stash show -p

Nesta etapa, aprenderemos como inspecionar as alterações armazenadas em um Git stash. Quando você usa git stash, o Git salva suas alterações não confirmadas. Para ver exatamente o que foi salvo, você pode usar o comando git stash show.

Primeiro, vamos fazer algumas alterações em um arquivo em nosso repositório my-time-machine. Navegue de volta para o diretório, caso você ainda não esteja lá:

cd ~/project/my-time-machine

Agora, vamos adicionar algum novo conteúdo ao nosso arquivo message.txt. Usaremos o comando echo com >> para anexar ao arquivo, para não sobrescrever o conteúdo existente.

echo "Adding a new line for stashing." >> message.txt

Você pode verificar o conteúdo do arquivo usando cat:

cat message.txt

Você deve ver tanto a linha original quanto a nova linha:

Hello, Future Me
Adding a new line for stashing.

Agora, vamos guardar (stash) essas alterações. Lembre-se, guardar (stashing) salva suas alterações não confirmadas para que você possa trabalhar em outra coisa e voltar a elas mais tarde.

git stash save "Added a line for stashing demo"

Você deve ver uma saída indicando que as alterações foram salvas:

Saved working tree and index state On branch master: Added a line for stashing demo

Agora que as alterações estão guardadas (stashed), vamos usar git stash show para ver o que está no stash.

git stash show

Este comando fornece um resumo das alterações no stash mais recente. Você pode ver uma saída como esta:

 message.txt | 1 +
 1 file changed, 1 insertion(+)

Isso nos diz que um arquivo (message.txt) foi alterado e houve uma inserção (uma nova linha).

Para ver o conteúdo real das alterações, precisamos adicionar a flag -p (que significa patch). Isso nos mostrará o diff, assim como git diff.

git stash show -p

Este comando exibirá as linhas exatas que foram adicionadas, removidas ou modificadas nas alterações guardadas (stashed). A saída se parecerá com um Git diff padrão:

diff --git a/message.txt b/message.txt
index <some_hash>..<some_hash> 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a new line for stashing.

As linhas que começam com + indicam adições. Neste caso, adicionamos a linha "Adding a new line for stashing."

Usar git stash show -p é crucial para entender o que está em um stash antes de decidir aplicá-lo ou descartá-lo. Isso ajuda você a confirmar que o stash contém as alterações que você espera.

Pesquisar Alterações no Diff do Stash

Na etapa anterior, usamos git stash show -p para visualizar as alterações em um stash. Às vezes, a saída do diff pode ser muito longa, especialmente em projetos grandes. Nesses casos, você pode querer procurar por alterações específicas dentro do diff do stash.

A saída do diff do Git é apenas texto, então você pode canalizá-la para ferramentas de linha de comando Linux padrão, como grep, para procurar por padrões.

Vamos tentar procurar a linha que adicionamos na etapa anterior: "Adding a new line for stashing."

Certifique-se de que você ainda está no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine

Agora, execute o comando git stash show -p e canalize sua saída para grep. Vamos procurar pela palavra "stashing".

git stash show -p | grep "stashing"

Você deve ver a linha contendo a palavra "stashing" da saída do diff:

+Adding a new line for stashing.

Isso demonstra como você pode usar grep para filtrar a saída de git stash show -p e encontrar linhas ou padrões específicos dentro das alterações guardadas (stashed).

Você pode usar qualquer uma das opções do grep para refinar sua pesquisa. Por exemplo, você pode usar -i para pesquisa sem distinção entre maiúsculas e minúsculas, ou -C para mostrar linhas de contexto ao redor da correspondência.

Ser capaz de pesquisar no diff do stash é uma técnica poderosa, especialmente quando você tem múltiplos stashes ou stashes grandes. Isso ajuda você a localizar rapidamente as alterações que lhe interessam sem ter que rolar manualmente por toda a saída do diff.

Testar Múltiplos Stashes

Em cenários do mundo real, você pode precisar guardar (stash) alterações várias vezes. O Git permite que você tenha múltiplos stashes, e eles são gerenciados como uma pilha (stack). O stash mais recente está no topo da pilha, referido como stash@{0}. Stashes mais antigos são stash@{1}, stash@{2}, e assim por diante.

Vamos criar outro conjunto de alterações e guardá-las (stash) para ver como isso funciona.

Primeiro, certifique-se de que você está no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine

Agora, vamos adicionar uma linha diferente a message.txt:

echo "Adding a second line for another stash." >> message.txt

Verifique o conteúdo:

cat message.txt

Você deve ver três linhas agora:

Hello, Future Me
Adding a new line for stashing.
Adding a second line for another stash.

Agora, guarde (stash) essas novas alterações:

git stash save "Added a second line for stashing demo"

Você deve ver a saída indicando o novo stash:

Saved working tree and index state On branch master: Added a second line for stashing demo

Para ver a lista de stashes que você tem, use o comando git stash list:

git stash list

Você deve ver algo assim:

stash@{0}: On master: Added a second line for stashing demo
stash@{1}: On master: Added a line for stashing demo

Observe que o stash mais recente ("Added a second line...") é stash@{0}, e o anterior ("Added a line...") é stash@{1}.

Você pode usar git stash show -p com o identificador do stash para visualizar o conteúdo de um stash específico. Por exemplo, para visualizar o primeiro stash que criamos (stash@{1}):

git stash show -p stash@{1}

Isso mostrará o diff para as alterações em stash@{1}:

diff --git a/message.txt b/message.txt
index <some_hash>..<some_hash> 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a new line for stashing.

E para visualizar o stash mais recente (stash@{0}):

git stash show -p stash@{0}

Isso mostrará o diff para as alterações em stash@{0}:

diff --git a/message.txt b/message.txt
index <some_hash>..<some_hash> 100644
--- a/message.txt
+++ b/message.txt
@@ -2 +2,2 @@
 Adding a new line for stashing.
+Adding a second line for another stash.

Ser capaz de gerenciar múltiplos stashes e inspecionar seus conteúdos individualmente é muito útil quando você está lidando com diferentes tarefas ou experimentos.

Resumo

Neste laboratório, aprendemos como inspecionar o conteúdo de um Git stash usando o comando git stash show. Começamos fazendo alterações em um arquivo e, em seguida, guardando (stashing) essas alterações com uma mensagem descritiva usando git stash save. Depois, usamos git stash show para obter um resumo das alterações e, mais importante, git stash show -p para visualizar o diff detalhado das alterações guardadas (stashed), permitindo-nos ver as linhas exatas que foram adicionadas ou modificadas.

As etapas subsequentes, que não foram totalmente detalhadas no conteúdo fornecido, provavelmente envolveriam a busca no diff do stash por alterações específicas e o teste de múltiplos stashes para entender como inspecionar diferentes stashes na pilha (stack). Esse processo é crucial para verificar se um stash contém as modificações esperadas antes de aplicá-lo ou descartá-lo.