Salvando o Trabalho em Andamento

Introdução

Boas-vindas de volta, explorador do Git! Hoje, vamos mergulhar em um dos recursos mais úteis do Git para gerenciar seu trabalho em andamento: o stash. Você já esteve no meio do desenvolvimento de uma funcionalidade quando, de repente, precisou mudar para uma tarefa diferente? O Git stash está aqui para salvar o dia!

Pense no Git stash como uma gaveta mágica onde você pode guardar temporariamente seu trabalho inacabado. Ele permite que você mude de contexto rapidamente sem precisar fazer um commit de um trabalho feito pela metade. Isso é incrivelmente útil quando você precisa trocar de branch, baixar atualizações (pull) ou lidar com a correção urgente de um bug.

Neste laboratório, exploraremos como usar o Git stash para salvar seu trabalho em andamento, como aplicar alterações armazenadas, criar branches a partir de stashes, gerenciar múltiplos stashes e limpar sua lista de stashes. Ao final deste laboratório, você terá uma nova e poderosa ferramenta em seu kit do Git que tornará seu fluxo de trabalho mais fluido e flexível.

Vamos começar e desbloquear o poder do Git stash!

Configurando seu Espaço de Trabalho

Antes de mergulharmos no stashing, vamos configurar um espaço de trabalho para experimentar. Criaremos um novo diretório, inicializaremos um repositório Git e adicionaremos algum conteúdo inicial.

Abra seu terminal e digite estes comandos:

cd ~/project
mkdir git-stash-lab
cd git-stash-lab
git init
echo "## Git Stash Lab" > README.md
git add README.md
git commit -m "Initial commit"

Vamos detalhar o que esses comandos fazem:

1. cd ~/project: Altera seu diretório atual para a pasta "project" em seu diretório home.
2. mkdir git-stash-lab: Cria um novo diretório chamado "git-stash-lab".
3. cd git-stash-lab: Move você para dentro do diretório recém-criado.
4. git init: Inicializa um novo repositório Git no diretório atual.
5. echo "## Git Stash Lab" > README.md: Cria um novo arquivo chamado "README.md" com o conteúdo "## Git Stash Lab".
6. git add README.md: Adiciona o novo arquivo à área de preparação (staging) para o commit.
7. git commit -m "Initial commit": Cria seu primeiro commit com as alterações preparadas.

Excelente! Agora temos um repositório com um commit. Vamos verificar nosso status:

git status

Você deve ver uma mensagem dizendo que sua árvore de trabalho está limpa (working tree clean). Isso significa que estamos prontos para começar a experimentar com o Git stash!

Se encontrar algum problema, certifique-se de que está no diretório correto e que o Git está instalado corretamente em seu sistema. Você pode verificar sua instalação do Git executando git --version.

Armazenando Alterações (Stashing)

Agora que temos nosso espaço de trabalho configurado, vamos criar algumas alterações e aprender como armazená-las no stash.

Primeiro, vamos fazer algumas alterações em nosso arquivo README.md:

echo "This is a work in progress" >> README.md

Este comando adiciona uma nova linha ao nosso arquivo README.md. Vamos também criar um novo arquivo:

echo "Some important notes" > notes.txt

Agora, se executarmos git status, veremos que temos tanto arquivos modificados quanto arquivos não rastreados (untracked):

git status

Você deve ver uma saída indicando que o README.md foi modificado e o notes.txt não está sendo rastreado.

Imagine que, neste momento, você precise mudar rapidamente para outra tarefa, mas não está pronto para fazer o commit dessas alterações. É aqui que o git stash se torna útil!

Para armazenar suas alterações, execute:

git stash

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

Saved working directory and index state WIP on master: 1234567 Initial commit

Agora, se você executar git status novamente, verá algo interessante:

git status

Você notará que, embora o README.md não apareça mais como modificado, o notes.txt ainda está listado como um arquivo não rastreado. Este é um ponto crucial sobre o git stash:

Importante: Por padrão, o git stash armazena apenas:

1. Alterações em arquivos rastreados (arquivos que o Git já conhece)
2. Alterações na área de preparação (staged)

Arquivos não rastreados (como o nosso notes.txt) não são incluídos no stash por padrão. Esse comportamento garante que o Git não esconda acidentalmente novos arquivos que você talvez não queira incluir no repositório.

Se você quiser incluir arquivos não rastreados em seu stash, pode usar a opção -u (ou --include-untracked):

git stash -u

Após executar este comando, tanto as alterações no README.md quanto o novo arquivo notes.txt serão armazenados no stash.

Para ver o que está no seu stash, você pode usar:

git stash list

Você deve ver uma ou duas entradas de stash, dependendo se usou a opção -u.

Pressione q para sair da visualização da lista de stashes.

Lembre-se, o stashing é perfeito para mudanças rápidas de contexto. No entanto, ele não substitui os commits em seu fluxo de trabalho de longo prazo. Os stashes destinam-se a ser um armazenamento temporário.

Aplicando Alterações Armazenadas

Agora que armazenamos nossas alterações, vamos aprender como trazê-las de volta. Existem dois comandos principais para isso: git stash apply e git stash pop.

Vamos começar com o git stash apply:

git stash apply

Após executar este comando, você pode notar algo inesperado. Vamos verificar o status:

git status

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

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

nothing added to commit but untracked files present (use "git add" to track)

Surpreendentemente, você verá apenas o notes.txt como um arquivo não rastreado e não verá nenhuma alteração no README.md. Esse comportamento ocorre porque:

1. Na Etapa 2, usamos primeiro o git stash sem a opção -u, o que armazenou apenas as alterações do README.md.
2. Depois usamos git stash -u, que armazenou o arquivo não rastreado notes.txt (o README.md já estava limpo devido ao stash anterior).
3. Quando aplicamos o stash, o Git aplica o stash mais recente (aquele criado com -u), que contém apenas o notes.txt, por isso você não vê as alterações no README.md.

Para ver todas as alterações, incluindo as do README.md, você pode usar:

git stash apply stash@{1}

Agora, se você verificar o status novamente, verá tanto as alterações no README.md quanto o notes.txt como um arquivo não rastreado.

Esta situação destaca um aspecto importante ao trabalhar com stashes: a ordem em que você cria e aplica os stashes pode afetar o resultado. É sempre uma boa prática verificar o conteúdo de seus stashes antes de aplicá-los, especialmente ao trabalhar com múltiplos stashes.

A diferença entre apply e pop é que o apply mantém as alterações no seu stash, enquanto o pop as remove do stash após a aplicação.

git stash clear
git stash -u
git stash list

Primeiro limpamos todos os stashes para começar do zero, depois armazenamos nossas alterações com a opção -u para incluir arquivos não rastreados. Por fim, listamos nossos stashes para verificar se o stash foi criado.

Vamos armazenar nossas alterações novamente e tentar o pop:

git stash pop

Você verá uma saída semelhante à anterior, mas se executar git stash list agora, verá que seu stash está vazio.

Por que ter tanto apply quanto pop? O apply é útil quando você deseja aplicar as mesmas alterações armazenadas em várias branches. O pop é mais comumente usado quando você está apenas retomando o trabalho na mesma branch.

Criando uma Branch a partir de um Stash

Às vezes, você pode perceber que as alterações que armazenou no stash deveriam, na verdade, estar em sua própria branch. O Git facilita isso com o comando git stash branch.

Primeiro, vamos criar algumas novas alterações e armazená-las:

echo "Feature in progress" >> README.md
echo "More notes" >> notes.txt
git stash -u

Agora, vamos criar uma nova branch com essas alterações:

git stash branch feature-branch

Este comando cria uma nova branch chamada "feature-branch", faz o checkout dela e, em seguida, aplica as alterações armazenadas. O stash é então removido da sua lista de stashes.

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

Switched to a new branch 'feature-branch'
On branch feature-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (1234567890abcdef1234567890abcdef12345678)

Este recurso é particularmente útil quando você armazenou algumas alterações experimentais e depois decide que vale a pena prosseguir com elas em uma branch própria.

Lembre-se, após criar uma branch a partir de um stash, você precisará fazer o commit das alterações se quiser mantê-las:

git add README.md notes.txt
git commit -m "Start new feature"

Para voltar para a sua branch master, use:

git checkout master

Gerenciando Múltiplos Stashes

Conforme você trabalha com o Git, pode se encontrar armazenando vários conjuntos de alterações. O Git permite gerenciar múltiplos stashes facilmente. Vamos explorar como criar, listar e gerenciar vários stashes.

Primeiro, vamos criar três stashes com alterações diferentes:

## Primeiro stash
echo "Change 1" >> README.md
git stash push -m "First change"

## Segundo stash com arquivo não rastreado
echo "Change 2" >> README.md
echo "Note 2" >> notes.txt
git stash push -u -m "Second change"

## Terceiro stash
echo "Change 3" >> README.md
git stash push -m "Third change"

Nota: Você notará que agora estamos usando git stash push em vez de apenas git stash. O subcomando push é a forma moderna e preferida de criar stashes, especialmente quando você deseja adicionar mensagens personalizadas com a flag -m. Embora git stash e git stash -u ainda funcionem (eles são atalhos para git stash push e git stash push -u), usar git stash push explicitamente oferece mais controle e clareza, particularmente ao gerenciar múltiplos stashes com mensagens descritivas.

Vamos detalhar o que fizemos:

1. Criamos o primeiro stash com uma alteração no README.md.
2. Criamos o segundo stash com uma alteração no README.md e um novo arquivo não rastreado.
3. Criamos o terceiro stash com outra alteração no README.md.
4. Usamos a flag -m para adicionar mensagens descritivas.
5. Usamos a flag -u no segundo stash para incluir o arquivo não rastreado.

Agora, vamos listar nossos stashes:

git stash list

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

stash@{0}: On master: Third change
stash@{1}: On master: Second change
stash@{2}: On master: First change

Você pode examinar o conteúdo de um stash sem aplicá-lo:

git stash show stash@{1}

Para mais detalhes, adicione a flag -p para ver o diff completo:

git stash show -p stash@{1}

Vamos criar mais dois stashes para praticar o gerenciamento de um conjunto maior de alterações:

## Quarto stash
echo "Change 4" >> README.md
git stash push -m "Fourth change"

## Quinto stash
echo "Change 5" >> README.md
git stash push -m "Fifth change"

Verifique sua lista de stashes novamente:

git stash list

Agora você deve ver cinco stashes em sua lista:

stash@{0}: On master: Fifth change
stash@{1}: On master: Fourth change
stash@{2}: On master: Third change
stash@{3}: On master: Second change
stash@{4}: On master: First change

Gerenciar múltiplos stashes pode ser útil quando você está equilibrando várias tarefas ao mesmo tempo. No entanto, tente não acumular muitos stashes, pois isso pode se tornar confuso. Considere usar branches para trabalhos de longo prazo.

Lembre-se: stashes devem ser temporários. Se você perceber que está mantendo stashes por muito tempo, considere usar branches de funcionalidade (feature branches) ou fazer o commit de suas alterações.

Limpando Stashes

À medida que você utiliza stashes em seu fluxo de trabalho, pode acumular itens que não são mais necessários. É uma boa prática limpar seus stashes regularmente para manter as coisas organizadas.

Para remover um único stash, você pode usar o comando drop que vimos anteriormente:

git stash drop stash@{2}

Isso remove o terceiro stash (com a mensagem "Third change") da nossa lista.

Se você quiser remover todos os seus stashes de uma vez, pode usar:

git stash clear

Tenha muito cuidado com este comando! Ele removerá todos os seus stashes e a ação não pode ser desfeita.

Outro comando útil é o git stash pop, que vimos anteriormente. Ele aplica o stash mais recente e o remove da lista:

git stash pop

Lembre-se, geralmente é uma boa prática manter sua lista de stashes curta. Os stashes destinam-se ao armazenamento temporário de trabalho em andamento. Se você estiver acumulando muitos stashes, pode ser um sinal de que deve fazer commits com mais frequência ou criar branches para trabalhos mais longos.

Resumo

Parabéns, mestre do Git stash! Você acaba de adicionar uma ferramenta poderosa ao seu kit do Git. Vamos recapitular os principais conceitos que abordamos:

1. Armazenando Alterações: Você aprendeu como guardar temporariamente seu trabalho em andamento usando git stash.
2. Aplicando Alterações Armazenadas: Você descobriu como trazer de volta suas alterações usando git stash apply e git stash pop.
3. Criando Branches a partir de Stashes: Você viu como transformar um conjunto de alterações armazenadas em uma nova branch com git stash branch.
4. Gerenciando Múltiplos Stashes: Você aprendeu a trabalhar com vários stashes, aplicando e visualizando stashes específicos conforme necessário.
5. Limpando Stashes: Você praticou a boa higiene de stashes aprendendo a remover itens individuais e a limpar toda a lista.

O Git stash é um recurso incrivelmente útil que permite mudar de contexto rapidamente sem comprometer um trabalho inacabado. É perfeito para aqueles momentos em que você precisa trocar de tarefa ou de branch com urgência.

Lembre-se, embora os stashes sejam úteis, eles devem ser temporários. Para trabalhos de longo prazo, geralmente é melhor fazer o commit de suas alterações ou criar uma nova branch. Use os stashes com sabedoria e eles ajudarão a manter seu fluxo de trabalho suave e flexível.