Comandos do Git: cola com exemplos para o dia a dia
Os comandos básicos do Git são git init e git clone para criar um repositório, git status, git add e git commit para salvar alterações, git branch, git switch e git merge para trabalhar com branches, git push, git fetch e git pull para sincronizar com o servidor, e git restore, git reset e git revert para desfazer mudanças.
A seguir está uma cola prática de Git: os comandos estão agrupados por tarefa, cada um com um exemplo e uma explicação curta. Vale deixá-la aberta ao lado do terminal, porque quase tudo o que um desenvolvedor faz com Git no dia a dia cabe em 20 a 30 comandos destas tabelas.
Para que os comandos façam sentido, tenha em mente três áreas: o diretório de trabalho (os arquivos no disco), o índice ou staging area (o que vai entrar no próximo commit) e o repositório (o histórico de commits dentro da pasta .git). A maioria dos comandos move mudanças entre essas três áreas ou entre o repositório local e o remoto.
Configuração do Git
Estes comandos são executados uma vez, depois da instalação. A flag --global grava as configurações em ~/.gitconfig e vale para todos os repositórios do usuário; sem ela, a configuração vale só para o repositório atual.
| Comando | O que faz |
|---|---|
git config --global user.name "Ana Souza" | Nome do autor dos commits |
git config --global user.email "ana@example.com" | E-mail do autor dos commits |
git config --global init.defaultBranch main | Nome da branch padrão em novos repositórios |
git config --global core.editor "code --wait" | Editor para as mensagens de commit (aqui, VS Code) |
git config --global pull.rebase false | Comportamento padrão do git pull: merge |
git config --global core.autocrlf input | Converte CRLF em LF ao fazer commit (macOS/Linux; no Windows costuma ser true) |
git config --list --show-origin | Mostra todas as configurações e de qual arquivo cada uma vem |
git config --global alias.st status | Apelido: git st no lugar de git status |
git --version | Versão do Git instalada |
git help commit | Manual completo de um comando (ou git commit -h para o resumo) |
Criar e clonar repositórios
| Comando | O que faz |
|---|---|
git init | Cria um repositório vazio (a pasta .git) no diretório atual |
git init meu-projeto | Cria a pasta meu-projeto e um repositório dentro dela |
git clone https://github.com/usuario/repo.git | Copia um repositório remoto com todo o histórico |
git clone git@github.com:usuario/repo.git app | Clona via SSH para a pasta app |
git clone --depth 1 URL | Clone raso: só o último commit, rápido e com pouco espaço |
git clone -b develop URL | Clona e já muda para a branch develop |
Ciclo básico: status, add, commit
É o núcleo do trabalho diário: ver o que mudou, escolher o que vai para o índice e registrar tudo em um commit.
| Comando | O que faz |
|---|---|
git status | Situação: arquivos modificados, preparados e não rastreados |
git status -s | Formato curto: M — modificado, A — adicionado, ?? — não rastreado |
git add arquivo.txt | Adiciona um arquivo ao índice |
git add . | Adiciona todas as alterações do diretório atual e abaixo, incluindo remoções |
git add -A | Adiciona todas as alterações de todo o repositório |
git add -p | Escolhe de forma interativa os trechos (hunks) alterados |
git commit -m "Adiciona tela de login" | Cria um commit com o conteúdo do índice e a mensagem |
git commit -am "Corrige typo" | Prepara todos os arquivos rastreados alterados e faz o commit; arquivos novos não entram |
git commit --amend | Reescreve o último commit: inclui o que ficou de fora do índice ou corrige a mensagem |
git commit --amend --no-edit | Complementa o último commit sem mudar a mensagem |
git rm arquivo.txt | Remove o arquivo do disco e do índice |
git rm --cached secreto.env | Para de rastrear o arquivo, mas mantém ele no disco |
git mv antigo.js novo.js | Renomeia ou move um arquivo |
Um fluxo típico fica assim:
git status
git add src/login.js src/login.css
git diff --staged # confira o que de fato vai para o commit
git commit -m "Adiciona tela de login"Não use --amend em commits que já foram enviados para uma branch compartilhada: ele cria um commit novo com outro hash, e os colegas vão ter divergências no histórico.
Ver histórico e alterações
| Comando | O que faz |
|---|---|
git log | Histórico de commits da branch atual |
git log --oneline | Cada commit em uma linha: hash curto e título |
git log --oneline --graph --all | Grafo de todas as branches no terminal |
git log -p arquivo.txt | Histórico do arquivo com o diff de cada commit |
git log --author="Ana" --since="2 weeks ago" | Filtro por autor e por data |
git log -S "getUser" | Commits em que a string getUser foi adicionada ou removida |
git log main..feature | Commits que estão em feature mas não em main |
git diff | Alterações no diretório de trabalho ainda não adicionadas ao índice |
git diff --staged | Alterações no índice em relação ao último commit (sinônimo de --cached) |
git diff main feature | Diferença entre as pontas de duas branches |
git diff HEAD~3 -- src/ | Alterações na pasta src nos últimos três commits |
git show a1b2c3d | Metadados e diff de um commit específico |
git show HEAD:README.md | Conteúdo de um arquivo no último commit |
git blame app.js | Quem alterou cada linha por último e em qual commit |
git shortlog -sn | Número de commits por autor |
Referências a commits aparecem em todo lugar: HEAD é o commit atual, HEAD~1 é o pai dele, HEAD~3 são três passos para trás pelo primeiro pai, e HEAD^2 é o segundo pai de um merge commit.
Branches: criar, trocar, excluir
A partir da versão 2.23, o Git tem git switch para branches e git restore para arquivos, separando as funções que o git checkout acumulava. As formas antigas continuam funcionando.
| Comando | O que faz |
|---|---|
git branch | Lista as branches locais; a atual aparece com * |
git branch -a | Branches locais e remotas (de rastreamento) |
git branch -vv | Branches com o último commit e a diferença em relação ao upstream |
git branch feature/login | Cria a branch sem trocar de branch |
git switch feature/login | Troca para a branch |
git switch -c feature/login | Cria a branch e já troca para ela (equivale a git checkout -b) |
git switch - | Volta para a branch anterior |
git branch -m novo-nome | Renomeia a branch atual |
git branch -d feature/login | Exclui a branch, se ela já foi mesclada |
git branch -D feature/login | Exclui a branch à força, mesmo sem merge |
git branch --merged | Branches já mescladas na atual: candidatas a exclusão |
Merge e rebase
| Comando | O que faz |
|---|---|
git merge feature | Mescla feature na branch atual (fast-forward, quando possível) |
git merge --no-ff feature | Cria sempre um merge commit |
git merge --squash feature | Junta todas as alterações da branch no índice de uma vez, para você fazer um único git commit |
git merge --abort | Cancela um merge com conflitos e volta ao estado anterior |
git rebase main | Reaplica os commits da branch atual em cima da main |
git rebase -i HEAD~4 | Interativo: unir (squash), renomear, reordenar ou remover os últimos 4 commits |
git rebase --continue | Continua depois de resolver um conflito |
git rebase --abort | Cancela o rebase por completo |
git cherry-pick a1b2c3d | Aplica um commit na branch atual como um commit novo |
Resolver um conflito de merge quase sempre segue o mesmo roteiro:
git merge feature
# CONFLICT (content): Merge conflict in app.js
git status # arquivos aparecem em "both modified"
# edite app.js e remova os marcadores <<<<<<< ======= >>>>>>>
git add app.js
git commit # o Git sugere a mensagem pronta do merge commitRegra principal do rebase: não reescreva commits que já estão em uma branch compartilhada e nos quais outras pessoas estão trabalhando.
Trabalho com repositórios remotos
| Comando | O que faz |
|---|---|
git remote -v | Lista os remotos e seus endereços |
git remote add origin git@github.com:usuario/repo.git | Conecta um repositório remoto com o nome origin |
git remote set-url origin NOVA_URL | Troca o endereço do remoto (por exemplo, de HTTPS para SSH) |
git remote remove upstream | Remove um remoto |
git fetch | Baixa commits e branches novos sem mexer nos seus arquivos |
git fetch --prune | O mesmo, e ainda apaga referências de branches que foram removidas no servidor |
git pull | git fetch + merge da branch upstream na atual |
git pull --rebase | git fetch + rebase dos seus commits em cima do que foi baixado |
git push | Envia os commits da branch atual para o upstream |
git push -u origin feature/login | Primeiro envio da branch, definindo o upstream |
git push --force-with-lease | Sobrescreve a branch remota, mas só se ninguém enviou commits novos nela |
git push origin --delete feature/login | Exclui a branch no servidor |
git push --tags | Envia todas as tags locais |
Em vez de git push --force, use --force-with-lease: se um colega tiver enviado algo para a mesma branch, o Git se recusa a apagar o trabalho dele.
Desfazer alterações
É a parte mais tensa do Git. A pergunta-chave antes de escolher o comando: a mudança está só nos arquivos, já no índice, em um commit local ou em um commit publicado?
| Situação | Comando |
|---|---|
| Descartar alterações em um arquivo (voltar ao que está no último commit) | git restore app.js |
| Tirar um arquivo do índice, mantendo as alterações | git restore --staged app.js |
| Trazer um arquivo de um commit específico | git restore --source=a1b2c3d app.js |
| Desfazer o último commit, mantendo as alterações no índice | git reset --soft HEAD~1 |
| Desfazer o último commit, mantendo as alterações nos arquivos | git reset HEAD~1 (modo --mixed, padrão) |
| Apagar o último commit e todas as suas alterações | git reset --hard HEAD~1 |
| Desfazer um commit publicado com um novo commit «inverso» | git revert a1b2c3d |
| Desfazer um merge commit | git revert -m 1 <hash-do-merge> |
| Ver quais arquivos não rastreados seriam apagados | git clean -n |
| Apagar arquivos e pastas não rastreados | git clean -fd |
| Encontrar um commit «perdido» depois de reset ou rebase | git reflog, depois git reset --hard HEAD@{2} |
git reset --hard e git clean -f apagam de forma irreversível as alterações não commitadas: o reflog guarda apenas commits, e não as edições do diretório de trabalho. Antes deles, faça um git stash ou, no mínimo, um git status.
Stash: guardar um trabalho inacabado
| Comando | O que faz |
|---|---|
git stash | Guarda as alterações dos arquivos rastreados e limpa o diretório de trabalho |
git stash push -u -m "wip: formulário" | Guarda também os arquivos não rastreados, com uma descrição |
git stash list | Lista os conjuntos guardados: stash@{0}, stash@{1}… |
git stash show -p stash@{0} | Mostra o diff de um conjunto guardado |
git stash pop | Restaura o último conjunto e o remove da lista |
git stash apply stash@{1} | Restaura um conjunto e mantém ele na lista |
git stash drop stash@{1} | Remove um conjunto |
git stash branch corrige-formulario | Cria uma branch a partir do commit em que o stash foi feito e aplica o conjunto nela |
Tags e releases
| Comando | O que faz |
|---|---|
git tag | Lista as tags |
git tag -a v1.2.0 -m "Release 1.2.0" | Tag anotada, com autor, data e mensagem |
git tag v1.2.0 a1b2c3d | Tag leve apontando para um commit específico |
git push origin v1.2.0 | Envia uma tag |
git tag -d v1.2.0 | Remove a tag localmente |
git push origin --delete v1.2.0 | Remove a tag no servidor |
git describe --tags | Tag mais próxima e quantos commits existem depois dela, por exemplo v1.2.0-3-ga1b2c3d |
Comandos avançados
| Comando | O que faz |
|---|---|
git bisect start, git bisect bad, git bisect good v1.1.0 | Busca binária pelo commit que introduziu um erro; ao final, git bisect reset |
git worktree add ../hotfix main | Segunda pasta de trabalho com outra branch do mesmo repositório |
git submodule update --init --recursive | Baixa os submódulos depois de um clone |
git grep "TODO" | Busca rápida nos arquivos rastreados |
git format-patch -1 HEAD / git apply fix.patch | Salva um commit como patch e aplica um patch ao diretório de trabalho |
git gc | Compacta objetos e limpa o repositório (normalmente o Git faz isso sozinho) |
Erros comuns e como corrigi-los
Commitei na main em vez de uma branch nova
Se o commit ainda não foi enviado, crie uma branch apontando para ele e recue a main:
git branch feature/login # a branch aponta para o seu commit
git reset --hard HEAD~1 # a main volta um passo
git switch feature/loginEsqueci de adicionar um arquivo ao último commit
git add esquecido.js
git commit --amend --no-editPush rejeitado: rejected, non-fast-forward
O servidor tem commits que você não tem. Primeiro traga-os e depois envie:
git pull --rebase
git pushCommitei por engano um arquivo com senhas
Tire o arquivo do rastreamento e inclua-o no .gitignore: git rm --cached .env, depois commit. Se o commit já foi publicado, considere o segredo comprometido e gere outro — ele continua no histórico.
Resumo
Para o dia a dia, basta um conjunto curto: status, add, commit, switch, merge, pull, push e log --oneline. Para desfazer, use restore, reset ou revert, conforme o commit já tenha sido publicado ou não; e lembre do reflog como seguro para situações extremas. Todos os comandos desta cola são praticados passo a passo no nosso curso de Git, em um repositório seu.
Perguntas frequentes
Quantos comandos do Git um iniciante precisa saber?
Para começar, de 10 a 12 bastam: init, clone, status, add, commit, log, diff, branch, switch, merge, pull e push. Os outros aparecem conforme a necessidade.
Qual a diferença entre git switch e git checkout?
O git switch só troca e cria branches; o git checkout também restaura arquivos. A separação existe para que você não sobrescreva alterações por engano ao confundir uma branch com um arquivo.
Como ver a ajuda de um comando do Git?
Use git help nome-do-comando para o manual completo ou git nome-do-comando -h para o resumo das flags. A mesma documentação está em git-scm.com.
Dá para encurtar comandos longos do Git?
Sim, com aliases: git config --global alias.lg "log --oneline --graph --all" permite digitar apenas git lg.
Esses comandos funcionam no Windows?
Sim, são os mesmos em todos os sistemas. No Windows, é cômodo executá-los no Git Bash, no PowerShell ou no terminal do editor de código.
Este tema é abordado em profundidade, com prática, no curso “Git do zero ao desenvolvedor confiante”.
- Primeiro Repositório: init, add, commit e a Mágica do Índice
- Lendo o histórico: log, diff, show e navegação pelo passado
- Branches: A Realidade Paralela do Seu Código
- Desfazendo Erros: restore, reset, revert — O Caminho Correto e os Perigos
- GitHub e repositórios remotos: seu código na nuvem
- Ferramentas Avançadas: rebase, stash, cherry-pick e tags