Mais de 200 comandos Git explicados em português, por situação: branches, remoto, stash, rebase e como desfazer commit, add, push e merge. Com busca.
Os comandos do Git que se usam de verdade, agrupados pela situação em que você está, e não em ordem alfabética. Busque por palavra (“desfazer”, “renomear branch”, “force”), filtre por grupo e copie o comando com um clique. Os que apagam trabalho levam um aviso de cuidado.
212 comandos em 11 grupos. Troque os marcadores entre < > pelo seu valor.
As situações mais comuns, com os comandos na ordem. Regra geral: o que já foi commitado quase sempre dá para recuperar; o que nunca foi commitado, não.
O commit some do histórico e as alterações dele voltam para o staging, prontas para ajustar e commitar de novo. Só para commit que ainda não foi enviado.
git reset --soft HEAD~1Remove o commit e mantém as alterações preparadas.
Volta o projeto ao estado do commit anterior, como se o último nunca tivesse existido.
git reset --hard HEAD~1Remove o commit e as alterações.
Cuidado: Apaga também o que não foi commitado. Na dúvida, use --soft.
Se o commit já foi enviado, o push seguinte precisa de --force-with-lease.
git commit --amend -m "nova mensagem"Substitui o último commit por outro igual, com a mensagem nova.
Evita o commit "esqueci um arquivo".
git add <arquivo>Prepara o arquivo que faltou.
git commit --amend --no-editRefaz o último commit com o arquivo, sem mudar a mensagem.
Tira o arquivo do staging. A alteração continua no disco.
git restore --staged <arquivo>Para um arquivo. Forma antiga: git reset HEAD <arquivo>.
git restore --staged .Para tudo o que está preparado na pasta atual.
O arquivo volta a ser como no último commit (ou como está no staging, se você já tinha dado git add).
git restore <arquivo>Descarta as alterações do arquivo. Forma antiga: git checkout -- <arquivo>.
Cuidado: Não tem volta: essa alteração nunca foi gravada pelo Git.
git restore .Descarta as alterações de todos os arquivos rastreados da pasta atual.
Cuidado: Perde todo o trabalho não commitado nesses arquivos.
git restore não toca em arquivos que o Git ainda não rastreia. Para esses, o comando é git clean.
git clean -ndPrimeiro simule: lista o que seria apagado.
git clean -fdApaga os arquivos e pastas não rastreados.
Cuidado: Apaga do disco, sem lixeira e sem reflog.
O jeito seguro, que serve para branch compartilhado: um commit novo que desfaz o antigo, sem reescrever o histórico.
git revert <commit>Cria o commit que desfaz o commit indicado. Para o último, use git revert HEAD.
git pushEnvia o revert normalmente.
Só em branch que é só seu (um branch de feature, por exemplo). Em branch compartilhado, use git revert.
git reset --hard HEAD~1Remove o commit localmente.
Cuidado: Apaga também o que não foi commitado.
git push --force-with-leaseSobrescreve o branch remoto, desde que ninguém tenha enviado nada depois do seu último fetch.
Cuidado: Reescreve o histórico remoto. Se o commit continha uma senha ou chave, considere-a vazada e troque-a.
Você deu merge, vieram conflitos e você quer desistir.
git merge --abortVolta tudo para como estava antes do merge.
Vale logo depois do merge, antes de qualquer outro reset ou rebase, porque ORIG_HEAD guarda a posição anterior. Se o merge criou um commit de merge, git reset --hard HEAD~1 dá no mesmo.
git reset --hard ORIG_HEADVolta o branch para antes do merge.
Cuidado: Descarta as alterações não commitadas.
Cria um commit que desfaz o que o merge trouxe. Atenção: para mesclar o mesmo branch de novo no futuro, será preciso reverter esse revert.
git revert -m 1 <commit-de-merge>-m 1 mantém o lado do branch que recebeu o merge.
git pushEnvia o revert.
Durante o rebase, basta abortar. Depois de concluído, o reflog mostra onde o branch estava antes.
git rebase --abortCom o rebase ainda em andamento.
git reflogCom o rebase concluído: ache a linha anterior ao início do rebase (rebase (start)).
git reset --hard HEAD@{n}Troque n pelo número dessa linha no reflog.
Cuidado: Descarta as alterações não commitadas.
Commits não somem na hora: o reflog guarda as posições do HEAD por pelo menos 30 dias, no padrão. O que nunca foi commitado não pode ser recuperado.
git reflogAche o hash do commit em que você estava antes do reset.
git reset --hard <commit>Volta o branch para esse commit.
Cuidado: Descarta as alterações não commitadas atuais.
O branch é só um ponteiro. Achando o último commit dele, é só criar o ponteiro de novo.
git reflogProcure o último commit feito no branch apagado.
git branch <nome> <commit>Recria o branch apontando para esse commit.
Você commitou no main e devia ter sido em um branch novo. Ainda sem push.
git branch <novo-branch>Cria o branch novo apontando para o commit, sem sair do lugar.
git reset --hard HEAD~1Tira o commit do branch errado.
Cuidado: Commite ou guarde (git stash) as outras alterações antes: o que não foi commitado é descartado.
git switch <novo-branch>Vai para o branch novo, onde o commit está a salvo.
Ajustes feitos uma vez por máquina (--global) ou por repositório (sem --global).
git --versionMostra a versão do Git instalada.
git config --global user.name "Seu Nome"Define o nome que aparece como autor dos seus commits.
git config --global user.email "[email protected]"Define o e-mail gravado nos seus commits.
git config --global init.defaultBranch mainFaz o git init criar o branch inicial com o nome main (Git 2.28 ou mais novo).
git config --global core.editor "code --wait"Usa o VS Code como editor de mensagens de commit e de rebase interativo.
git config --global pull.rebase trueFaz o git pull reaplicar seus commits sobre os do remoto (rebase) em vez de criar um commit de merge.
git config --global push.autoSetupRemote trueNo primeiro push de um branch novo, cria o branch remoto e o vínculo sozinho, sem precisar de -u (Git 2.37 ou mais novo).
git config --global core.autocrlf trueNo Windows: converte quebras de linha para CRLF ao baixar e para LF ao gravar no repositório.
git config --global core.autocrlf inputNo Linux e no macOS: mantém LF e converte CRLF para LF ao gravar no repositório.
git config --global rerere.enabled trueFaz o Git lembrar como você resolveu um conflito e repetir a solução quando o mesmo conflito voltar.
git config --global alias.st "status -sb"Cria um atalho: depois disso, git st equivale a git status -sb.
git config --list --show-originLista todas as configurações em vigor e o arquivo de onde cada uma vem.
git config user.emailMostra o valor atual de uma configuração (aqui, o e-mail).
git config --global --unset core.editorRemove uma configuração global.
git config --global --editAbre o arquivo de configuração global no editor.
git help <comando>Abre o manual do comando. Para um resumo no terminal, use git <comando> -h.
Criar um repositório novo ou baixar um que já existe.
git initTransforma a pasta atual em um repositório Git (cria a pasta oculta .git).
git init -b mainCria o repositório já com o branch inicial chamado main (Git 2.28 ou mais novo).
git init <pasta>Cria a pasta, se não existir, e inicia um repositório dentro dela.
git clone <url>Baixa o repositório inteiro, com todo o histórico, para uma pasta com o nome do projeto.
git clone <url> <pasta>Clona para a pasta que você escolher.
git clone --depth 1 <url>Clone raso: baixa só o commit mais recente. Mais rápido em repositórios grandes, mas sem o histórico.
git clone -b <branch> --single-branch <url>Clona apenas um branch, em vez de todos.
git remote add origin <url>Liga um repositório criado com git init ao repositório remoto (GitHub, GitLab etc.).
git push -u origin mainPrimeiro envio: manda o branch main e grava o vínculo com origin/main.
git statusMostra o branch atual, o que foi alterado, o que está preparado para commit e o que não é rastreado.
git status -sbVersão curta do status: uma linha por arquivo, mais a situação do branch em relação ao remoto.
O ciclo básico: alterar, preparar (add), gravar (commit), enviar (push).
git add <arquivo>Prepara o arquivo para o próximo commit (coloca na área de staging).
git add .Prepara tudo o que mudou na pasta atual e nas subpastas, incluindo arquivos novos e apagados.
git add -APrepara todas as mudanças do repositório inteiro, não importa em que pasta você esteja.
git add -uPrepara só alterações e exclusões de arquivos já rastreados; ignora arquivos novos.
git add -pMostra cada trecho alterado e pergunta se entra no commit. Bom para separar mudanças em commits diferentes.
git commit -m "mensagem"Grava um commit com o que está preparado.
git commit -am "mensagem"Prepara e grava de uma vez as alterações de arquivos já rastreados. Arquivos novos ficam de fora.
git commitAbre o editor para escrever uma mensagem longa (título, linha em branco, corpo).
git commit --allow-empty -m "mensagem"Cria um commit sem alteração nenhuma. Útil para disparar de novo uma pipeline de CI.
git diffMostra o que mudou e ainda não foi preparado com git add.
git diff --stagedMostra o que já está preparado e vai entrar no próximo commit. --cached é sinônimo.
git diff --statResumo do diff: arquivos alterados e quantidade de linhas a mais e a menos.
git diff HEADMostra tudo o que mudou desde o último commit, preparado ou não.
git rm <arquivo>Apaga o arquivo do disco e já prepara a exclusão para o próximo commit.
git rm --cached <arquivo>Para de rastrear o arquivo, mas mantém a cópia no seu disco. É o que se usa depois de incluí-lo no .gitignore.
git mv <antigo> <novo>Renomeia ou move um arquivo e já prepara a mudança.
git pullBaixa as novidades do remoto e integra ao branch atual (fetch seguido de merge ou rebase).
git pushEnvia os commits do branch atual para o remoto.
git showMostra o último commit: autor, data, mensagem e diff.
git switch (Git 2.23, de 2019) é o comando atual para trocar de branch; git checkout continua funcionando.
git branchLista os branches locais; o atual aparece com asterisco.
git branch -aLista os branches locais e os remotos conhecidos.
git branch -vvLista os branches com o último commit e o branch remoto vinculado, indicando quantos commits está à frente ou atrás.
git branch --show-currentMostra só o nome do branch atual.
git switch <branch>Troca para o branch. Se ele só existe no remoto, cria o branch local já vinculado.
Forma antiga: git checkout <branch>
git switch -c <novo-branch>Cria um branch a partir do commit atual e já troca para ele.
Forma antiga: git checkout -b <novo-branch>
git switch -c <novo-branch> <commit>Cria o branch a partir de outro ponto: um commit, uma tag ou outro branch (por exemplo, origin/main).
Forma antiga: git checkout -b <novo-branch> <commit>
git switch -Volta para o branch em que você estava antes.
Forma antiga: git checkout -
git switch --detach <commit>Vai para um commit específico sem estar em branch nenhum (HEAD destacado), para olhar ou testar uma versão antiga.
Forma antiga: git checkout <commit>
git branch <novo-branch>Cria o branch, mas continua no atual.
git branch -m <novo-nome>Renomeia o branch atual.
git branch -m <antigo> <novo>Renomeia outro branch.
git branch -d <branch>Apaga o branch local. O Git recusa se houver commits que ainda não foram mesclados.
git branch -D <branch>Apaga o branch local à força, mesmo com commits não mesclados.
Cuidado: Os commits que só existiam nesse branch ficam sem referência. Dá para recuperar pelo git reflog por um tempo, mas não conte com isso.
git branch --mergedLista os branches já mesclados no atual, que em geral podem ser apagados.
git branch --no-mergedLista os branches com trabalho que ainda não foi mesclado no atual.
git branch -u origin/<branch>Vincula o branch atual a um branch remoto, para pull e push funcionarem sem argumentos.
git branch -rLista só os branches remotos conhecidos.
git branch --sort=-committerdateLista os branches do mais recentemente alterado para o mais antigo.
Sincronizar com GitHub, GitLab, Bitbucket ou qualquer outro servidor. origin é o nome padrão do remoto.
git remote -vLista os remotos configurados e suas URLs.
git remote add <nome> <url>Adiciona um remoto, como o upstream de um fork.
git remote set-url origin <url>Troca a URL do remoto, por exemplo de HTTPS para SSH ou depois de renomear o repositório.
git remote rename <antigo> <novo>Renomeia um remoto.
git remote remove <nome>Remove o remoto da configuração local. Não apaga nada no servidor.
git remote show originMostra detalhes do remoto: branches, vínculos e o que está desatualizado.
git fetchBaixa as novidades do remoto sem mexer nos seus arquivos nem nos seus branches.
git fetch --all --pruneBaixa de todos os remotos e remove as referências a branches que já foram apagados no servidor.
git fetch origin <branch>Baixa só um branch do remoto.
git pull --rebaseBaixa as novidades e reaplica seus commits locais por cima, mantendo o histórico em linha reta.
git pull --ff-onlySó atualiza se for possível avançar sem merge; se os históricos divergiram, para e avisa.
git pull origin mainTraz o main do remoto para dentro do branch atual.
git push -u origin <branch>Envia o branch pela primeira vez e grava o vínculo com o remoto.
git push -u origin HEADO mesmo, sem digitar o nome: envia o branch atual com o mesmo nome no remoto.
git push origin <local>:<remoto>Envia um branch local para um branch remoto de nome diferente.
git push origin --delete <branch>Apaga o branch no servidor.
Cuidado: Apaga o branch para todo mundo que usa o repositório. Confira o nome antes.
git push --force-with-leasePush forçado com trava: só sobrescreve o remoto se ninguém tiver enviado nada desde o seu último fetch.
Cuidado: Reescreve o histórico do branch remoto. Use só em branch seu, depois de amend ou rebase, e nunca em branch compartilhado.
git push --forceSobrescreve o branch remoto com o seu, sem conferir nada.
Cuidado: Apaga sem aviso os commits que outras pessoas enviaram. Prefira --force-with-lease.
git remote prune originRemove as referências locais a branches remotos que já não existem no servidor.
git ls-remote --heads originLista os branches que existem no servidor, consultando-o diretamente.
git remote set-head origin -aAtualiza qual é o branch padrão do remoto (origin/HEAD), útil depois de trocar master por main no servidor.
git restore (Git 2.23) trata dos arquivos; git reset move o branch; git revert cria um commit que desfaz outro.
git restore <arquivo>Descarta as alterações não preparadas do arquivo e volta à versão que está no staging (ou no último commit).
Forma antiga: git checkout -- <arquivo>
Cuidado: A alteração descartada nunca foi gravada pelo Git: não há como recuperar.
git restore .Descarta as alterações não preparadas de todos os arquivos rastreados da pasta atual.
Forma antiga: git checkout -- .
Cuidado: Perde todo o trabalho não commitado nesses arquivos, sem volta.
git restore --staged <arquivo>Desfaz o git add: tira o arquivo do staging e mantém a alteração no disco.
Forma antiga: git reset HEAD <arquivo>
git restore --staged .Tira do staging tudo o que estava preparado na pasta atual, sem perder as alterações.
Forma antiga: git reset -- .
git restore --staged --worktree <arquivo>Volta o arquivo ao estado do último commit, no staging e no disco.
Forma antiga: git checkout HEAD -- <arquivo>
Cuidado: Descarta as alterações do arquivo, preparadas ou não.
git restore --source=<commit> <arquivo>Traz para o disco a versão que o arquivo tinha em outro commit, sem mudar de branch.
Forma antiga: git checkout <commit> -- <arquivo>
Cuidado: Sobrescreve a versão atual do arquivo no disco.
git commit --amend -m "nova mensagem"Troca a mensagem do último commit.
Cuidado: Cria um commit novo no lugar do antigo. Se o antigo já foi enviado, será preciso push forçado.
git commit --amend --no-editInclui no último commit o que está preparado, mantendo a mensagem. Serve para o arquivo que você esqueceu.
Cuidado: Reescreve o último commit. Evite se ele já foi enviado para um branch compartilhado.
git reset --soft HEAD~1Desfaz o último commit e deixa as alterações dele preparadas (no staging).
git reset HEAD~1Desfaz o último commit e deixa as alterações nos arquivos, sem preparar (modo --mixed, o padrão).
git reset --hard HEAD~1Desfaz o último commit e apaga as alterações dele.
Cuidado: Apaga também qualquer alteração não commitada em arquivos rastreados. O commit ainda pode ser achado no git reflog; o que não foi commitado, não.
git reset --hardDescarta todas as alterações não commitadas em arquivos rastreados, preparadas ou não.
Cuidado: Não tem volta para o que não foi commitado. Arquivos não rastreados não são afetados.
git reset --hard origin/mainDeixa o branch atual idêntico ao main do remoto, descartando commits e alterações locais.
Cuidado: Rode git fetch antes. Tudo o que é só local nesse branch é descartado.
git reset --hard ORIG_HEADVolta o branch para onde estava antes do último merge, rebase ou reset.
Cuidado: Descarta as alterações não commitadas. ORIG_HEAD muda a cada merge, rebase ou reset.
git revert <commit>Cria um commit novo que desfaz as mudanças do commit indicado. É a forma segura de desfazer algo que já foi enviado.
git revert HEADCria um commit que desfaz o último commit.
git revert --no-commit <antigo>..<recente>Desfaz vários commits de uma vez (os que vêm depois de <antigo>, até <recente>) e deixa tudo preparado para um único commit.
git revert -m 1 <commit-de-merge>Desfaz um merge já enviado, mantendo o lado do branch que recebeu o merge (o pai 1).
git clean -nSimulação: mostra quais arquivos não rastreados seriam apagados, sem apagar nada. Acrescente -d para incluir pastas.
git clean -fdApaga arquivos e pastas não rastreados.
Cuidado: Apaga do disco arquivos que o Git nunca guardou: não há como recuperar. Rode git clean -nd antes para ver a lista.
git clean -fdxApaga também os arquivos ignorados pelo .gitignore (node_modules, builds, .env).
Cuidado: Leva junto arquivos de configuração local, como .env. Confira antes com git clean -ndx.
git clean -iLimpeza interativa: você escolhe o que apagar.
Guardar alterações inacabadas para trocar de branch ou puxar novidades, e retomar depois.
git stashGuarda as alterações de arquivos rastreados e limpa a pasta de trabalho. Equivale a git stash push.
git stash push -m "descrição"Guarda com uma descrição, para achar depois na lista.
git stash -uGuarda também os arquivos novos, ainda não rastreados.
git stash -aGuarda tudo, inclusive os arquivos ignorados.
git stash push -- <arquivo>Guarda só as alterações do arquivo (ou pasta) indicado.
git stash -pEscolhe, trecho por trecho, o que vai para o stash.
git stash push --stagedGuarda só o que está preparado no staging (Git 2.35 ou mais novo).
git stash listLista os stashes guardados: stash@{0} é o mais recente.
git stash show -pMostra o diff do stash mais recente.
git stash show -p stash@{1}Mostra o diff de um stash específico.
git stash popReaplica o stash mais recente e o remove da lista. Se der conflito, o stash é mantido.
git stash applyReaplica o stash mais recente e o mantém na lista.
git stash apply stash@{2}Reaplica um stash específico.
git stash pop --indexReaplica restaurando também o que estava preparado no staging.
git stash branch <novo-branch>Cria um branch a partir do commit em que o stash foi feito, aplica o stash nele e o remove da lista.
git restore --source=stash@{0} -- <arquivo>Traz um único arquivo de dentro do stash, sem aplicar o resto.
Cuidado: Sobrescreve a versão atual do arquivo no disco.
git stash drop stash@{0}Apaga um stash da lista.
Cuidado: O conteúdo do stash apagado é difícil de recuperar.
git stash clearApaga todos os stashes.
Cuidado: Apaga tudo de uma vez, sem confirmação.
Consultar o que aconteceu: quem mudou, quando e por quê.
git logLista os commits do mais recente para o mais antigo. Saia com a tecla q.
git log --onelineUm commit por linha: hash curto e título.
git log --oneline --graph --decorate --allDesenha a árvore de todos os branches e tags no terminal.
git log -n 5Mostra só os 5 commits mais recentes.
git log --statLista os commits com os arquivos alterados em cada um.
git log -p <arquivo>Histórico do arquivo com o diff de cada commit.
git log --follow <arquivo>Histórico do arquivo atravessando renomeações.
git log --author="Nome"Só os commits de um autor (casa com parte do nome ou do e-mail).
git log --since="2 weeks ago"Commits das últimas duas semanas. Também aceita datas, como --since="2026-01-01", e --until.
git log --grep="texto"Commits cuja mensagem contém o texto.
git log -S "texto"Commits que acrescentaram ou removeram o texto no código. Ótimo para descobrir quando uma função sumiu.
git log main..<branch>Commits que estão no branch e ainda não estão no main.
git log origin/main..HEADCommits locais que ainda não foram enviados para o main do remoto.
git log --diff-filter=D --name-onlyLista os commits que apagaram arquivos, com o nome de cada um.
git log --all --full-history -- <arquivo>Acha os commits que mexeram em um arquivo, mesmo que ele já tenha sido apagado.
git show <commit>Mostra a mensagem e o diff de um commit.
git show --stat <commit>Mostra a mensagem e só a lista de arquivos alterados.
git show <commit>:<caminho/arquivo>Mostra o conteúdo que o arquivo tinha naquele commit.
git diff <commit-a> <commit-b>Diferença entre dois commits, branches ou tags.
git diff main...<branch>Com três pontos: só o que o branch mudou desde que se separou do main. É o diff que um pull request mostra.
git diff --name-only <commit-a> <commit-b>Só os nomes dos arquivos que diferem.
git blame <arquivo>Mostra, linha por linha, o commit e o autor da última alteração.
git blame -L 10,20 <arquivo>O mesmo, só para as linhas 10 a 20.
git shortlog -snConta os commits por autor, do maior para o menor.
git grep "texto"Procura o texto nos arquivos rastreados (mais rápido que um grep comum e respeita o .gitignore).
git rev-parse --short HEADMostra o hash curto do commit atual.
git describe --tagsDescreve o commit atual pela tag mais próxima, como v1.2.0-3-gabc1234.
Marcar versões. Tags anotadas (-a) guardam autor, data e mensagem e são as indicadas para releases.
git tagLista as tags.
git tag -l "v1.*"Lista as tags que casam com o padrão.
git tag v1.0.0Cria uma tag leve (só um nome para o commit atual).
git tag -a v1.0.0 -m "Versão 1.0.0"Cria uma tag anotada no commit atual.
git tag -a v1.0.0 <commit> -m "Versão 1.0.0"Cria a tag anotada em um commit antigo.
git show v1.0.0Mostra os dados da tag e o commit marcado.
git push origin v1.0.0Envia uma tag para o remoto. O git push comum não envia tags.
git push origin --tagsEnvia todas as tags locais.
git push --follow-tagsEnvia os commits e, junto, as tags anotadas que apontam para eles.
git fetch --tagsBaixa todas as tags do remoto.
git tag -d v1.0.0Apaga a tag local.
git push origin :refs/tags/v1.0.0Apaga a tag no remoto.
Cuidado: Quem já baixou a tag continua com ela. Evite reaproveitar o nome de uma versão publicada.
git switch --detach v1.0.0Abre o código exatamente como estava na tag (HEAD destacado).
Forma antiga: git checkout v1.0.0
git switch -c <branch> v1.0.0Cria um branch a partir da tag, para corrigir uma versão antiga.
Merge junta dois históricos; rebase reaplica seus commits sobre outra base, reescrevendo-os.
git merge <branch>Traz os commits do branch indicado para o branch atual.
git merge --no-ff <branch>Cria sempre um commit de merge, mesmo quando daria para só avançar o branch. Deixa a origem do trabalho registrada no histórico.
git merge --ff-only <branch>Só mescla se for possível avançar sem criar commit de merge; se não, para.
git merge --squash <branch>Traz todas as mudanças do branch como alterações preparadas, sem commitar. Você grava um commit só.
git merge --abortCancela um merge com conflito e volta ao estado anterior.
git merge --continueConclui o merge depois de resolver os conflitos e dar git add.
git rebase mainReaplica os commits do branch atual sobre o topo do main.
Cuidado: Reescreve os commits (novos hashes). Não faça em commits que outras pessoas já usam.
git rebase -i HEAD~3Rebase interativo dos 3 últimos commits: reordenar, juntar (squash), editar mensagem (reword) ou remover (drop).
Cuidado: Reescreve o histórico. Se os commits já foram enviados, o push seguinte precisa de --force-with-lease.
git rebase -i --rootRebase interativo desde o primeiro commit do repositório.
Cuidado: Reescreve o histórico inteiro do branch.
git rebase --continueSegue com o rebase depois de resolver um conflito e dar git add.
git rebase --skipPula o commit que está dando conflito.
Cuidado: As mudanças desse commit ficam de fora do resultado.
git rebase --abortCancela o rebase e volta o branch para onde estava antes de começar.
git rebase --onto <nova-base> <base-antiga> <branch>Move os commits do branch que vêm depois de <base-antiga> para cima de <nova-base>. Serve para tirar um branch de cima de outro.
Cuidado: Reescreve os commits do branch.
git commit --fixup=<commit>Cria um commit de correção marcado para ser fundido ao commit indicado.
git rebase -i --autosquash mainRebase interativo que já posiciona os commits fixup! junto dos commits que eles corrigem.
Cuidado: Reescreve o histórico do branch.
git pull --rebase origin mainAtualiza o branch atual com o main do remoto usando rebase em vez de merge.
Cuidado: Reescreve seus commits locais. Depois de um push anterior, será preciso --force-with-lease.
git cherry-pick <commit>Copia um commit de outro branch para o branch atual, como um commit novo.
git cherry-pick <antigo>^..<recente>Copia uma sequência de commits, incluindo o <antigo>.
git cherry-pick -n <commit>Aplica as mudanças do commit sem commitar, deixando-as preparadas.
git cherry-pick --continueSegue com o cherry-pick depois de resolver um conflito.
git cherry-pick --abortCancela o cherry-pick em andamento.
Conflitos, commits perdidos, arquivos que não deveriam estar no repositório e caça a bugs.
git diff --name-only --diff-filter=ULista os arquivos que ainda estão em conflito.
git restore --ours <arquivo>No conflito, fica com a versão do branch atual. Depois, marque como resolvido com git add. Em um rebase os lados se invertem: --ours é a base e --theirs são os seus commits.
Forma antiga: git checkout --ours <arquivo>
Cuidado: Descarta por inteiro as mudanças do outro lado nesse arquivo.
git restore --theirs <arquivo>No conflito, fica com a versão que está chegando (o outro branch, em um merge). Depois, git add.
Forma antiga: git checkout --theirs <arquivo>
Cuidado: Descarta por inteiro as mudanças do seu lado nesse arquivo.
git mergetoolAbre a ferramenta visual configurada para resolver os conflitos arquivo por arquivo.
git reflogMostra por onde o HEAD passou: commits, resets, rebases, trocas de branch. É por aqui que se recupera um commit "perdido".
git reset --hard HEAD@{1}Volta o branch para a posição anterior registrada no reflog (por exemplo, antes de um reset ou rebase errado).
Cuidado: Descarta as alterações não commitadas. Confira a posição certa com git reflog antes.
git branch <nome> <commit>Recria um branch apagado apontando para o commit encontrado no reflog.
git fsck --lost-foundProcura commits e objetos sem referência, última tentativa quando o reflog não ajuda.
git restore --source=<commit>~1 -- <arquivo>Recupera um arquivo apagado: <commit> é o commit que o apagou, e ~1 pega a versão imediatamente anterior.
git check-ignore -v <arquivo>Mostra qual regra de qual .gitignore está ignorando o arquivo.
git rm -r --cached .Tira tudo do índice, mantendo os arquivos no disco. Seguido de git add . e de um commit, faz o .gitignore valer para arquivos que já eram rastreados.
Cuidado: Confira o git status antes de commitar: o que não for readicionado sai do repositório no próximo commit.
git update-index --skip-worktree <arquivo>Faz o Git ignorar suas alterações locais em um arquivo rastreado (uma configuração local, por exemplo). Desfaça com --no-skip-worktree.
git commit --amend --reset-author --no-editCorrige o autor do último commit depois de acertar user.name e user.email.
Cuidado: Reescreve o último commit.
git branch -m master mainRenomeia o branch local master para main.
git config --global --add safe.directory <caminho>Resolve o erro "detected dubious ownership", que aparece quando a pasta pertence a outro usuário do sistema.
git bisect startComeça uma busca binária pelo commit que introduziu um bug.
git bisect badMarca o commit atual como defeituoso.
git bisect good <commit>Marca um commit antigo em que tudo funcionava. O Git passa a escolher commits no meio do caminho para você testar e marcar como good ou bad.
git bisect resetEncerra o bisect e volta para o branch em que você estava.
git worktree add <pasta> <branch>Abre outro branch em uma segunda pasta, sem precisar de stash nem de outro clone.
git worktree listLista as pastas de trabalho ligadas ao repositório.
git worktree remove <pasta>Remove uma pasta de trabalho extra. O Git recusa se houver alterações não commitadas nela.
git gcFaz a faxina do repositório: compacta objetos e remove o que já expirou.
git count-objects -vHMostra quanto espaço o repositório ocupa em disco.
< e > é para trocar: <arquivo>, <branch>, <commit>, <url>. Em git switch <branch>, digite git switch main, sem os sinais.<commit> aceita o hash (completo ou os primeiros 7 caracteres), um branch, uma tag ou uma referência relativa.HEAD é o commit em que você está. HEAD~1 é o anterior, HEAD~3 é três commits atrás.origin é o apelido padrão do repositório remoto, e origin/main é a cópia local do branch main que está no servidor, atualizada a cada git fetch.git reset --hard 'HEAD@{1}' e git stash apply 'stash@{2}'. Sem aspas, o PowerShell interpreta as chaves e o comando falha.Quase toda confusão com add, restore e reset some quando se entende que o Git trabalha com três lugares:
| Área | O que é | Como entra | Como sai |
|---|---|---|---|
| Pasta de trabalho | Os arquivos no seu disco | Você edita | git restore <arquivo> descarta |
| Staging (índice) | O rascunho do próximo commit | git add | git restore --staged <arquivo> |
| Histórico | Os commits gravados | git commit | git reset ou git revert |
git diff compara a pasta de trabalho com o staging. git diff --staged compara o staging com o último commit.
Até 2019, git checkout fazia duas coisas sem relação entre si: trocava de branch e descartava alterações de arquivos. O Git 2.23 (agosto de 2019) separou as funções em dois comandos:
| Tarefa | Comando atual | Forma antiga |
|---|---|---|
| Trocar de branch | git switch main | git checkout main |
| Criar branch e trocar | git switch -c nova | git checkout -b nova |
| Descartar alteração | git restore arquivo.txt | git checkout -- arquivo.txt |
| Tirar do staging | git restore --staged arquivo.txt | git reset HEAD arquivo.txt |
As formas antigas continuam funcionando e aparecem em muito tutorial. Esta cola mostra a atual e cita a antiga logo abaixo, para você reconhecer as duas.
Os três modos movem o branch para o commit indicado. A diferença é o que fazem com as alterações dos commits que ficaram para trás:
| Modo | Staging | Arquivos no disco | Resultado |
|---|---|---|---|
--soft | mantém | mantém | Alterações ficam preparadas para um novo commit |
--mixed (padrão) | limpa | mantém | Alterações ficam nos arquivos, sem add |
--hard | limpa | sobrescreve | Alterações são descartadas |
Só o --hard destrói trabalho, e destrói também o que você ainda não tinha commitado.
git reset apaga commits do histórico do branch. Use em commits que ainda não foram enviados.git revert cria um commit novo que desfaz outro. O histórico só cresce, então é seguro em branch compartilhado e em commit que já foi para o remoto.Se você fez reset em algo que já tinha enviado, o git push normal será recusado. O push forçado resolve, mas reescreve o remoto: faça isso só em branch que é só seu.
git push --force substitui o branch remoto pelo seu, sem olhar o que há lá. Se um colega enviou commits depois do seu último fetch, eles somem sem aviso.
git push --force-with-lease faz a mesma coisa com uma trava: só sobrescreve se o branch remoto ainda estiver no ponto que o seu Git conhece. Se alguém enviou algo, o push é recusado e você tem a chance de olhar. Um detalhe: ferramentas que rodam git fetch sozinhas em segundo plano atualizam esse ponto e enfraquecem a trava.
A regra prática: rebase à vontade em commits que só existem na sua máquina ou em um branch só seu; nunca em commits que outras pessoas já baixaram.
git reflog lista todas as posições por onde o HEAD passou, inclusive commits “apagados” por reset --hard, por um rebase ou junto com um branch. Ache o hash e volte com git reset --hard <commit> ou recrie o branch com git branch <nome> <commit>.
Duas limitações importantes: o reflog é local (não vai para o remoto nem vem no clone) e expira. Por padrão, entradas de commits que já não fazem parte do branch são mantidas por 30 dias, e as demais por 90. E ele só conhece o que foi commitado: alteração descartada com git restore, git reset --hard ou git clean antes de qualquer commit não volta.
git switch e git restore (2.23), git init -b (2.28), git stash push --staged (2.35), push.autoSetupRemote (2.37). Confira a sua com git --version.git log --grep e git grepSe ainda não enviou: git reset --soft HEAD~1 desfaz o commit e mantém as alterações preparadas. Para descartar também as alterações, git reset --hard HEAD~1. Se o commit já foi enviado para um branch compartilhado, use git revert HEAD, que cria um commit desfazendo o anterior.
git restore <arquivo> (ou, na forma antiga, git checkout -- <arquivo>). Se o arquivo já estava no staging, rode antes git restore --staged <arquivo>, ou use git restore --staged --worktree <arquivo> para fazer as duas coisas. A alteração descartada não pode ser recuperada.
git fetch só baixa as novidades do remoto e atualiza origin/main e os demais branches remotos; seus arquivos não mudam. git pull faz o fetch e, em seguida, integra as novidades ao branch atual, por merge ou por rebase, conforme a configuração.
Para commits, git reflog mostra as posições anteriores do HEAD. Para um stash removido com drop, o reflog do HEAD não ajuda; a tentativa é git fsck --lost-found, que lista objetos sem referência, e nem sempre dá certo. Por isso git stash drop e git stash clear aparecem com aviso.
Não. Mesmo com o commit removido do branch por push forçado, ele pode continuar acessível no servidor, em forks e em clones de outras pessoas. Trate a senha ou a chave como vazada e troque-a imediatamente; depois cuide da limpeza do histórico.
Rodados na raiz do repositório, fazem o mesmo. A diferença aparece em uma subpasta: git add . prepara só o que mudou dali para baixo, e git add -A prepara as mudanças do repositório inteiro.