Git: 100 Comandos que Resolvem o Dia a Dia

Git é a ferramenta que todo desenvolvedor usa e quase ninguém domina por inteiro. A boa notícia: uns 20 comandos cobrem 95% do trabalho — os outros 80 são o que salva você no dia em que algo dá errado.

Estes 100 comandos estão na ordem em que aparecem na vida real: configurar, criar, commitar, ramificar, integrar, publicar, desfazer e investigar.

Regra de ouro: enquanto você não deu push, quase tudo é reversível. Depois do push, prefira comandos que adicionam história (como revert) em vez dos que a reescrevem (como rebase e --force).

Índice

• 1–10 · Configuração inicial
• 11–18 · Criar e clonar repositórios
• 19–32 · O fluxo do dia a dia
• 33–46 · Branches
• 47–58 · Merge, rebase e conflitos
• 59–70 · Trabalhando com remotos
• 71–84 · Desfazendo (o capítulo que salva a pele)
• 85–94 · Histórico e investigação
• 95–100 · Stash, tags e submódulos

Configuração inicial

Feito uma vez por máquina — e o que evita commit com autor errado.

1. Definir nome e e-mail

É o que aparece na autoria de cada commit. Sem isso, o Git reclama no primeiro commit.

git config --global user.name "Jhonatan Pinheiro"
git config --global user.email "voce@email.com"

2. Ver a configuração atual

Lista tudo que está valendo e de onde cada valor veio.

git config --list --show-origin

3. Configuração por repositório

Sem --global, vale só no projeto atual. Útil para separar e-mail pessoal do corporativo.

git config user.email "voce@empresa.com"

4. Editor padrão

Define quem abre a mensagem de commit e o rebase interativo.

git config --global core.editor "code --wait"

5. Branch inicial padrão

Faz todo repositório novo nascer com main em vez de master.

git config --global init.defaultBranch main

6. Fim de linha (CRLF x LF)

Evita o clássico diff gigante entre Windows e Linux.

git config --global core.autocrlf true    # Windows
git config --global core.autocrlf input   # Linux e macOS

7. Atalhos (alias)

Comandos longos que você repete todo dia merecem um apelido.

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.lg "log --oneline --graph --decorate --all"

8. Cache de credencial

Evita digitar token a cada push.

git config --global credential.helper store     # salva em disco
git config --global credential.helper manager   # Windows (gerenciador do SO)

9. Assinar commits com GPG

Prova criptográfica de autoria — o selo Verified no GitHub.

git config --global user.signingkey SEU_ID_GPG
git config --global commit.gpgsign true

10. Pull sem merge automático

Faz o git pull reclamar em vez de criar merge sozinho. Evita história embolada.

git config --global pull.rebase false
git config --global pull.ff only

Criar e clonar repositórios

O ponto de partida: transformar uma pasta em repositório ou trazer um existente.

11. git init — criar repositório

Transforma a pasta atual em um repositório Git (cria o diretório .git).

git init

12. git clone — copiar um repositório

Baixa o projeto com todo o histórico e já configura o remoto origin.

git clone https://github.com/usuario/projeto.git

13. Clonar em outra pasta

Define o nome do diretório de destino.

git clone https://github.com/usuario/projeto.git minha-pasta

14. Clone raso (shallow)

Traz só os commits mais recentes. Muito mais rápido em repositório grande — ideal em CI.

git clone --depth 1 https://github.com/usuario/projeto.git

15. Clonar uma branch específica

Baixa apenas o ramo que interessa.

git clone --branch desenvolvimento --single-branch https://github.com/usuario/projeto.git

16. Clonar via SSH

Sem digitar senha/token, desde que sua chave esteja cadastrada.

git clone git@github.com:usuario/projeto.git

17. .gitignore

Lista o que o Git deve ignorar. Coloque aqui dependências, build e segredos.

# .gitignore
node_modules/
.env
.env.local
dist/
*.log

18. Parar de rastrear um arquivo já commitado

Adicionar ao .gitignore não remove o que já está versionado.

git rm --cached .env
git commit -m "chore: remove .env do versionamento"

O fluxo do dia a dia

Ver o que mudou, escolher o que entra e registrar. Noventa por cento do uso do Git.

19. git status

Mostra o que mudou, o que está preparado e em que branch você está. Rode sempre antes de commitar.

git status
git status -s        # versão curta

20. git add — preparar arquivo

Move a alteração para a staging area — a antessala do commit.

git add arquivo.ts
git add src/

21. git add . — preparar tudo

Adiciona tudo que mudou. Confira com status antes, para não levar arquivo indesejado.

git add .

22. git add -p — preparar por partes

Escolhe pedaço por pedaço dentro do mesmo arquivo. O melhor amigo do commit pequeno.

git add -p

23. git diff — o que mudou

Diferença entre o que está no disco e o último commit (sem contar o que já foi preparado).

git diff

24. git diff --staged

Mostra exatamente o que vai entrar no próximo commit.

git diff --staged

25. git diff entre branches

Compara dois pontos quaisquer da história.

git diff main..minha-feature
git diff main..minha-feature -- src/app

26. git commit

Registra o que está preparado. A mensagem é documentação: escreva o porquê.

git commit -m "feat: adiciona filtro por assunto no blog"

27. Commit com corpo

Título curto, linha em branco, e o contexto embaixo.

git commit -m "fix: corrige contraste do tema claro" -m "O primary ficava em 3,2:1 sobre o fundo, abaixo do minimo AA."

28. git commit -a

Adiciona e commita arquivos já rastreados de uma vez. Não pega arquivo novo.

git commit -am "refactor: extrai helper de datas"

29. Conventional Commits

Convenção que deixa o histórico legível e permite gerar changelog automático.

# feat, fix, docs, style, refactor, perf, test, chore
git commit -m "perf(db): indexa pedidos por cliente_id"

30. git commit --amend

Corrige o último commit (mensagem ou conteúdo). Só antes do push.

git commit --amend -m "mensagem corrigida"
git commit --amend --no-edit   # só adiciona o que está preparado

31. Commit vazio

Sem alteração nenhuma — útil para disparar um pipeline de CI.

git commit --allow-empty -m "chore: dispara build"

32. git mv e git rm

Renomear e remover mantendo o rastro no histórico.

git mv antigo.ts novo.ts
git rm obsoleto.ts

Branches

Ramificar é barato no Git. Uma branch por tarefa é o padrão que evita dor de cabeça.

33. Listar branches

Mostra as locais; com -a, também as remotas.

git branch
git branch -a
git branch -vv   # com o último commit e o remoto de cada uma

34. Criar branch

Cria a partir do commit atual, sem mudar para ela.

git branch minha-feature

35. Trocar de branch

switch é o comando moderno; checkout continua funcionando.

git switch minha-feature
git checkout minha-feature

36. Criar e já trocar

O atalho mais usado do dia a dia.

git switch -c minha-feature
git checkout -b minha-feature

37. Criar branch a partir de outra

Sai de um ponto específico em vez do commit atual.

git switch -c hotfix main

38. Renomear branch

Renomeia a atual (-m) ou uma específica.

git branch -m novo-nome
git branch -m nome-antigo novo-nome

39. Apagar branch local

-d recusa se houver commit não integrado; -D força.

git branch -d minha-feature
git branch -D minha-feature

40. Apagar branch remota

Remove o ramo do servidor depois do merge.

git push origin --delete minha-feature

41. Voltar para a branch anterior

O - funciona como no cd.

git switch -

42. Branches já integradas

Lista o que já foi mesclado — candidatas seguras a apagar.

git branch --merged main
git branch --no-merged main

43. Rastrear branch remota

Vincula a branch local à do servidor, para push/pull sem argumentos.

git branch --set-upstream-to=origin/minha-feature

44. Limpar referências mortas

Remove do seu clone as branches que já não existem no servidor.

git fetch --prune

45. git worktree

Duas branches abertas em pastas diferentes ao mesmo tempo, sem clonar de novo.

git worktree add ../projeto-hotfix hotfix
git worktree list
git worktree remove ../projeto-hotfix

46. Descobrir a branch atual

Útil dentro de script e prompt de terminal.

git branch --show-current

Merge, rebase e conflitos

Duas formas de integrar trabalho — e como sair do conflito sem perder nada.

47. git merge

Traz a branch informada para a atual, criando um commit de merge quando necessário.

git switch main
git merge minha-feature

48. Merge fast-forward

Sem divergência, o Git só avança o ponteiro — história linear, sem commit extra.

git merge --ff-only minha-feature

49. Merge com commit sempre

Força o commit de merge, preservando a existência da branch na história.

git merge --no-ff minha-feature

50. Abortar um merge

Volta tudo ao estado anterior ao merge.

git merge --abort

51. Resolver conflito

Edite os arquivos marcados, remova os marcadores, adicione e conclua.

git status                 # lista os conflitos
# edite os arquivos e remova <<<<<<< ======= >>>>>>>
git add arquivo-resolvido.ts
git commit

52. Escolher um lado no conflito

Aceita a versão sua ou a que veio, sem edição manual.

git checkout --ours arquivo.ts    # a versão da branch atual
git checkout --theirs arquivo.ts  # a versão que está entrando

53. Ferramenta visual de merge

Abre o conflito em uma ferramenta gráfica configurada.

git mergetool

54. git rebase

Reaplica seus commits em cima de outra branch. Deixa a história linear.

git switch minha-feature
git rebase main

55. Rebase interativo

Reordena, junta (squash), edita e remove commits antes de abrir o PR.

git rebase -i HEAD~5

56. Continuar ou abortar o rebase

Resolveu o conflito? Continue. Complicou? Aborte.

git rebase --continue
git rebase --skip
git rebase --abort

57. git cherry-pick

Leva um commit específico para a branch atual — clássico do hotfix.

git cherry-pick a1b2c3d
git cherry-pick a1b2c3d..e4f5g6h

58. Merge x rebase: quando usar

Rebase na sua branch antes do PR; merge para integrar na main. Nunca faça rebase de branch compartilhada.

# Bom: atualizar sua feature
git switch minha-feature && git rebase main

# Bom: integrar na principal
git switch main && git merge --no-ff minha-feature

Trabalhando com remotos

Sincronizar seu clone com o servidor — e entender a diferença entre fetch e pull.

59. Listar remotos

Mostra os endereços configurados para buscar e enviar.

git remote -v

60. Adicionar remoto

Conecta o repositório local a um servidor.

git remote add origin git@github.com:usuario/projeto.git

61. Trocar a URL do remoto

Usado ao migrar de HTTPS para SSH ou ao mudar de organização.

git remote set-url origin git@github.com:usuario/projeto.git

62. git fetch

Baixa as novidades sem mexer no seu trabalho. O comando mais seguro do Git.

git fetch origin

63. git pull

É fetch + merge em um passo só. Traz e já integra na sua branch.

git pull origin main

64. Pull com rebase

Integra reaplicando seus commits por cima — sem commit de merge no meio do caminho.

git pull --rebase origin main

65. git push

Envia seus commits para o servidor.

git push origin main

66. Push da primeira vez

-u vincula a branch local à remota; depois basta git push.

git push -u origin minha-feature

67. Push forçado com segurança

--force-with-lease recusa se alguém publicou algo que você ainda não viu. Sempre prefira este ao --force.

git push --force-with-lease origin minha-feature

68. Enviar tags

Tags não sobem no push comum.

git push origin v1.2.0
git push origin --tags

69. Comparar com o remoto

Quantos commits você está à frente ou atrás.

git fetch
git status -sb
git log --oneline origin/main..HEAD   # o que você tem a mais

70. Trabalhar com fork (upstream)

Mantém seu fork em dia com o projeto original.

git remote add upstream https://github.com/original/projeto.git
git fetch upstream
git merge upstream/main

Desfazendo (o capítulo que salva a pele)

Quase tudo no Git é reversível. A diferença está em o que já foi publicado.

71. Descartar alteração de um arquivo

Volta o arquivo ao último commit. Perde o que não foi salvo.

git restore arquivo.ts
git checkout -- arquivo.ts   # forma antiga

72. Descartar tudo que não foi commitado

Zera o diretório de trabalho. Use com consciência.

git restore .

73. Tirar da staging area

Remove do que está preparado, mas mantém a alteração no arquivo.

git restore --staged arquivo.ts
git reset arquivo.ts         # forma antiga

74. git reset --soft

Desfaz o commit e mantém tudo preparado. Ideal para refazer a mensagem ou juntar commits.

git reset --soft HEAD~1

75. git reset --mixed

Desfaz o commit e tira da staging, preservando os arquivos. É o padrão.

git reset HEAD~1

76. git reset --hard

Desfaz o commit e apaga as alterações. Não tem desfazer — a não ser pelo reflog.

git reset --hard HEAD~1

77. git revert

Cria um commit novo que desfaz outro. É a forma correta de reverter algo já publicado.

git revert a1b2c3d

78. Reverter um merge

Precisa indicar qual lado é o principal (-m 1).

git revert -m 1 a1b2c3d

79. git reflog — a rede de segurança

Registra tudo por onde o HEAD passou, inclusive commits perdidos por reset. Salva quase qualquer situação.

git reflog
git reset --hard HEAD@{2}

80. Recuperar arquivo apagado

Traz de volta a versão de um commit específico.

git restore --source=HEAD~3 arquivo.ts

81. Recuperar branch apagada

Ache o commit no reflog e recrie a branch nele.

git reflog
git branch minha-feature-recuperada a1b2c3d

82. git clean

Apaga arquivos não rastreados. Rode com -n antes para ver o que sairia.

git clean -n        # simula
git clean -fd       # apaga arquivos e diretórios
git clean -fdx      # inclui o que está no .gitignore

83. Voltar um arquivo a um commit antigo

Só aquele arquivo volta no tempo; o resto fica como está.

git checkout a1b2c3d -- caminho/arquivo.ts

84. Remover segredo do histórico

Um .env commitado continua no histórico até ser reescrito — e o token precisa ser trocado de qualquer forma.

git filter-repo --path .env --invert-paths
# depois: git push --force-with-lease (combine com o time antes)

Histórico e investigação

Descobrir quando, por que e por culpa de qual commit aquilo quebrou.

85. git log

O histórico. Sozinho é verboso demais — as variações abaixo valem mais.

git log
git log -5

86. Log em uma linha com grafo

A visão mais útil: compacta, com ramificações desenhadas.

git log --oneline --graph --decorate --all

87. Filtrar por autor e data

Recorta o histórico por quem e quando.

git log --author="Jhonatan" --since="2 weeks ago"

88. Buscar por texto no código

Acha o commit que introduziu (ou removeu) determinado trecho.

git log -S "getThemeSelection" --oneline

89. Histórico de um arquivo

Só os commits que tocaram naquele caminho; --follow acompanha renomeações.

git log --follow -p -- src/lib/theme/presets.ts

90. git show

Mostra um commit inteiro: mensagem, autor e diff.

git show a1b2c3d

91. git blame

Diz quem escreveu cada linha e em qual commit. Use para entender, não para culpar.

git blame src/app/page.tsx
git blame -L 40,60 src/app/page.tsx

92. git bisect

Busca binária no histórico: acha em poucos passos o commit que quebrou.

git bisect start
git bisect bad                 # o atual está quebrado
git bisect good v1.0.0         # aqui funcionava
# teste, marque good/bad, repita
git bisect reset

93. Quem mais contribuiu

Resumo por autor.

git shortlog -sn --all

94. Ver um arquivo de outro commit

Sem trocar de branch nem mexer no diretório.

git show a1b2c3d:src/app/page.tsx

Stash, tags e submódulos

Guardar trabalho pela metade, marcar versões e reunir repositórios.

95. git stash

Guarda as alterações e limpa o diretório — para trocar de contexto às pressas.

git stash
git stash push -m "meio da refatoração"

96. Recuperar o stash

pop aplica e remove da pilha; apply mantém guardado.

git stash list
git stash pop
git stash apply stash@{1}

97. Stash incluindo arquivos novos

Por padrão o stash ignora o que não está rastreado.

git stash -u

98. Criar tag anotada

Marca uma versão com autor, data e mensagem. Prefira à tag simples.

git tag -a v1.2.0 -m "Release 1.2.0"
git push origin v1.2.0

99. Listar e apagar tags

Apagar exige remover local e remotamente.

git tag -l "v1.*"
git tag -d v1.2.0
git push origin --delete v1.2.0

100. Submódulos

Um repositório dentro do outro, preso a um commit específico.

git submodule add https://github.com/usuario/lib.git libs/lib
git submodule update --init --recursive
git clone --recurse-submodules https://github.com/usuario/projeto.git