Como Verificar se um Git Stash Está Vazio

Introdução

Neste laboratório, você aprenderá como verificar se um Git stash está vazio. Exploraremos diferentes métodos para inspecionar e verificar o conteúdo de seus stashes.

Primeiramente, você usará o comando git stash show para inspecionar as alterações dentro de um stash, incluindo a visualização de um resumo e o diff detalhado. Em seguida, você aprenderá como usar git stash list para verificar a presença e o conteúdo dos stashes. Finalmente, você testará esses comandos com stashes não vazios para solidificar sua compreensão.

Executar git stash show para Inspecionar

Nesta etapa, aprenderemos como inspecionar as alterações armazenadas em um Git stash usando o comando git stash show.

Antes de podermos inspecionar um stash, precisamos ter um. Vamos criar um arquivo simples e fazer o stash das alterações.

Primeiro, certifique-se de estar no diretório do seu projeto:

cd ~/project/my-time-machine

Agora, crie um novo arquivo chamado notes.txt e adicione algum conteúdo:

echo "Important notes for the future." > notes.txt

Verifique o status para ver o novo arquivo:

git status

Você deve ver notes.txt listado como um arquivo não rastreado.

Agora, vamos fazer o stash dessas alterações. Isso salvará as alterações sem confirmá-las e limpará seu diretório de trabalho:

git stash save "Add important notes"

Você deve ver uma saída indicando que as alterações foram salvas e o diretório de trabalho está limpo.

Agora que temos um stash, podemos inspecionar seu conteúdo usando git stash show. Por padrão, git stash show mostra um resumo das alterações no stash mais recente.

Execute o comando:

git stash show

Você deve ver uma saída semelhante a esta:

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

Esta saída nos diz que um arquivo (notes.txt) foi alterado e que uma linha foi adicionada.

Para ver as alterações reais do conteúdo (um diff), você pode adicionar a opção -p ou --patch:

git stash show -p

Isso mostrará o diff das alterações no stash, de forma semelhante a como git diff funciona. Você deve ver algo como isto:

diff --git a/notes.txt b/notes.txt
new file mode 100644
index 0000000..a1b2c3d
--- /dev/null
+++ b/notes.txt
@@ -0,0 +1 @@
+Important notes for the future.

Esta saída mostra que um novo arquivo notes.txt foi criado e a linha "Important notes for the future." foi adicionada.

O comando git stash show é muito útil para verificar rapidamente quais alterações estão contidas em um stash sem ter que aplicá-lo. Isso ajuda você a decidir qual stash você pode querer aplicar ou descartar mais tarde.

Usar git stash list para Verificar

Nesta etapa, aprenderemos como visualizar uma lista de todos os stashes que você criou usando o comando git stash list. Isso é útil quando você tem vários stashes e precisa se lembrar do que cada um contém.

Certifique-se de ainda estar no diretório do seu projeto:

cd ~/project/my-time-machine

Na etapa anterior, criamos um stash. Vamos usar git stash list para vê-lo.

Execute o comando:

git stash list

Você deve ver uma saída semelhante a esta:

stash@{0}: On master: Add important notes

Vamos analisar essa saída:

• stash@{0}: Este é o nome do stash. stash indica que é um stash, e {0} é o índice do stash na lista. O stash mais recente está sempre no índice {0}.
• On master: Isso informa em qual branch você estava quando criou o stash.
• Add important notes: Esta é a mensagem que fornecemos quando criamos o stash usando git stash save. Se você não fornecer uma mensagem, o Git gerará automaticamente uma com base no commit atual e nos arquivos alterados.

Se você tivesse vários stashes, eles seriam listados com índices crescentes, como stash@{0}, stash@{1}, stash@{2}, e assim por diante.

Vamos criar outro stash para ver como a lista muda.

Primeiro, modifique o arquivo message.txt que criamos em um laboratório anterior:

echo "Adding another line for testing." >> message.txt

Agora, faça o stash dessas novas alterações:

git stash save "Add another line to message"

Execute git stash list novamente:

git stash list

Agora você deve ver dois stashes:

stash@{0}: On master: Add another line to message
stash@{1}: On master: Add important notes

Observe que o novo stash agora está no índice {0}, e o stash anterior foi movido para o índice {1}. O Git sempre coloca o stash mais recente no topo da lista com o índice {0}.

O comando git stash list é essencial para gerenciar vários stashes. Ele fornece uma visão geral clara do seu trabalho salvo, permitindo que você identifique e referencie stashes específicos quando precisar aplicá-los ou descartá-los.

Testar Stashes Não Vazios

Nesta etapa, praticaremos o uso de git stash show e git stash list com múltiplos stashes para reforçar nossa compreensão.

Certifique-se de estar no diretório do seu projeto:

cd ~/project/my-time-machine

Atualmente, temos dois stashes. Vamos listá-los novamente para refrescar nossa memória:

git stash list

Você deve ver:

stash@{0}: On master: Add another line to message
stash@{1}: On master: Add important notes

Agora, vamos inspecionar o conteúdo do primeiro stash (stash@{0}). Podemos especificar qual stash mostrar adicionando seu índice ao comando:

git stash show stash@{0}

Isso mostrará o resumo das alterações no stash mais recente, que é aquele onde adicionamos uma linha a message.txt. A saída deve ser semelhante a:

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

Para ver o diff para este stash, use a opção -p:

git stash show -p stash@{0}

Você deve ver o diff mostrando a linha adicionada em message.txt.

Agora, vamos inspecionar o segundo stash (stash@{1}). Este é o stash onde criamos o arquivo notes.txt.

git stash show stash@{1}

A saída deve ser semelhante a:

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

E para ver o diff para este stash:

git stash show -p stash@{1}

Isso mostrará o diff para a criação de notes.txt.

Ser capaz de listar e inspecionar stashes individuais é crucial quando você salvou múltiplos conjuntos de alterações. Isso permite que você identifique rapidamente o stash que você precisa sem ter que aplicá-los um por um.

Nos próximos laboratórios, aprenderemos como aplicar e gerenciar esses stashes.

Resumo

Neste laboratório, aprendemos como inspecionar o conteúdo de um stash do Git usando o comando git stash show. Primeiro, criamos um arquivo simples e fizemos o stash das alterações para ter um stash com o qual trabalhar. Em seguida, usamos git stash show para ver um resumo das alterações no stash mais recente, incluindo o número de arquivos alterados e linhas adicionadas/excluídas. Também exploramos a opção -p ou --patch com git stash show para visualizar o diff real das alterações dentro do stash, permitindo que víssemos as linhas específicas que foram adicionadas, modificadas ou excluídas. Este comando é uma ferramenta valiosa para entender rapidamente o conteúdo de um stash sem precisar aplicá-lo.