<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

Git avançado: rebase, stash e reflog na prática

DA

7 min

Git avançado: rebase, stash e reflog na prática

Domine Git avançado: rebase para organizar commits, stash para trocar de tarefa e reflog para recuperar o que aparentemente se perdeu.

Neste artigo

O Git que a maioria usa no dia a dia é só a ponta: add, commit e push. Quando o histórico vira bagunça, o que salva é o Git avançado, e três comandos respondem por quase toda emergência: rebase para reorganizar, stash para guardar sem commitar e reflog para recuperar o que parecia perdido. Este guia explica os três com o risco de cada um.

Rebase reescreve a base de uma branch para alinhar commits a um histórico linear; stash guarda mudanças não commitadas para você trocar de tarefa; reflog é o diário do Git que registra tudo o que o repositório fez, permitindo recuperar trabalho. Antes de mergulhar, certifique-se do básico no quiz de Git e GitHub.

Quando o rebase faz sentido

O merge junta branches com um commit de junção; o rebase replanta os seus commits em cima da branch de destino, deixando o histórico em linha reta. Para atualizar a sua feature com o que mudou na main sem gerar bolinho de merge, o rebase é a escolha. A regra de segurança é nunca rebase de branch que já foi publicada, porque ele reescreve o histórico.

⚠️ Atenção: rebase no push (force push) reescreve commits que outros podem ter baixado. A prática segura é usar rebase só em branch local, antes de publicar. Publicou? Prefira merge.

Rebase na prática

Para alinhar a sua feature com a main, atualize primeiro a referência e depois replante seus commits em cima dela.

git fetch origin
git checkout minha-feature
git rebase origin/main

O Git pega os seus commits, guarda de lado, atualiza para a main e reaplica um por um. Se houver conflito, ele pausa e pede para resolver. Após resolver, você continua com git rebase --continue. O resultado é um histórico linear, mais fácil de ler em code review.

Stash: trocar de tarefa sem perder o fio

O stash guarda as mudanças não commitadas num espaço separado, sem criar commit. Você está no meio de uma alteração e precisa trocar para um bug urgente: stasha, troca de branch, resolve e volta. É o comando de quem trabalha com várias demandas ao mesmo tempo.

git stash                    # guarda as mudanças
git stash push -m "bug login"  # guarda com etiqueta
git stash list               # vê o que está guardado
git stash pop                # reaplica a última stash

O pop reaplica e remove da lista; o apply reaplica sem remover. A etiqueta no push evita o cenário de uma pilha de stashes sem saber o que é cada um, que é onde a ferramenta vira bagunça em vez de ajuda.

Reflog: o diário que recupera quase tudo

O reflog registra cada movimento do repositório nos últimos dias: commits, resets, checkouts e merges. Mesmo quando você apaga uma branch ou desfaz um commit na mão, o reflog guarda o histórico local do que aconteceu.

git reflog                 # lista o histórico de movimentos
git checkout HEAD@{2}      # volta para o estado de dois movimentos atrás

ℹ️ Info: o reflog é local e tem validade, não substitui backup. Ele salva de erro imediato, mas trabalho importante ainda precisa de commit e, idealmente, de push para o remoto.

Cherry-pick: levar um commit para outra branch

Tem hora que você precisa de um único commit em outra branch, sem levar o restante do trabalho que veio junto. O cherry-pick faz isso: escolhe um commit e aplica só ele no destino. É o caso do hotfix descoberto na branch errada, ou da feature que é preciso adiantar sem a base que a acompanha.

git checkout main
git cherry-pick a1b2c3d

O commit reaparece no destino com outro hash, porque o histórico muda. Use com critério: é uma operação pontual, não o substituto de merge ou rebase no fluxo regular. Em excesso, vira uma esteira de commits duplicados que ninguém rastreia.

Decidir o fluxo do time

Toda essa caixa de ferramentas só faz sentido dentro de um fluxo combinado. O time decide se integra por merge, se trilha por rebase e como trata branch publicada. Sem esse acordo, cada pessoa usa uma técnica e o histórico vira um emaranhado. A ferramenta certa na hora errada cria mais problema que resolve.

O fluxo começa em branch local e termina num pull request revisado. O Git avançado entra para manter a branch limpa antes da revisão e recuperar o deslize depois. O objetivo nunca é a técnica pela técnica, e sim um histórico que conte a história do projeto sem forçar quem chega depois a adivinhar.

Como desfazer cada tipo de erro

Desfazer no Git depende do estágio: arquivo ainda não adicionado, já adicionado, já commitado ou já publicado. Cada caso tem a ferramenta certa, e usar a errada é o que transforma um deslize em desastre. A regra é avançar do mais local para o que exige coordenação.

git checkout -- arquivo.txt      # descarta mudança não adicionada
git restore --staged arquivo.txt # remove do stage
git reset --soft HEAD~1          # desfaz o commit, mantém mudança
git revert a1b2c3d               # desfaz um commit público com novo commit

O reset age no histórico local; o revert cria um commit contrário, seguro para o que já foi publicado. A distinção entre os dois é a linha que separa conserto de caos: revert publica, reset reescreve. Decorar por cenário evita o reset em branch compartilhada que ninguém quer explicar depois.

Boas práticas de quem usa Git avançado

  • Commits pequenos e descritivos, uma ideia por commit, para o rebase ter significado.
  • Branch publicada não rebase; use merge para manter compatibilidade com o time.
  • Stash com etiqueta sempre que guardar algo além de uma única mudança.
  • Push frequente: o reflog local é a última linha, o remoto é a rede de segurança.

Essa disciplina se encaixa no fluxo maior de colaboração: quem organiza o histórico facilita o code review, e quem publica direito anda de mãos dadas com a entrega contínua, assunto que conecta com o pipeline de CI/CD. Para subir o projeto do jeito certo, veja também o passo a passo de publicar no GitHub.

Perguntas frequentes

Rebase ou merge, qual usar?

Rebase para branch local e histórico linear; merge para integrar trabalho publicado e preservar o histórico real. A escolha varia pelo fluxo do time, não pelo gosto isolado.

Perder commit é irreversível?

Na maioria das vezes não. O reflog guarda o movimento local por dias, então dá para recuperar o que um reset ou checkout parecia apagar. O limite é o período e a falta de push.

Como desfazer um stash errado?

Use git stash list para achar a entrada e git stash show -p stash@{n} para inspecionar antes de aplicar. A etiqueta na hora de guardar evita o erro na hora de recuperar.

Force push é sempre errado?

Em branch compartilhada, sim, reescreve histórico alheio. Em branch só sua e antes da revisão, pode ser necessário após um rebase. Coordene com o time antes de forçar qualquer coisa.

Produtos relacionados

Este conteúdo tem links de afiliado: se você comprar por eles, podemos receber uma comissão sem custo extra para você. A escolha dos produtos segue critérios próprios e não é influenciada por comissão.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Depois dessa formação...

Veja vagas em tecnologia →

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Atualizado em 06/10/2026 •

Ver perfil do autor

COMPARTILHAR