Guia rápido de Git — comandos por tarefa
Comandos do Git organizados pelo que você quer fazer: desfazer o último commit, renomear uma branch, apagar uma branch remota. switch/restore modernos com os equivalentes clássicos e alertas de perigo.
Última verificação: 2026-10-18, conferido com a referência do git-scm.com para o Git 2.56 e o manual do GitHub CLI. Fontes: Git reference (git-scm.com/docs), git restore, git switch, git reset, git config, GitHub CLI manual.
Configuração (uma vez por máquina)
Com --global, as configurações vão para ~/.gitconfig. Desde o Git 2.46, a forma documentada é git config set / get / list; a forma clássica continua funcionando.
git config set --global user.name "Ana Lee" git config set --global user.email "ana@example.com"
Forma clássica: git config --global user.name "Ana Lee"
Fica registrado em cada commit que você faz. Use o e-mail que seu serviço Git conhece para que os commits fiquem vinculados à sua conta.
git config set --global init.defaultBranch main
Forma clássica: git config --global init.defaultBranch main
Sem isso, o git init ainda chama a primeira branch de master (e mostra uma dica).
git config set --global core.editor "code --wait"
Forma clássica: git config --global core.editor "code --wait"
Funciona qualquer comando que fique bloqueado até o arquivo ser fechado: "nano", "vim", "subl -n -w".
git config set --global core.autocrlf true # Windows git config set --global core.autocrlf input # macOS, Linux
Forma clássica: git config --global core.autocrlf true
Faz commit com LF e faz checkout com CRLF no Windows. Para uma equipe inteira, um arquivo .gitattributes com "* text=auto" é mais confiável que configurações individuais.
git --version
git switch e git restore exigem 2.23+, os subcomandos do git config 2.46+.
Iniciar um repositório
git init
git init -b main # name the first branchCria um diretório .git. Adicione um .gitignore antes do primeiro commit para que arquivos de build e segredos nunca entrem.
git clone https://github.com/owner/repo.git git clone git@github.com:owner/repo.git my-folder
Baixa todo o histórico e define o remoto "origin". A segunda forma usa SSH e um nome de pasta personalizado.
git clone --depth 1 https://github.com/owner/repo.git
Pula o histórico; bom para CI e repositórios grandes. git fetch --unshallow traz o resto depois.
git remote add origin git@github.com:owner/repo.git git push -u origin main
Crie antes o repositório vazio no serviço (ou use gh repo create, abaixo). -u guarda origin/main como upstream.
Stage e commit
git status
git status -s # short formLista arquivos no stage, fora do stage e não rastreados, e sugere o próximo comando.
git add file.txt
git add . # everything in this folder and belowgit add -A também adiciona ao stage exclusões em qualquer parte do repositório.
git add -p file.txt
Percorre cada alteração ("hunk"): y para adicionar, n para pular, s para dividir, e para editar.
git commit -m "Add login form"
git commit -am "Fix typo" # stage tracked files and commit-a inclui arquivos rastreados modificados e excluídos, nunca arquivos novos.
git mv old.txt new.txt git rm file.txt
Os dois já adicionam a alteração ao stage. O Git detecta renomeações pelo conteúdo, então um mv comum seguido de git add também funciona.
git rm --cached .env echo ".env" >> .gitignore
Remove o arquivo do repositório a partir do próximo commit. Ele continua nos commits anteriores: se continha um segredo, troque o segredo.
Branches
git branch git branch -a # include remote branches git branch -vv # show upstream and ahead/behind
A branch atual é marcada com *.
git switch -c feature/login
Forma clássica: git checkout -b feature/login
Começa no commit atual; adicione um ponto de partida para criar a partir de outro lugar: git switch -c hotfix origin/main.
git switch main
git switch - # back to the previous branchForma clássica: git checkout main
Se só existir origin/feature, git switch feature cria automaticamente uma branch local que a rastreia.
git branch -m new-name # current branch
git branch -m old-name new-nameRenomeia só localmente. Para renomear também no remoto, veja o próximo item.
git branch -m old-name new-name git push -u origin new-name git push origin --delete old-name
Não existe renomear no remoto: envie o novo nome e apague o antigo. Pull requests abertos no nome antigo podem ser fechados; o botão de renomear na interface web do GitHub os redireciona.
git branch -d feature/login
git branch -D feature/login # even if unmerged-d se recusa se a branch tiver commits não mesclados no upstream ou no HEAD; -D apaga mesmo assim.
Recuperação: Commits não mesclados continuam no reflog: rode git reflog, encontre a ponta e depois git branch feature/login <sha>.
git push origin --delete feature/login
Forma clássica: git push origin :feature/login
Os colegas continuam vendo a branch até rodarem git fetch --prune.
Recuperação: Qualquer pessoa com a branch local (ou você, via git reflog) pode enviá-la de volta.
git branch -u origin/main
git push -u origin HEAD # push current branch and track itForma clássica: git branch --set-upstream-to=origin/main
O upstream é o que git pull e git push usam sem argumentos.
git switch --detach a1b2c3d
git switch -c rescue # keep work made thereForma clássica: git checkout a1b2c3d
Commits feitos com o HEAD destacado não pertencem a nenhuma branch; crie uma antes de mudar de lugar, senão eles só ficam acessíveis pelo reflog.
Merge, rebase e cherry-pick
git switch main
git merge feature/login
git merge --no-ff feature/login # always create a merge commitFaz fast-forward quando possível; --no-ff mantém a branch visível no histórico.
git merge --squash feature/login git commit -m "Add login"
Adiciona ao stage as alterações combinadas sem registrar um merge; depois disso, a branch não aparece como mesclada.
git status # list conflicted files # edit the files, remove <<<<<<< ======= >>>>>>> markers git add file.txt git commit # or: git rebase --continue
Para ficar inteiramente com um dos lados, use git restore --ours file.txt ou --theirs. Durante um rebase, "ours" é a branch sobre a qual se faz o rebase, o contrário de um merge.
git merge --abort
Volta ao estado anterior ao início do merge.
Recuperação: As resoluções de conflito que você fez são perdidas. Se havia alterações sem commit quando o merge começou, o --abort talvez não consiga restaurá-las; por isso, faça commit ou stash antes do merge.
git switch feature/login git rebase main
Reaplica seus commits em cima da main para um histórico linear. Resolva os conflitos, git add e depois git rebase --continue; --abort desiste.
Recuperação: Logo depois: git reset --hard ORIG_HEAD. Mais tarde: encontre a ponta antiga no git reflog.
git rebase -i HEAD~3
Abre uma lista: troque pick por squash/fixup para combinar, reword para editar uma mensagem, drop para apagar, ou reordene as linhas.
Recuperação: git reflog mostra o commit anterior ao rebase; git reset --hard <sha> o restaura.
git commit --fixup=a1b2c3d git rebase -i --autosquash a1b2c3d~1
O commit de fixup é incorporado a a1b2c3d automaticamente quando você faz o rebase.
Recuperação: Igual ao rebase interativo: git reflog.
git pull --rebase
git config set --global pull.rebase true # make it the defaultFaz rebase dos seus commits locais em cima do que foi baixado.
git cherry-pick a1b2c3d
git cherry-pick -x a1b2c3d # note the source in the messageCria um novo commit com as mesmas alterações. Um intervalo: git cherry-pick A..B (exclui A).
Remotos: fetch, pull, push
git remote -v git remote set-url origin git@github.com:owner/repo.git
set-url muda um clone de HTTPS para SSH (ou para um repositório renomeado).
git fetch
git fetch --prune # also drop deleted remote branchesAtualiza só origin/*; suas branches não são tocadas.
git pull
git fetch mais merge (ou rebase, se pull.rebase estiver definido).
git push
git push -u origin HEAD # first push of a new branch
git config set --global push.autoSetupRemote trueCom push.autoSetupRemote (Git 2.37+), um simples git push em uma branch nova já define o upstream.
git push --force-with-lease
Se recusa se o remoto tiver commits que você não baixou, ao contrário do --force. Adicione --force-if-includes (Git 2.30+) para mais segurança com fetches em segundo plano.
Recuperação: Commits remotos sobrescritos sobrevivem no reflog de quem os tinha, e o GitHub os mantém acessíveis pelo SHA por um tempo.
git remote add upstream https://github.com/original/repo.git git fetch upstream git switch main git merge upstream/main
Ou com o GitHub CLI: gh repo sync.
Desfazer coisas
Escolha pelo lugar onde está o erro: na árvore de trabalho, na staging area, em um commit local ou em um commit já enviado. Tudo o que já passou por um commit geralmente pode ser encontrado de novo com git reflog; edições sem commit que você descarta, não.
git reset --soft HEAD~1
O commit some; as alterações continuam no stage, prontas para um novo commit. Use git reset HEAD~1 (sem --soft) para mantê-las fora do stage.
Recuperação: git reset ORIG_HEAD traz o commit de volta. Se ele já foi enviado, use git revert.
git reset --hard HEAD~1
Volta a branch um commit e redefine todos os arquivos rastreados para corresponder.
Recuperação: O commit está no git reflog (entradas inacessíveis expiram após 30 dias por padrão): git reset --hard HEAD@{1}. Alterações sem commit em arquivos rastreados se perdem para sempre.
git revert a1b2c3d
git revert HEAD # the latest commitAdiciona um novo commit que reverte o antigo, então o histórico de ninguém muda. É a forma segura de desfazer em branches compartilhadas.
git revert -m 1 <merge-sha>
-m 1 mantém o primeiro pai (geralmente a main). Para mesclar a branch de novo depois, é preciso antes reverter este revert.
git commit --amend -m "Better message"
Substitui o último commit por um novo. Tudo bem antes do push; depois do push, exige --force-with-lease.
Recuperação: git reset --soft HEAD@{1} volta ao commit anterior ao amend.
git add forgotten.txt git commit --amend --no-edit
Mantém a mensagem e adiciona o arquivo.
Recuperação: git reset --soft HEAD@{1}.
git restore --staged file.txt
git restore --staged . # everythingForma clássica: git reset HEAD file.txt
As alterações continuam na árvore de trabalho; só o stage é desfeito.
git restore file.txt
Forma clássica: git checkout -- file.txt
Redefine o arquivo para a versão no stage (ou para o último commit, se não houver nada no stage).
Recuperação: Não dá para recuperar pelo Git: as edições nunca passaram por um commit. O histórico local do seu editor talvez ainda as tenha.
git restore --staged --worktree .
git clean -fd # also delete untracked filesForma clássica: git reset --hard
git clean -fd
Volta ao último commit. Rode git clean -n antes para ver o que seria apagado.
Recuperação: Não recuperável: edições sem commit e arquivos não rastreados são apagados. git stash -u é a alternativa reversível.
git restore file.txt # deletion not committed git restore --source=a1b2c3d~1 file.txt # deleted in commit a1b2c3d
Forma clássica: git checkout a1b2c3d~1 -- file.txt
Encontre o commit que o excluiu com git log --diff-filter=D -- file.txt.
git restore --source=main -- config.yml
Forma clássica: git checkout main -- config.yml
Sobrescreve só a cópia de trabalho; adicione --staged --worktree para colocá-lo no stage também. Só para ver: git show main:config.yml.
Recuperação: Edições sem commit nesse arquivo são sobrescritas.
git reflog git branch rescued a1b2c3d
O reflog registra cada lugar por onde o HEAD passou. Encontre o SHA de antes do erro e crie uma branch nele.
git reset --hard ORIG_HEAD
O ORIG_HEAD é definido por merge, rebase e reset com a posição anterior. Ele é sobrescrito pelo próximo comando desse tipo.
Recuperação: O git reflog ainda lista o commit de merge.
git reflog # find "rebase (start)"; the entry below it is the old tip
git reset --hard HEAD@{5}Logo depois do rebase, git reset --hard ORIG_HEAD faz o mesmo.
Recuperação: Alterações sem commit são descartadas pelo --hard; faça stash delas antes.
git reset --hard HEAD@{1}HEAD@{1} é onde o HEAD estava antes do último movimento. Só funciona para trabalho que passou por commit.
git filter-repo --invert-paths --path secrets.env
O git filter-repo é uma ferramenta separada (pip install git-filter-repo), recomendada pela documentação do git-filter-branch. Depois disso, todo mundo precisa clonar de novo. Troque o segredo de qualquer forma: ele ficou público no momento do push.
Recuperação: O filter-repo trabalha em um clone novo; guarde o clone antigo até ter certeza.
Stash
git stash
git stash push -m "half-done login"
git stash -u # include untracked filesGuarda as alterações rastreadas e limpa a árvore de trabalho para você poder trocar de branch.
git stash pop # apply and drop git stash apply stash@{1} # apply, keep the stash
Pode haver conflitos; com pop, o stash é mantido se a aplicação falhar.
git stash list
git stash show -p stash@{0}Mais recentes primeiro; stash@{0} é o último.
git stash push -- src/login.ts
git stash push --staged # only what is staged (2.35+)Stashes limitados a caminhos deixam todo o resto no lugar.
git stash branch feature/login stash@{0}Cria a branch no commit em que você fez o stash, aplica o stash e o descarta; evita conflitos.
git stash drop stash@{0}
git stash clearclear remove todos os stashes.
Recuperação: Um stash descartado é um commit inacessível até a coleta de lixo: git fsck --unreachable | grep commit, depois git stash apply <sha>.
Histórico e diffs
git log --oneline --graph --all
Uma linha por commit com a estrutura de branches. Em versões muito antigas do Git, adicione --decorate para ver os nomes das branches.
git log --follow -p -- path/file.txt
--follow continua através de renomeações; -p mostra cada alteração.
git log -S "functionName" --oneline git log -G "regex" --oneline
-S procura mudanças no número de ocorrências; -G compara qualquer linha alterada com uma regex.
git log --author="Ana" --since="2 weeks ago" --oneline
Também --until, --grep="fix" para mensagens, e main..feature para commits que estão em feature mas não na main.
git show a1b2c3d git show a1b2c3d:path/file.txt
A segunda forma imprime o arquivo como estava naquele commit, sem mexer na sua cópia.
git diff # unstaged git diff --staged # staged, i.e. what will be committed
--stat resume por arquivo; --word-diff é melhor para texto corrido.
git diff main...feature # changes on feature since it branched git diff main feature # the two tips directly
Três pontos comparam com a base do merge, que é o que um pull request mostra.
git blame -L 10,20 path/file.txt
Adicione -w para ignorar espaços em branco e -C para seguir linhas movidas de outros arquivos.
git bisect start git bisect bad # current commit is broken git bisect good v1.4.0 # this one worked # test, then mark each step good or bad git bisect reset
Busca binária: cerca de log2(n) passos. git bisect run ./test.sh automatiza o processo.
git grep -n "TODO"
Mais rápido que o grep em repositórios grandes e ignora arquivos ignorados. Adicione um commit para pesquisar uma versão antiga.
Tags e releases
git tag -a v1.2.0 -m "Release 1.2.0"
git tag -a v1.1.1 a1b2c3d -m "Hotfix" # tag an older commitTags anotadas (-a) guardam autor, data e mensagem; prefira-as para releases. git tag v1.2.0 sozinho cria uma tag leve.
git tag -d v1.2.0 git push origin --delete v1.2.0
Evite reutilizar o nome de uma tag de release apagada: outros clones mantêm a tag antiga.
Recuperação: O commit marcado não é afetado; recrie a tag nele.
Submódulos e worktrees
git submodule add https://github.com/owner/lib.git vendor/lib git commit -m "Add lib submodule"
Registra o URL em .gitmodules e fixa um commit exato do outro repositório.
git clone --recurse-submodules <url>
git submodule update --init --recursive # already clonedSem isso, as pastas dos submódulos ficam vazias.
git submodule update --remote git commit -am "Bump submodules"
Busca a branch rastreada de cada submódulo; faça commit das novas fixações no repositório pai.
git worktree add ../repo-hotfix hotfix git worktree add -b review ../repo-review origin/main
Uma segunda pasta de trabalho que compartilha o mesmo repositório; sem precisar de stash nem de um segundo clone.
git worktree list
git worktree remove ../repo-hotfix
git worktree prune # forget folders deleted by handremove se recusa se a worktree tiver alterações sem commit (use --force para forçar).
Limpeza
git clean -n -d
Sempre rode isto antes de git clean -f.
git clean -fd # untracked files and folders git clean -fdx # also ignored files (build output, .env!)
-x também remove arquivos ignorados, o que inclui configurações locais como .env.
Recuperação: Não recuperável: esses arquivos nunca estiveram no Git.
git branch --merged main git branch -d branch-a branch-b
Revise a lista antes; -d se recusa a apagar branches não mescladas, então é seguro tentar.
git fetch --prune git config set --global fetch.prune true
Descarta as refs origin/* cujas branches foram apagadas no servidor.
git maintenance start git gc
maintenance start agenda tarefas em segundo plano de prefetch, commit-graph e repack; gc compacta os objetos e remove os inacessíveis na hora.
Configuração e aliases
git config list --show-origin
Forma clássica: git config --list --show-origin
Mostra os valores do sistema, globais e do repositório, com o arquivo onde está cada um.
git config set --global alias.st "status -s" git config set --global alias.lg "log --oneline --graph --all"
Forma clássica: git config --global alias.st "status -s"
Depois use git st e git lg. Comece com ! para rodar um comando do shell: alias.root "!pwd".
git config set --global pull.rebase true git config set --global push.autoSetupRemote true git config set --global rerere.enabled true git config set --global merge.conflictStyle zdiff3 git config set --global diff.algorithm histogram
Forma clássica: git config --global pull.rebase true
Rebase no pull; upstream automático no primeiro push (2.37+); lembrar resoluções de conflito; mostrar o ancestral comum nos conflitos (2.35+); diffs mais claros.
git config set --global core.excludesFile ~/.gitignore_global
Forma clássica: git config --global core.excludesFile ~/.gitignore_global
Para a bagunça do sistema e do editor (.DS_Store, .idea/). Regras específicas do projeto ficam no .gitignore do repositório.
Noções básicas do GitHub CLI (gh)
O gh é a ferramenta de linha de comando do próprio GitHub, instalada separadamente do Git.
gh auth login
gh auth setup-git # let git use gh for HTTPS credentialsAbre um navegador ou aceita um token; funciona com github.com e GitHub Enterprise.
gh repo create my-app --private --source=. --push
Cria o repositório, adiciona como origin e envia a branch atual.
gh repo clone owner/repo
Em um fork, também adiciona o repositório pai como remoto upstream.
gh pr create --fill gh pr create --draft --title "WIP: login" --body "…"
--fill usa as mensagens de commit no título e no corpo.
gh pr checkout 123
Baixa a branch do PR (inclusive de forks) e muda para ela.
gh pr list gh pr view 123 --web gh pr merge 123 --squash --delete-branch
gh pr status mostra os PRs relevantes para você.
gh issue create --title "Bug: …" --body "…" gh issue list --assignee @me
gh issue view 42 --comments lê uma conversa no terminal.
gh run list gh run watch
gh run view --log-failed mostra só as etapas que falharam.
Precisa de um .gitignore inicial? Use o gerador de .gitignore. Quer comparar duas versões de um arquivo fora do Git? O comparador de textos mostra as diferenças lado a lado.
Uma referência estática: a busca roda no seu navegador e nada do que você digita é enviado para lugar nenhum. Ver todas as ferramentas grátis.
Encontrou um problema ou algo que poderia ser melhor? Lemos todas as mensagens e corrigimos rápido.
Este guia rápido de Git é organizado por tarefa, e não por comando, porque ninguém pesquisa “git reset --soft”; as pessoas pesquisam “desfazer último commit”. Encontre o que você está tentando fazer, copie o comando e leia a explicação de uma linha sobre o que ele muda. A busca prioriza as tarefas, então “apagar branch remota” ou “renomear branch” leva direto à entrada certa.
Comandos que reescrevem o histórico ou jogam trabalho fora vêm marcados, com uma nota sobre o que pode ser recuperado: quase tudo que já foi commitado pode ser encontrado de novo com git reflog, enquanto edições não commitadas que você descarta com restore, reset --hard ou clean se perdem. Onde o Git hoje tem um comando mais claro (git switch e git restore desde a 2.23, git config set e list desde a 2.46), ele aparece primeiro, com a forma clássica ao lado, para que o guia sirva tanto para quem aprendeu Git no ano passado quanto em 2010. Conferido com a referência do git-scm.com para o Git 2.56.
Como usar
- Digite o que você quer fazer na caixa de pesquisa, como “desfazer último commit”, “tirar do stage” ou “juntar commits”, ou clique em uma das buscas em “Mais buscados”.
- Leia os alertas antes de executar qualquer coisa: âmbar significa que o comando reescreve o histórico; vermelho significa que ele pode descartar trabalho. A nota de recuperação explica como voltar atrás.
- Clique em Copiar comando. A cópia deixa de fora os comentários com #, para colar sem problemas no terminal; substitua marcadores como a1b2c3d ou feature/login pelos seus.
- Compartilhe uma resposta específica com o link # ao lado de cada tarefa ou imprima o guia inteiro como PDF em duas colunas.
Perguntas frequentes
Como desfaço o último commit no Git?
Se você ainda não fez push, git reset --soft HEAD~1 remove o commit e mantém as alterações no stage, e git reset HEAD~1 as mantém fora do stage. git reset --hard HEAD~1 remove o commit e as alterações. Se o commit já foi enviado para uma branch compartilhada, use git revert HEAD, que adiciona um novo commit desfazendo o anterior sem reescrever o histórico de ninguém.
Qual é a diferença entre git reset, git restore e git revert?
git restore altera arquivos: descarta edições na árvore de trabalho ou as tira do stage, e nunca move uma branch. git reset move a branch atual para outro commit (e, com --hard, também sobrescreve os seus arquivos), então reescreve o histórico. git revert cria um novo commit que aplica o oposto de um commit anterior; o histórico só cresce, o que o torna a escolha segura em branches que outras pessoas usam.
Como renomeio uma branch do Git, localmente e no remoto?
git branch -m novo-nome renomeia a branch em que você está (git branch -m antigo novo para outra branch). Remotos não têm operação de renomear, então envie o novo nome com git push -u origin novo-nome e apague o antigo com git push origin --delete nome-antigo. No GitHub, renomear a branch pela interface web também redireciona os pull requests abertos.
Devo usar git switch ou git checkout?
Os dois funcionam. O git checkout faz dois trabalhos sem relação entre si, trocar de branch e restaurar arquivos, e é por isso que o Git 2.23 os separou em git switch e git restore. Os novos comandos são mais claros e mais difíceis de usar errado (git checkout -- arquivo descarta edições sem avisar), então este guia os mostra primeiro. O git checkout não foi descontinuado, e cada comando aqui traz o equivalente clássico.
Consigo recuperar um commit depois de git reset --hard?
Normalmente, sim. Rode git reflog, encontre a linha de antes do reset e rode git reset --hard HEAD@{n} ou crie uma branch nesse SHA. Os commits continuam acessíveis pelo reflog por 30 dias, por padrão, depois que nada mais aponta para eles. O que não pode ser recuperado é o trabalho não commitado: alterações que nunca foram commitadas nem guardadas no stash são sobrescritas para sempre.
O que o git push --force-with-lease faz?
Ele sobrescreve a branch remota só se o remoto ainda apontar para onde o seu último fetch o viu. Se alguém fez push nesse meio-tempo, o push é recusado em vez de apagar os commits da outra pessoa sem avisar, que é o que o --force puro faz. Use-o depois de um rebase ou amend em uma branch que você já enviou.
Qual comando para desfazer? Decida pelo lugar onde a alteração está
• Editou um arquivo e quer desfazer a edição: git restore arquivo. Não tem recuperação, porque nunca foi commitado.
• Colocou algo no stage por engano: git restore --staged arquivo. Nada se perde; a edição continua no arquivo.
• Commitou, mas não fez push: git reset --soft HEAD~1 para refazer o commit, ou git commit --amend para corrigi-lo no lugar.
• Commitou e fez push para uma branch compartilhada: git revert <sha>. Não faça reset em uma branch que outras pessoas já puxaram.
• Perdeu um commit, uma branch ou o resultado de um rebase que deu errado: git reflog e depois git branch resgatado <sha>.
A regra por trás disso: qualquer coisa que reescreve commits não tem problema enquanto os commits forem só seus, e vira problema de todo mundo assim que eles são compartilhados.
Merge ou rebase?
Os dois trazem as alterações de uma branch para outra. Um merge registra que dois históricos se juntaram, com um commit de merge que tem dois pais; nada é reescrito, então é sempre seguro em branches compartilhadas. Um rebase reaplica os seus commits por cima da outra branch, produzindo um histórico em linha reta, como se você tivesse começado do commit mais recente, mas cria novos IDs de commit, então quem já tem os antigos precisa se acertar.
Uma convenção comum em equipes: faça rebase da sua branch de feature sobre a main para se manter atualizado (git pull --rebase ou git rebase main) e faça merge da branch pronta na main por meio de um pull request. O squash merge gera um commit por feature na main; merges simples mantêm todos os commits e o formato da branch. Escolha uma opção por repositório e configure-a no serviço de hospedagem, para o histórico ficar consistente.
Configurações do Git que vale a pena mudar
• pull.rebase true: o git pull faz rebase em vez de criar commits de merge a cada sincronização.
• push.autoSetupRemote true (Git 2.37+): o primeiro git push de uma nova branch define o upstream, sem precisar de -u.
• merge.conflictStyle zdiff3 (Git 2.35+): os marcadores de conflito incluem o ancestral comum, o que deixa a maioria dos conflitos óbvia.
• rerere.enabled true: o Git lembra como você resolveu um conflito e reaplica a solução quando o mesmo conflito volta durante um rebase.
• fetch.prune true: branches remotas apagadas no servidor desaparecem localmente no próximo fetch.
• init.defaultBranch main: novos repositórios começam na main.
Ferramentas grátis relacionadas
- Gerador de .gitignore — Combine modelos de .gitignore para linguagens, frameworks, editores e sistemas operacionais em um único arquivo limpo.
- Comparador de textos — Compare duas versões de um texto, código ou arquivo JSON e veja exatamente quais linhas, palavras e caracteres mudaram.
- Guia rápido de Markdown — Todos os elementos do Markdown com código e prévia renderizada, sintaxe estendida (tabelas, listas de tarefas, notas de rodapé, matemática, Mermaid, alertas), uma tabela de compatibilidade com 9 plataformas e um playground ao vivo.
- Guia rápido de regex — Todos os tokens de expressões regulares com um exemplo que funciona, suporte em JavaScript, PCRE/PHP, Python, Go, Java e .NET, e um link “Teste no testador de regex” que abre o testador de regex já preenchido.