Como usar o Git Stash: Um guia passo a passo

Este guia abordará em profundidade o `git stash` do , começando pelo seu conceito básico, utilidade e cenários de uso. Em seguida, abordaremos os conceitos básicos, como recuperar e gerenciar stashes, e exploraremos técnicas avançadas. As melhores práticas e sua importância no desenvolvimento de software encerrarão nosso guia, garantindo uma compreensão abrangente do git stash.

O Git e a importância do `git stash`

Antes de nos aprofundarmos nos detalhes do `git stash`, é fundamental entender o próprio Git. O Git, em poucas palavras, é um sistema de controle de versão distribuído que é  amplamente utilizado no desenvolvimento de software para acompanhar as alterações no código-fonte durante o desenvolvimento. Sua natureza distribuída permite que vários desenvolvedores trabalhem simultaneamente na mesma base de código sem interferir no trabalho uns dos outros. 

Entre as principais características que tornam o Git indispensável para os desenvolvedores estão:

• Ramificação e fusão: O modelo de ramificação do Git permite que os desenvolvedores trabalhem em ambientes isolados chamados “ramificações” e incorporem suas alterações ao código-fonte de maneira integrada.
• Rapidez e eficiência: O Git foi projetado para oferecer alto desempenho. Suas operações são rápidas, o que o torna adequado para projetos de qualquer porte.
• Integridade dos dados: O Git garante a integridade do código-fonte, mantendo um histórico completo e recursos abrangentes de controle de versões.

Compreender esses aspectos do Git abre caminho para uma exploração mais aprofundada do comando `git stash`, uma ferramenta que, embora seja menos comentada do que outras, como `git commit` ou `git merge`, pode, no entanto, ser um recurso inestimável no conjunto de ferramentas de um desenvolvedor.

O que é o `git stash`?

O comando `git stash` é um recurso poderoso do Git. Trata-se, essencialmente, de um mecanismo para salvar o estado atual do seu diretório de trabalho e do índice sem confirmar as alterações. É como uma área de transferência para alterações não confirmadas, oferecendo um instantâneo que pode ser reaplicado posteriormente. Esse recurso é essencial no controle de versão, pois ajuda a gerenciar as alterações no código de forma mais flexível e eficiente. Ele arquiva temporariamente, ou “guarda”, as alterações que você fez no diretório de trabalho, permitindo que você trabalhe em outra coisa e retorne a elas mais tarde.

Seus casos de uso incluem:

• Alteração de contexto Alterne rapidamente entre ramificações ou tarefas sem precisar fazer commit de um trabalho ainda incompleto.
• Experimentação: Teste novos códigos ou ideias sem afetar o projeto principal.
• Gerenciamento de trabalhos em andamento: Mantenha seu diretório de trabalho organizado, guardando em stash as alterações em andamento que ainda não estão prontas para serem confirmadas.

Em projetos com vários desenvolvedores, o `git stash` é indispensável

• Inspeção simplificada de código: Permite uma inspeção mais rápida do código e o rastreamento de bugs, facilitando as práticas de inspeção de código em equipe, o que é fundamental para identificar e resolver problemas rapidamente.
• Limpar o diretório de trabalho: Ajuda a manter um ambiente de trabalho organizado, reduzindo assim o risco de envios acidentais de trabalhos incompletos ou arquivos errados.
• Zona de experimentação segura: Facilita a realização de alterações experimentais sem afetar a base de código principal, permitindo que os desenvolvedores testem novas ideias sem interromper o fluxo de trabalho.
• Suporte em ambientes escaláveis: Pode ser útil em redes altamente containerizadas e/ou escalonadas horizontalmente, por exemplo, em cenários de implantação em fases, ao gerenciar alterações no código de maneira eficiente nas diferentes etapas de implantação.

Principais cenários para o uso do `git stash`

• Mudança urgente de ramificação: Alternar entre branches para correções urgentes, permitindo que os desenvolvedores mudem rapidamente de foco sem perder o andamento da tarefa atual.
• Suspender o trabalho atual: Deixar as alterações temporariamente de lado para trabalhar em outra coisa, o que ajuda a priorizar tarefas sem confundir diferentes alterações no código.
• Testes de código seguro: Experimentar código sem fazer commit no branch atual, ideal para testar novos recursos ou correções sem alterar a base de código principal ou o branch de trabalho atual.

Noções básicas sobre o stash do Git

Armazenar alterações no Git é bem simples. Basta usar o comando `git stash` no seu diretório de trabalho. Este comando irá armazenar todas as alterações modificadas e preparadas para envio, deixando seu diretório de trabalho limpo.

Como o comando `git stash` é usado

1. Faça as alterações no seu diretório de trabalho.
2. Execute o comando `git stash` para armazenar as alterações.
3. O diretório de trabalho volta ao estado do commit mais recente.

Como salvar alterações com uma mensagem

Use o comando `git stash save message`. Isso ajuda a organizar e identificar os stashes, especialmente ao trabalhar com vários stashes.

Como visualizar seus stashes

Use o comando `git stash list`. Este comando exibe uma lista de todos os stashes, cada um com um identificador e a mensagem (se houver).

Limitações comuns do `git stash`

• Isso não substitui os commits.
• Os stashes são locais e não são compartilhados entre repositórios.
• Arquivos não rastreados e ignorados não são armazenados no stash por padrão.

Casos de uso do `Git stash`

O `Git stash` possui funcionalidades importantes que os desenvolvedores podem utilizar em diversos cenários. Aqui estão alguns exemplos de uso.

1. Salvar o trabalho em andamento

Cenário: Quando um desenvolvedor precisa mudar para outro branch para se concentrar em um problema crítico, mas está no meio da implementação de uma nova correção de bug.

Caso de uso O `git stash` salva as alterações atuais sem fazer o commit, permitindo que os desenvolvedores mudem para outro branch ou façam alterações antes de retornar ao branch original e recuperar as alterações armazenadas.

2. Limpeza do diretório de trabalho

Cenário: Quando um desenvolvedor tem alterações não confirmadas em seu diretório de trabalho que não pode perder, mas deseja começar a trabalhar em um novo recurso do zero.

Caso de uso O `git stash` remove temporariamente as alterações não confirmadas. Ele limpa um diretório de trabalho, permitindo que os desenvolvedores criem um novo recurso do zero e, em seguida, reapliquem suas alterações anteriores.

3. Testando diferentes abordagens

Cenário: Quando um desenvolvedor está trabalhando em uma solução e quer experimentar uma nova abordagem, mas sem perder o trabalho já realizado.

Caso de uso O `Git stash` permite que os desenvolvedores guardem suas alterações atuais e experimentem diferentes abordagens. Eles podem voltar às alterações que guardaram caso a nova abordagem não funcione.

4. Resolução de conflitos de mesclagem

Cenário: Quando um desenvolvedor deseja guardar temporariamente algumas alterações para lidar com outras questões urgentes enquanto busca uma solução para um conflito de mesclagem complexo.

Caso de uso O `Git stash` permite salvar alterações temporariamente, possibilitando que os desenvolvedores se concentrem em outras tarefas e, posteriormente, voltem a resolver conflitos de mesclagem.

5. Armazenamento parcial

Cenário: Quando um desenvolvedor deseja selecionar apenas algumas das várias alterações que deseja armazenar temporariamente entre as alterações presentes em seu diretório de trabalho.

Caso de uso O `git stash` permite armazenar arquivos específicos ou partes deles, dando aos desenvolvedores mais controle sobre o que é armazenado.

6. Trabalhando com vários recursos

Cenário: Quando um desenvolvedor precisa alternar entre várias funcionalidades nas quais está trabalhando simultaneamente.

Caso de uso O `Git stash` permite que os desenvolvedores salvem o andamento do recurso no qual estão trabalhando no momento, para que possam passar para outro recurso sem perder as alterações feitas. Os desenvolvedores podem armazenar temporariamente seu trabalho em um recurso, alternar para um branch de outro recurso e, em seguida, reaplicar as alterações armazenadas assim que voltarem ao recurso em que estão trabalhando.

7. Revisões de código

Cenário: Quando um desenvolvedor precisa deixar alterações não confirmadas em seu diretório de trabalho para revisar o código de um colega.

Caso de uso O `Git stash` permite que os desenvolvedores armazenem suas alterações, revisem o código de seus colegas e, em seguida, reapliquem as alterações armazenadas assim que retornarem ao diretório de trabalho após analisar o código dos colegas.

8. Fazendo backup do trabalho não confirmado

Cenário: Quando um desenvolvedor deseja fazer backup de suas alterações não confirmadas em outro branch ou em um repositório remoto.

Caso de uso O `Git stash` permite armazenar alterações, criar um novo branch a partir do stash, enviar esse branch para um repositório remoto e fornecer um backup do trabalho ainda não confirmado do desenvolvedor.

9. Trabalho colaborativo

Cenário: Quando um desenvolvedor precisa baixar a versão mais recente do repositório sem perder suas alterações locais, mas está trabalhando em um repositório compartilhado.

Caso de uso O stash do Git permite que os desenvolvedores armazenem suas alterações e, em seguida, busquem as alterações ou atualizações mais recentes do repositório remoto. Assim, eles poderão aplicar novamente as alterações que guardaram posteriormente.

10. Automação do fluxo de trabalho

Cenário: Quando um desenvolvedor usa scripts ou hooks que exigem um diretório de trabalho limpo.

Caso de uso O `git stash` permite que os desenvolvedores guardem as alterações feitas antes de executar os scripts ou hooks. Em seguida, eles podem reaplicá-las para garantir um diretório de trabalho limpo para os processos de automação.

Esses são apenas os casos de uso mais comuns do `Git stash`, demonstrando sua flexibilidade na oferta de soluções e na otimização dos fluxos de trabalho de desenvolvimento.

Recuperando alterações armazenadas

Para aplicar novamente as alterações salvas mais recentes

Use o comando `git stash apply`. Este comando reaplica as alterações armazenadas mais recentemente, mas não as remove da lista de alterações armazenadas.

A diferença entre “apply” e “pop”

O comando `git stash pop` difere do `apply`, pois aplica o stash e, em seguida, o remove da lista de stashes. Isso é usado quando você tem certeza de que não precisa mais das alterações armazenadas.

Aplicando stashes específicos de vários stashes armazenados

1. Liste os stashes com o comando `git stash list`.
2. Aplique o stash desejado usando seu identificador: git stash apply stash@{n}.

Por exemplo: Se o comando `git stash list` mostrar dois stashes, use `git stash apply stash@{1}` para aplicar o segundo (enumerados a partir de zero).

Gerenciamento e limpeza de esconderijos

Como descartar ou limpar alterações armazenadas com segurança

• Para descartar um item específico: Use o comando `git stash drop stash@{n}` 
• Para limpar todos os stashes, o comando é `git stash clear`.

Estratégias para recuperar itens perdidos acidentalmente

Os stashes são, por definição, locais e não são confirmados nem transmitidos. Recuperar stashes descartados é um desafio, já que o Git não oferece uma maneira direta de fazer isso. No entanto, às vezes é possível recuperá-los usando o reflog, caso o stash tenha sido descartado recentemente; essa ferramenta funciona apenas localmente e pode ajudá-lo a localizar os arquivos temporários que ainda não foram excluídos.

Melhores práticas na gestão de estoque

• Manutenção preventiva: Revise regularmente e elimine os itens armazenados desnecessários.
• Lembre-se dos comentários: Use mensagens descritivas para facilitar a identificação.
• Use a ferramenta certa para cada tarefa: Evite depender de stashes por muito tempo; prefira commits para alterações de longo prazo.

Integração do gerenciamento de stash nos fluxos de trabalho

• Salvar as alterações antes de mudar de branch.
• Usando stashes para experimentos temporários.
• Adicionar ou remover itens regularmente para manter a lista de itens organizada.

Técnicas avançadas de `git stash`

Sobre o armazenamento de arquivos específicos ou alterações

Para colocar arquivos específicos no stash, use git stash push [arquivo1] [arquivo2]. Isso se aplica apenas aos arquivos ou alterações especificados, proporcionando maior controle sobre o que é armazenado no stash, ao aumentar a granularidade do controle do stash.

Como lidar com conflitos ao aplicar alterações armazenadas

Ao aplicar stashes, podem surgir conflitos. Trate-os da mesma forma que faria com um conflito de mesclagem: edite os arquivos para resolver os conflitos e, em seguida, adicione-os e faça o commit.

O `stash` do Git facilita a troca de ramificações

• Salvando as alterações no branch atual.
• Mudando para o branch de destino.
• Aplicando o stash no novo branch.

Comandos avançados do git stash

Aqui estão alguns comandos avançados do `git stash` que atendem tanto a casos de uso comuns quanto a outros mais especializados:

• Armazenando arquivos não rastreados: git stash –include-untracked ou git stash -u

Por padrão, o `git stash` armazena apenas os arquivos rastreados (aqueles que foram adicionados ao índice). Esse comando permite que você também armazene arquivos não rastreados (arquivos novos que ainda não foram adicionados ao índice), o que é útil quando você tem arquivos novos que ainda não está pronto para fazer o commit.

• Armazenar arquivos específicos: git stash push -m “mensagem” — caminho/para/arquivo1 caminho/para/arquivo2

Este comando armazena arquivos ou diretórios específicos, em vez de todo o diretório de trabalho. Isso é particularmente útil quando você deseja separar as alterações em diferentes arquivos ou diretórios e gerenciá-las de forma independente.

• Criando um branch a partir de um stash: git stash branch new_branch_name stash@{n}

Se você tiver um stash (stash@{n}) e perceber que ele deveria estar em um branch separado, este comando cria um novo branch a partir do commit em que o stash foi criado, aplica as alterações armazenadas no stash a ele e, em seguida, exclui o stash. É uma ótima maneira de gerenciar alterações armazenadas que se transformaram em um recurso mais significativo ou na correção de um bug. Isso é útil quando um stash não se aplica corretamente ao branch atual.

• Aplicando um stash sem índice: git stash apply –index

Normalmente, quando você aplica um stash, as alterações que estavam na área de preparação no momento em que o stash foi criado deixam de estar nessa área. O uso da opção –index reaplica o stash e também coloca na fila de alterações as alterações que estavam na fila no momento em que foram armazenadas no stash. Isso é útil quando você deseja preservar o estado do índice das alterações que você armazenou temporariamente.

• Stash interativo: git stash -p ou git stash –patch

Este comando permite que você selecione interativamente blocos de alterações para armazenar temporariamente. O Git solicitará sua confirmação para cada alteração no diretório de trabalho, e você poderá escolher se deseja armazená-la temporariamente ou não. Isso é particularmente útil quando você deseja um controle mais detalhado sobre o que será armazenado.

Melhores práticas para o `git stash`

Assim como muitos outros processos no desenvolvimento, o git stash também inclui estratégias que ajudam os desenvolvedores a aproveitar suas poderosas funcionalidades. Aqui estão algumas práticas recomendadas para o `git stash`:

Use o estoque com moderação: Em outras palavras, não abuse do `git stash`. Em vez de guardar o código, prefira utilizar branches dedicados para trabalhos em andamento de longo prazo. Lembre-se de usar o comando com moderação, especialmente quando ele for necessário apenas para trabalhar em outra tarefa, pois isso afetará as alterações que devem ser feitas no commit.

Use mensagens claras e descritivas nos esconderijos: Os desenvolvedores podem adicionar uma mensagem descritiva que explique as alterações que estão salvando no stash. Com isso em mente, eles devem sempre ser claros nas mensagens que deixam nos esconderijos e evitar mensagens desnecessárias. Tornar o stash significativo e informativo permite que os desenvolvedores se lembrem exatamente do que está nele quando voltarem a consultá-lo mais tarde. Mensagens claras também facilitam a identificação e a aplicação do stash correto posteriormente, para uma recuperação mais fácil.

Aproveitar as filiais: Certifique-se sempre de criar um novo branch antes de armazenar as alterações temporariamente. Isso permite que você alterne entre diferentes tarefas ou ramificações sem afetar suas alterações atuais. Você pode então voltar para o branch e aplicar o stash quando decidir trabalhar nas modificações novamente.

Armazenar arquivos não rastreados: Uma das melhores práticas que os desenvolvedores devem sempre seguir é usar comandos que incluam arquivos não rastreados ao salvar temporariamente. Isso reduz o risco de perda de dados ou de alterações importantes que tenham sido feitas anteriormente.

Gerenciar vários repositórios: Existem comandos que permitem aos desenvolvedores gerenciar vários stashes de maneira eficaz. Entre elas estão o comando `git stash list` para visualizar todos os stashes existentes, o comando `git stash apply stash@{<n>}` (onde <n> representa o índice do stash) para aplicar um stash específico e o comando `git stash drop stash@{<n>}` (onde <n> representa o índice do stash) para remover um stash caso você não precise mais dele.

Pense bem antes de usar o “stash pop”: Assim como a primeira prática recomendada, o comando `stash pop` (git stash pop) deve ser usado com bom senso. Embora esse comando ofereça uma maneira rápida de aplicar e remover um stash, a operação pode causar conflitos de mesclagem se as alterações armazenadas no stash entrarem em conflito com a árvore de trabalho atual. Como alternativa, você pode usar o comando `git stash apply` para aplicar o stash sem excluí-lo. Isso permite que você resolva manualmente quaisquer conflitos antes de remover o stash com o comando `git stash drop`.

Faça as alterações o mais rápido possível: O armazenamento deve ser utilizado apenas como uma solução temporária. Depois de concluir um conjunto de alterações, você deve enviá-las ao repositório para manter um registro dessas alterações.

Outras estratégias úteis para o stash do Git

Como manter um histórico do Git organizado

• Comprometa-se com a permanência: Para alterações permanentes, prefira commits em vez de stashes.
  • git commit -m “Mensagem do commit”
• Organização do Stash: Faça uma limpeza regular nos esconderijos.
  • git stash list seguido de git stash drop stash@{n}
• Refúgio temporário: Use os stashes para alterações temporárias, e não para alterações de longo prazo.

Armadilhas comuns do `git stash` que devem ser evitadas

• Evite acumular coisas em excesso: Depender excessivamente do estoque para mudanças importantes.
• Lembre-se de retirar do estoque: Esquecer de aplicar ou retirar os stashes.
  • git stash apply ou git stash pop
• Conscientização sobre o estoque: Perder a noção do que cada estoque contém.
  • git stash list para revisar os stashes
• Esclareça com comentários: Confusão nos stashes devido à falta de comentários nos stashes.
  • git stash save “Mensagem descritiva”

Ao utilizar o `git stash` em projetos em equipe

• Compartilhe seus achados: Comunique as alterações armazenadas caso elas afetem outras pessoas.
• Aprimoramento do fluxo de trabalho: Use os stashes para aprimorar seu fluxo de trabalho pessoal.
• Mantenha os arquivos em localização local: Evite enviar stashes para repositórios compartilhados, a menos que seja necessário criar um novo branch a partir de um stash para enviar as alterações locais ao repositório da maneira mais suave possível.

Solução de problemas comuns com o `git stash`

Resolução de conflitos entre aplicações do stash

• Problemas Conflitos ao aplicar um stash devido a alterações sobrepostas.
• Solução: Resolva manualmente os conflitos nos arquivos afetados e, em seguida, execute o comando `git add` e faça o commit.

Recuperando esconderijos perdidos

• Problemas Itens que caíram acidentalmente ou que estão faltando.
• Solução: Use o `git reflog` para localizar o hash do commit do stash perdido e, em seguida, reaplique-o com `git stash apply <hash-do-commit>`.

Como lidar com stashes no estado HEAD desanexado

• Problemas Aplicando stashes após trabalhar em um estado HEAD desanexado.
• Solução: Faça o checkout no branch desejado e, em seguida, aplique o stash usando o comando `git stash apply` ou `git stash pop`.

Como evitar a duplicação de itens armazenados

• Problemas Duplique os fios após aplicar, sem soltar.
• Solução: Depois de aplicar um stash, use o comando `git stash drop` para removê-lo, caso ele não seja mais necessário.

Armazenamento de arquivos não rastreados

Problema: o comando `git stash` não inclui arquivos não rastreados por padrão.

Solução: Use o comando `git stash –include-untracked` ou `git stash -u` para armazenar arquivos não rastreados.

Git stash, git commit, git reset e git stage: Quais são as diferenças?

Como já falamos sobre o `git stash`, vamos ver como ele difere de outros comandos do Git, como o commit, o reset e o staging de alterações.

Commit no Git

O `git commit` é um comando que permite aos desenvolvedores salvar as alterações feitas no código-fonte, armazenando-as no repositório local. Eles fazem isso para manter um instantâneo de um projeto em um determinado momento, de modo a terem uma referência que represente o estado atual do projeto, incluindo as alterações preparadas, a partir do momento em que estavam trabalhando nele. Para contextualizar, segue abaixo uma tabela com as diferenças entre eles:

Git reset

O `git reset` é um comando complementar ao `git stash` que permite gerenciar alterações em um repositório Git. Com esses dois comandos combinados, os desenvolvedores podem recuperar arquivos que estavam no backup e que haviam sido excluídos anteriormente e enviá-los de volta ao repositório. Mas o `git stash` e o `git commit` também apresentam diferenças, que você pode conferir na tabela abaixo:

Marcação no Git

A área de preparação do Git é usada para deixar as alterações prontas para serem confirmadas. O processo envolve adicionar as alterações à área de preparação, ou “índice”, permitindo que os desenvolvedores revisem as alterações feitas antes de realizarem um commit. A tabela abaixo mostra as principais diferenças entre o `git stash` e o `Git stage`:

Quer mudar de ramificação sem perder o progresso? Assista ao vídeo “ : como usar o stash do Git” em.

A prática de guardar coisas ajuda a cultivar bons hábitos de desenvolvimento

Salvar regularmente as alterações não confirmadas incentiva os desenvolvedores a manter uma base de código limpa e organizada, o que, por sua vez, reduz a probabilidade de conflitos e erros. É uma prática que, quando utilizada com critério, pode aumentar significativamente a eficiência e a eficácia gerais do gerenciamento do controle de versões.

Esse recurso não é apenas um simples comando entre a vasta gama de funcionalidades do Git; é uma ferramenta essencial para fluxos de trabalho de programação eficientes e flexíveis. Sua capacidade de deixar temporariamente de lado os trabalhos em andamento permite que os desenvolvedores mantenham um diretório de trabalho organizado e livre de arquivos desnecessários ( ), o que é essencial em ambientes complexos de desenvolvimento de software, onde o foco e a organização são fundamentais.

A versatilidade do `git stash` reside em sua simplicidade e na ampla variedade de cenários aos quais se adapta — desde mudanças rápidas de contexto até a experimentação de novos recursos sem interferir na base de código principal. Essa funcionalidade é especialmente útil em ambientes colaborativos, nos quais vários desenvolvedores contribuem para o mesmo projeto.

Os repositórios ajudam a garantir que o trabalho de cada desenvolvedor permaneça intacto e não seja afetado pelas alterações feitas por outros, promovendo assim uma colaboração mais harmoniosa e produtiva.

Seja você um programador iniciante que está começando a usar o Git ou um desenvolvedor experiente, a capacidade de utilizar o `git stash` com habilidade é uma habilidade inestimável no seu conjunto de ferramentas de desenvolvimento de software. Oferece uma maneira estratégica de lidar com alterações no código, se alinha bem às práticas eficazes de desenvolvimento e, em última análise, contribui para uma gestão de projetos ágil mais simplificada e .