Guide
O Guia rápido de comandos Git é uma tabela pronta para usar: são 149 comandos divididos em onze cenários — configuração inicial, commits do dia a dia, branches, merge e rebase, desfazer e reverter, colaboração remota, stash, tags, submódulos e worktrees, histórico e solução de problemas, e ignore e atributos. Cada linha traz uma explicação curta, um exemplo que dá para colar no terminal e um rótulo de risco em dois níveis, “Aviso” e “Perigo” — comandos que descartam alterações não commitadas ou reescrevem histórico compartilhado saltam aos olhos.
Atualizado em 2026-09-094 sources10 min read
O Guia rápido de comandos Git é uma tabela pronta para usar: são 149 comandos divididos em onze cenários — configuração inicial, commits do dia a dia, branches, merge e rebase, desfazer e reverter, colaboração remota, stash, tags, submódulos e worktrees, histórico e solução de problemas, e ignore e atributos. Cada linha traz uma explicação curta, um exemplo que dá para colar no terminal e um rótulo de risco em dois níveis, “Aviso” e “Perigo” — comandos que descartam alterações não commitadas ou reescrevem histórico compartilhado saltam aos olhos.
Ele serve para três momentos: você lembra o que quer fazer, mas esqueceu como se escreve o comando (busque “desfazer commit”, “excluir branch remota”); você conhece o comando, mas não tem certeza se ele vai apagar algo (leia o nível de risco e as observações); e você está começando no Git e quer entender o que add, commit e push movem de um lugar para o outro (veja o diagrama das quatro áreas no topo e os diagramas de operação mais abaixo).
No fim da página há um terminal Git simulado que roda só na memória: são mais de 30 subcomandos comuns, com o grafo de commits à direita mudando em tempo real a cada comando, além de 10 níveis de prática, do “primeiro commit” até “resolver um conflito de merge”. Ele não é o Git de verdade e nunca acessa o seu computador nem a rede, mas a semântica segue o manual oficial, então o treino vale para a máquina real.
Digite “desfazer commit” na caixa de busca e aparecem estas linhas do grupo “Desfazer e reverter” (trecho):
Concluindo o nível 4, “desfazer o último commit mantendo as alterações”, no terminal simulado:
git reset --soft HEAD~1 desfaz o último commit e mantém as alterações na área de staging Aviso
git reset HEAD~1 desfaz o último commit e devolve as alterações para a árvore de trabalho, sem staging
git reset --hard <commit> ponteiro da branch, índice e árvore de trabalho voltam ao commit Perigo
git revert <commit> cria um novo commit que desfaz a alteração; o histórico não muda e o push é segurouser@toolun-lab:~/project (main)$ git log --oneline
7f3a1c2 (HEAD -> main) wip: commit bagunçado
2b9e0d4 init: add README
user@toolun-lab:~/project (main)$ git reset --soft HEAD~1
HEAD agora está em 2b9e0d4 init: add README
--soft: move só o ponteiro da branch; índice e árvore de trabalho são mantidos (o conteúdo do commit desfeito fica em staging)
Dica: o commit descartado 7f3a1c2 ainda pode ser recuperado com git reflog
user@toolun-lab:~/project (main)$ git status -s
A app.js
A secret.env
✔ Concluído: desfazer o último commit, mantendo as alterações.Quase todo comando Git pode ser lido como “mover conteúdo de uma área para outra”. A árvore de trabalho são os arquivos que você vê e edita; o índice (staging area) é a lista do que o próximo commit vai conter; o repositório local (.git) guarda todos os commits; o repositório remoto é o mesmo conjunto em outra máquina.
Com esse desenho em mente, muitas dúvidas de “como desfazer” têm uma resposta única: mudou algo que ainda não passou por add — recupere com git restore <file>; fez add e não quer commitar — git restore --staged; commitou e quer voltar — git reset; já fez push — só git revert, que acrescenta um commit inverso, é seguro.
Um objeto de commit registra: o snapshot de toda a árvore de diretórios (não um diff), o id dos commits-pai, autor e data, e a mensagem. Isso tudo é resumido por SHA-1 (repositórios novos podem usar SHA-256) até chegar ao id do commit, então qualquer mudança — mesmo um caractere na mensagem — gera um id totalmente novo. É por isso que --amend, rebase e cherry-pick “reescrevem o histórico”: eles criam commits novos, e os antigos simplesmente deixam de ser referenciados.
Uma branch é um arquivo de 40 caracteres em .git/refs/heads/<name> cujo conteúdo é o id de um commit. O HEAD normalmente aponta para um nome de branch. Por isso criar branch é instantâneo (escrever um arquivo pequeno), trocar de branch é reapontar o HEAD para outro nome e atualizar a árvore de trabalho para o snapshot daquele commit, e excluir branch é apagar um ponteiro — os commits em si não somem na hora.
O merge registra fielmente o que aconteceu: as duas linhas se encontram no commit de merge e qualquer pessoa vê que a funcionalidade foi desenvolvida em paralelo. O rebase deixa o histórico parecendo sempre linear — git log fica mais fácil de ler e git bisect mais fácil de usar — ao custo de mudar todos os ids de commit. Regra prática: rebase à vontade na sua branch que ainda não foi enviada; só faça merge do que outras pessoas podem estar usando como base. O git pull --rebase é essa regra no dia a dia: ele move seus poucos commits não enviados para depois do estado mais recente do remoto e evita uma pilha de “Merge branch 'main' of …”.
O --soft serve para “dividir ou juntar commits”: o ponteiro volta e o conteúdo continua em staging. O --mixed (padrão) serve para “escolher de novo o que commitar”. O --hard é o descarte de verdade: alterações que nunca foram commitadas na árvore de trabalho não têm como voltar, mas os commits descartados continuam no banco de objetos — o git reflog mostra cada movimento do HEAD, e git reset --hard HEAD@{1} leva você de volta ao estado anterior ao reset. Por padrão o reflog guarda 90 dias (30 para entradas inalcançáveis): é a janela de arrependimento que o Git oferece.
O rótulo “Perigo” vai para dois tipos de comando: os que descartam conteúdo não commitado da árvore de trabalho (restore, reset --hard, clean, stash drop, checkout -- <file>) e os que reescrevem histórico que outras pessoas talvez já tenham (push --force, branch -D em branch não mesclada). “Aviso” fica para comandos que mudam o estado de forma recuperável ou cujo raio de impacto você deve confirmar antes (commit --amend, rebase, merge --squash, push --delete). Comandos somente leitura (log, diff, status, show, blame) não recebem rótulo.
git switch e git restore exigem a versão 2.23 ou mais nova, e a grafia antiga checkout aparece junto.hash-object, cat-file, update-ref e afins) e operações específicas de plataforma (PR no GitHub, MR no GitLab pelo site) ficam de fora.reset, rebase linear, stash, push e pull remotos), mas não cobre rebase interativo, bisect, submódulos, hooks nem todas as opções de arquivos de configuração; um rebase que encontra conflito é abandonado automaticamente em vez de parar para você resolver..git do seu computador e não oferece resolvedor gráfico de conflitos.Busque “desfazer” ou abra o grupo “Desfazer e reverter” e separe primeiro os casos “ainda não enviei” (reset / --amend) dos “já enviei” (revert), depois escolha o comando. Em “Combinações comuns” há receitas completas, como “commitei na main e quero levar para uma branch nova”.
git rebase -i HEAD~N com squash / fixup / reword; o cartão de rebase nos diagramas mostra como o histórico sai da bifurcação para uma linha reta e por que os commits antigos ficam cinza.
O grupo “Colaboração remota” vai de remote add a push -u e --force-with-lease; os níveis 8 (push) e 9 (desfazer um commit já enviado) do terminal cobrem os dois “não consigo dar push” mais comuns.
git reflog, git fsck --lost-found e git stash list ficam lado a lado em “Desfazer e reverter”; a receita “recuperar uma branch apagada por engano” resolve em dois passos.
Depende de o commit já ter sido enviado. Não enviado: reset puxa o ponteiro direto de volta e o histórico fica limpo. Já enviado: revert acrescenta um commit inverso sem reescrever o que os outros já baixaram; caso contrário, na próxima vez que alguém fizer pull vai dar bifurcação.
Porque você tem commits não enviados e o remoto também tem commits novos, e o pull padrão faz merge dos dois lados. Para evitar, use git pull --rebase ou configure de uma vez com git config --global pull.rebase true.
--force sobrescreve a branch remota sem condição. O --force-with-lease primeiro confere se a branch remota ainda é o commit que você viu no último fetch e recusa se alguém tiver enviado algo novo — é o que impede o acidente de “sobrescrevi os commits do colega”. Depois de reescrever histórico, use sempre o segundo.
O Git real resume conteúdo, autor e data/hora num hash; o simulador troca o tempo real por um relógio lógico e usa hash determinístico, então a mesma sequência de operações gera os mesmos ids, o que facilita comparar com a resposta de referência. Os ids dele são diferentes dos que o Git real calcularia, de propósito.
Os comandos em si são multiplataforma. A diferença está no shell: no PowerShell, && exige a versão 7.x, colocar caminhos entre aspas é mais seguro e as quebras de linha convém configurar pelo item core.autocrlf em “Configuração inicial”.
Todo o conteúdo da página (a tabela de comandos, os diagramas e o terminal simulado) é estático, baixado junto com a página e executado localmente no seu navegador; buscar, copiar, favoritar e praticar não enviam requisição nenhuma ao servidor. Os favoritos ficam no localStorage deste aparelho, fora do alcance do site. Os links externos apontam para a documentação oficial do Git e são tratados pelo site de destino depois do clique.
Atualizado em 2026-09-09
149 comandos Git agrupados por situação, cada um com explicação, exemplo e nível de risco; busca, cópia em um clique e favoritos; inclui diagramas e um terminal de prática
Esta ferramenta ainda não está totalmente traduzida; parte do conteúdo usa o idioma de origem ou um idioma de reserva.
git init git init -b main # Especifique o nome inicial do branch
git clone https://github.com/git/git.git git clone git@github.com:user/repo.git my-dir
git clone --depth 1 --branch v2.0 https://github.com/user/repo.git
git clone -b develop https://github.com/user/repo.git
git config --global user.name "Zhang San" git config --global user.email "zs@example.com"
git config user.email "me@company.com"
git config --list --show-origin git config --get user.name
git config --global core.autocrlf input
git config --global alias.lg "log --oneline --graph --all" git lg
O Windows geralmente vem com um gerenciador; macOS usa osxkeychain para mais segurança.
git help rebase git reset -h # Uso curto
git status git status -s # Formato abreviado: M Modificar A Adicionar D Excluir ?? Não rastreado
git add src/app.js git add src/ # Diretório inteiro git add "*.md" # curinga
git add -A git add -u # Apenas alterações temporárias e exclusões de arquivos rastreados são armazenadas, excluindo novos arquivos.
git add -p src/app.js # y salva temporariamente esta peça e pula a divisão em pedaços menores q sai
git commit -m "correção: julgamento correto do tempo limite de login"
git commit -am "docs: update readme"
É fácil trazer mudanças que você não deseja comprometer. Basta executar git status antes de confirmar.
git add forgotten.js git commit --amend --no-edit #Adicione arquivos, mas não altere a descrição git commit --amend -m "nova descrição"
Gere um novo ID de envio; não altere envios que já foram enviados, caso contrário, eles precisarão ser enviados.
git diff git diff src/app.js # Visualiza apenas um arquivo
git diff --staged
git diff main feature git diff HEAD~3 HEAD -- src/ git diff main...feature # Mudanças de recursos em relação ao ponto de bifurcação
git diff --stat HEAD~1
git diff --word-diff=color README.md
git log git log -5 # Últimas 5 entradas git log --oneline # Uma linha por linha
git log --oneline --graph --all --decorate
git show HEAD git show a1b2c3d --stat git show HEAD:src/app.js # Visualiza o conteúdo do arquivo de uma determinada versão
git rm old.txt git rm -r legacy/
git rm --cached .env echo ".env" >> .gitignore
git mv utils.js helpers.js
git branch git branch -a # inclui branches remotas git branch -vv # Com o relacionamento mais recente de commit e rastreamento
git branch feature/login git branch hotfix a1b2c3d # Cria a partir do commit especificado
git switch main git switch - # Volta para o branch anterior
git switch -c feature/search git switch -c hotfix origin/main # Baseado na branch remota
git checkout -b release/1.2
git branch -m master main git push -u origin main && git push origin --delete master
git branch -d feature/login
git branch -D experiment
Os commits únicos no branch se tornarão órfãos e poderão ser recuperados usando o reflog no curto prazo.
git branch --merged main git branch --no-merged # inversamente
git branch -u origin/feature/login
git branch -a --contains a1b2c3d
git checkout v1.0 git switch -c fix-from-v1 # Se você quiser manter as alterações, crie um branch aqui
Os envios neste estado não pertencem a nenhum ramo e são facilmente perdidos após serem cortados.
git branch --sort=-committerdate | head
git fetch -p git remote prune origin
git switch main git merge feature/login
git merge --no-ff feature/login
git merge --squash feature/login git commit -m "feat: login"
git merge --abort
git add src/app.js git commit #Default descrição Mesclar branch...
git checkout --theirs package-lock.json git add package-lock.json
Ao rebase, os significados do nosso/deles são invertidos: o nosso é o ramo que é rebaseado.
git switch feature git rebase main
Todos os IDs de commit movidos serão alterados; ramos que foram empurrados e alguém está trabalhando nisso não devem ser rebaseados.
git rebase -i HEAD~3 # escolha manter reformulação alterar a descrição squash mesclar para a anterior correção mesclar e perder a descrição soltar excluir
git add . git rebase --continue
git rebase --abort
git rebase --onto main server client
Adequado para a situação em que “a agência foi aberta no local errado”.
git commit --fixup a1b2c3d git rebase -i --autosquash a1b2c3d~1
git cherry-pick a1b2c3d git cherry-pick a1b2c3d..e5f6g7h # Um intervalo (excluindo a1b2c3d)
git cherry-pick -n a1b2c3d
git config --global merge.tool vscode git config --global mergetool.vscode.cmd "code --wait $MERGED" git mergetool
git restore src/app.js git restaurar. #Diretório inteiro
As alterações não preparadas serão perdidas diretamente e não poderão ser recuperadas usando o Git.
git restore --staged src/app.js git reset HEAD src/app.js #Maneira antiga de escrever
git restore --source HEAD~2 config.yml git restore --source v1.0 -- src/
git reset --soft HEAD~1 git commit -m "Uma descrição mais apropriada"
git reset HEAD~1
git reset --hard HEAD~1 # Jogue fora o último commit git reset --hard origin/main # Exatamente o mesmo que remoto
As alterações no espaço de trabalho são irreversíveis; os confirmados podem ser recuperados usando git reflog.
git reset package-lock.json
git revert HEAD git revert a1b2c3d --no-edit
git revert --no-commit HEAD~3..HEAD git commit -m "revert last 3 commits"
git revert -m 1 f00ba12
Depois de desfazer a mesclagem, você precisa reverter essa reversão antes de mesclá-la no mesmo branch.
git reflog
git reset --hard HEAD@{2} # Retorna ao estado anterior ao passo 2
git branch Rescue a1b2c3d # Cria um branch para o envio órfãogit clean -n # Visualiza o que será excluído git clean -fd #executa git clean -fdx # Exclua até mesmo os ignorados em .gitignore (como node_modules)
git checkout -- src/app.js
git fsck --lost-found git show <dangling-commit-id>
git fsck --unreachable | grep commit | cut -d" " -f3 | xargs git log --merges --no-walk
git remote -v
git remote add origin git@github.com:user/repo.git
git remote set-url origin git@github.com:user/repo.git
git remote rename origin upstream
git remote remove upstream
git fetch git fetch origin main git fetch --all --prune
git pull git pull origin main
git pull --rebase origin main
git push git push origin main
git push -u origin feature/login
git push origin --delete feature/old git push origin --delete v0.1 # Você também pode excluir tags remotas
git push --force-with-lease origin feature/login
Use isto de preferência a --force.
git push -f origin feature/login
Os envios enviados por terceiros serão apagados; branches compartilhadas são proibidas.
git push --all origin
git ls-remote --heads origin git ls-remote --tags https://github.com/git/git.git
git remote add upstream https://github.com/original/repo.git git fetch upstream git switch main && git merge upstream/main
git pull --ff-only
git stash git stash push -m "Página de login semiacabada"
git stash -u git stash -a # Coleta até mesmo arquivos ignorados
git stash list
git stash pop
git stash pop stash@{2}git stash apply stash@{1}git stash show -p stash@{0}git stash drop stash@{0}
git stash clear #exclui tudogit stash branch fix-from-stash stash@{0}git stash push -m "Recolher apenas estilos" -- src/styles/
git tag git tag -l "v1.*" # Filtrar por padrão
git tag -a v1.2.0 -m "Release 1.2.0"
git tag build-2026-09-09
git tag -a v1.1.1 a1b2c3d -m "maquiagem"
git show v1.2.0
git tag -d v1.2.0
git push origin --delete v1.2.0
git describe --tags --always
git submodule add https://github.com/user/lib.git vendor/lib
git submodule update --init --recursive
git clone --recurse-submodules https://github.com/user/repo.git
git submodule update --remote vendor/lib git add vendor/lib && git commit -m "bump lib"
git submodule status
git submodule deinit -f vendor/lib git rm -f vendor/lib rm -rf .git/modules/vendor/lib
git worktree add ../repo-hotfix hotfix/1.2.1 git worktree add -b review ../repo-review origin/pr-42
git worktree list
git worktree remove ../repo-hotfix git worktree prune # Limpa o registro de diretórios excluídos manualmente
git clone --filter=blob:none --sparse <url> cd repo && git sparse-checkout set apps/web packages/ui
git log -p -- src/app.js git log --follow -- src/app.js # Rastreamento de renomeação cruzada
git log --grep="login" -i --oneline
git log -S"validateToken" --oneline git log -G"regex" --oneline # Versão normal
git log main..feature --oneline git log origin/main..HEAD # Commits que ainda não foram enviados
git log --pretty=format:"%h %ad %an %s" --date=short -10
git log --since="2026-09-01" --until="2026-09-09" --oneline
git shortlog -sn --all --no-merges
git blame -L 40,60 src/app.js git culpa -w -C src/app.js # Ignora espaços em branco, rastreia movimentos
git bisect start git bisect bad # Atualmente ruim git bisect good v1.1.0 # Esta versão é boa # Teste repetidamente e execute git bisect good/bad git bisect reset
git bisect run npm test
git grep -n "TODO" -- "*.ts" git grep "foo" v1.0 # Pesquise em uma determinada versão
git show HEAD~5:src/config.js > old-config.js
git diff --name-only HEAD~3 HEAD git diff --name-status main # com status M/A/D
git count-objects -vH
git gc --aggressive --prune=now
prune irá, na verdade, excluir os objetos inacessíveis, e o remédio para arrependimento no reflog desaparecerá junto.
git rev-parse --short HEAD git rev-parse --abbrev-ref HEAD git rev-parse --show-toplevel # Diretório raiz do armazém
git archive -o release.zip v1.2.0 git archive HEAD src/ | tar -x -C /tmp/out
# .gitignore node_modules/ dist/ *.log .env* !.env.example
git check-ignore -v dist/app.js
git rm -r --cached . git add . git commit -m "chore: apply .gitignore"
echo ".DS_Store" >> ~/.gitignore_global git config --global core.excludesFile ~/.gitignore_global
git update-index --skip-worktree config/local.php git update-index --no-skip-worktree config/local.php # Cancelar
* text=auto *.sh text eol=lf *.png binary *.psd filter=lfs diff=lfs merge=lfs -text
git lfs install git lfs track "*.psd" git add .gitattributes
Encadeie alguns comandos em uma receita de «quero fazer uma coisa»; ao expandir, dá para copiar tudo.
O envio foi muito cedo/a descrição foi escrita incorretamente/quero dividi-lo em dois envios (e ainda não foi enviado)
git reset --soft HEAD~1Envie e retire, as alterações ainda estão na área de testegit statusConfirme se os arquivos estão todos em “Alterações a serem enviadas”git commit -m “nova descrição”Outros podem já ter feito isso, a história não pode ser reescrita.
git revert <commit>Gerar commit reversogit pushO experimento local está bagunçado e quero voltar completamente para um determinado commit
git log --onelineEncontre o ID do commit alvogit stash -u(Opcional) Recolha as alterações que deseja manter primeirogit reset --hard <commit>Esqueci de abrir uma branch e enviei N vezes.
git branch feature/xCrie uma branch no local atual ("salve" esses commits)git reset --hard origin/mainprincipal retorna ao estado remotogit switch feature/xOrganize o histórico antes de abrir um PR (a agência não é utilizada por terceiros)
git rebase -i HEAD~4Altere o pick nas linhas a seguir para squash ou fixupgit push --force-with-leaseObrigatório somente se o branch tiver sido enviado por pushmain tem um novo commit, e o branch feature deve continuar em cima dele
git fetch origingit switch feature/xgit rebase origin/mainou git merge Origin/main (manter commits de mesclagem)Unifique o nome da branch padrão
git branch -m master maingit push -u origin maingit push origin --delete masterPrimeiro, corte o branch padrão para main na plataforma de hospedagemAchei útil depois de git branch -D
git reflogEncontre o id do último commit do branch (como "commit: xxx")git branch <name> <commit-id>.env ou centenas de arquivos MB entraram no histórico
git rm --cached .env && echo ".env" >> .gitignoreSe apenas o commit mais recente for feito: então git commit --amendgit filter-repo --path .env --invert-pathsJá mergulhado na história: reescreva todo o histórico com git-filter-repo (precisa ser instalado separadamente)git push --force-with-lease --allTodos os colaboradores deverão ser clonados novamente; chaves vazadas devem ser invalidadas e reemitidas de qualquer maneiraBugs corrigidos no main também serão movidos para release/1.2
git switch release/1.2git cherry-pick <commit>git pushgit mesclar / puxar relatório CONFLITO
git statusVeja quais documentos foram “modificados por ambas as partes”code <file>Processar tags <<<<<<< ======= >>>>>>> no editor, mantendo o conteúdo corretogit add <file>Adicione um depois que cada um for corrigidogit commitAo rebase, git rebase --continuePrimeiro escrevi o código localmente e depois construí um warehouse no GitHub.
git init -b main && git add -A && git commit -m "init"git remote add origin git@github.com:user/repo.gitgit push -u origin mainOs círculos são commits e as setas apontam para o commit pai; os rótulos verdes são branches e o roxo indica o branch onde está o HEAD; os círculos cinza não são mais referenciados por nenhum branch (recuperáveis pelo reflog) e os preenchidos são os commits criados por esta operação.
git add . && git commit -m "…"Cada commit registra seu próprio commit pai; um branch é apenas um ponteiro móvel para um commit, então ao confirmar, main e HEAD avançam juntos.
git switch -c featureO novo branch e main apontam para o mesmo commit, então criá-lo é instantâneo; depois, commits em feature avançam apenas feature.
git switch main && git merge featureNenhum commit novo é criado e o histórico continua uma linha reta. Para guardar o registro de que houve um branch aqui, use --no-ff.
git merge featureO Git encontra o ancestral comum b2, combina as mudanças de cada lado em relação a b2 e cria m6 com dois commits pais. Só há conflito quando a mesma área muda de forma diferente.
git switch feature && git rebase mainO histórico vira uma linha reta, mas c3 e d4 são substituídos pelos novos commits c3′ e d4′ (os ids mudam). Evite fazer rebase de um branch já enviado, senão o histórico dos outros vai divergir do seu.
git reset --hard HEAD~1--soft move apenas o ponteiro; --mixed também limpa a área de preparação; --hard reverte também a árvore de trabalho. O commit órfão c3 ainda pode ser recuperado pelo reflog (mantido por pelo menos 30 dias por padrão).
git revert HEADc3 continua no histórico e o novo commit r4 contém o inverso das mudanças de c3. Para desfazer um commit já enviado, use revert em vez de reset.
git cherry-pick x7Reaplica sobre main a mudança que x7 introduziu em relação ao seu commit pai e gera x7′ com o mesmo conteúdo e id diferente. É a forma usual de levar uma correção isolada para um branch de release.
Um simulador de Git totalmente em memória (não é o Git real e não acessa a rede): aceita os subcomandos comuns init / add / commit / branch / switch / merge / rebase / reset / revert / stash / tag / remote / push / pull, e o grafo à direita é atualizado em tempo real. 10 níveis vão de “a primeira confirmação” a “resolver um conflito de fusão”. A prática de comandos Linux está emReferência de comandos do Linux.