Folha de Referência Git: Comandos Essenciais para Todo Desenvolvedor

31 de março de 2026 · 12 min de leitura

Git é o sistema de controle de versão mais amplamente utilizado no mundo, alimentando milhões de projetos desde projetos paralelos solo até aplicações empresariais. Seja você um desenvolvedor solo ou parte de uma grande equipe, conhecer os comandos essenciais do Git economiza tempo e previne erros.

Esta folha de referência abrangente cobre todos os comandos que você precisará para o trabalho de desenvolvimento diário, desde operações básicas até fluxos de trabalho avançados. Organizamos por tipo de tarefa para que você possa encontrar rapidamente o que precisa quando precisar.

Marque esta página como sua referência rápida. Para formatar sua documentação Git e arquivos README, experimente nosso Editor Markdown.

Configuração Inicial

Antes do seu primeiro commit, você precisa configurar sua identidade. Essas configurações são armazenadas globalmente e anexadas a cada commit que você faz, para que outros desenvolvedores saibam quem fez quais alterações.

Configuração Inicial

git config --global user.name "Seu Nome"
git config --global user.email "[email protected]"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"

A flag --global aplica essas configurações a todos os repositórios em sua máquina. Se você precisar de configurações diferentes para um projeto específico, execute os mesmos comandos sem --global dentro daquele repositório.

Opções de Configuração Úteis

git config --global color.ui auto              # Habilitar saída colorida
git config --global core.autocrlf true         # Lidar com finais de linha (Windows)
git config --global core.autocrlf input        # Lidar com finais de linha (Mac/Linux)
git config --global pull.rebase false          # Usar estratégia de mesclagem para pulls
git config --global alias.st status            # Criar atalho: git st
git config --global alias.co checkout          # Criar atalho: git co
git config --global alias.br branch            # Criar atalho: git br
git config --global alias.ci commit            # Criar atalho: git ci

Visualizando e Editando Configuração

git config --list                              # Ver todas as configurações
git config --list --show-origin                # Mostrar onde cada configuração está definida
git config user.name                           # Ver configuração específica
git config --global --edit                     # Editar configuração global no editor

Criando Repositórios

Existem duas maneiras de começar a trabalhar com Git: inicializar um novo repositório ou clonar um existente de um servidor remoto.

Inicializar um Novo Repositório

git init                                       # Inicializar repo no diretório atual
git init meu-projeto                           # Criar novo diretório com repo
git init --bare repositorio-compartilhado.git  # Criar repo bare (para servidores)

Quando você executa git init, o Git cria um diretório oculto .git que armazena todas as informações de controle de versão. Este diretório contém todo o histórico do projeto, configuração e metadados.

Clonar um Repositório Existente

git clone https://github.com/usuario/repo.git  # Clonar via HTTPS
git clone [email protected]:usuario/repo.git      # Clonar via SSH
git clone <url> minha-pasta                    # Clonar em diretório específico
git clone --depth 1 <url>                      # Clone superficial (apenas último commit)
git clone --branch develop <url>               # Clonar branch específico

Clones superficiais são úteis para pipelines CI/CD ou quando você precisa apenas do código mais recente sem o histórico completo. Eles são significativamente mais rápidos e usam menos espaço em disco.

Comandos Básicos de Fluxo de Trabalho

O fluxo de trabalho principal do Git gira em torno de três áreas: o diretório de trabalho (seus arquivos), a área de preparação (alterações prontas para commit) e o repositório (histórico commitado). Entender esse fluxo é crucial para usar o Git efetivamente.

Verificando Status

git status                                     # Verificar status da árvore de trabalho
git status -s                                  # Saída em formato curto
git status -sb                                 # Formato curto com informações de branch

Execute git status frequentemente. Ele mostra quais arquivos estão modificados, preparados ou não rastreados, e ajuda você a entender o estado atual do seu repositório.

Preparando Alterações

git add arquivo.txt                            # Preparar um arquivo específico
git add *.js                                   # Preparar todos os arquivos JavaScript
git add .                                      # Preparar todas as alterações
git add -A                                     # Preparar todas as alterações (incluindo exclusões)
git add -p                                     # Preparar alterações interativamente (modo patch)
git add -u                                     # Preparar apenas arquivos modificados e excluídos

A área de preparação (também chamada de índice) permite que você crie commits precisos. Você pode preparar apenas as alterações que deseja incluir, mesmo que tenha modificado vários arquivos.

Commitando Alterações

git commit -m "Adicionar autenticação de usuário"  # Commit com mensagem
git commit -am "Corrigir bug de login"              # Preparar arquivos rastreados + commit
git commit --amend                                  # Modificar o último commit
git commit --amend --no-edit                        # Emendar sem alterar mensagem
git commit -v                                       # Mostrar diff no editor de mensagem de commit

Escreva mensagens de commit claras e descritivas. Um bom formato é: um resumo curto (50 caracteres ou menos), seguido por uma linha em branco, depois uma explicação detalhada se necessário.

Visualizando Alterações

git diff                                       # Mostrar alterações não preparadas
git diff --staged                              # Mostrar alterações preparadas
git diff HEAD                                  # Mostrar todas as alterações desde o último commit
git diff branch1..branch2                      # Comparar dois branches
git diff --stat                                # Mostrar estatísticas de alterações
git diff --word-diff                           # Mostrar diferenças no nível de palavra

Ramificação e Mesclagem

Branches são uma das características mais poderosas do Git. Eles permitem que você trabalhe em recursos, correções ou experimentos isoladamente sem afetar a base de código principal.

Gerenciamento de Branches

git branch                                     # Listar branches locais
git branch -a                                  # Listar todos os branches (local + remoto)
git branch feature-login                       # Criar novo branch
git branch -d feature-login                    # Excluir branch (seguro)
git branch -D feature-login                    # Forçar exclusão de branch
git branch -m nome-antigo nome-novo            # Renomear branch
git branch -vv                                 # Mostrar branches com informações de rastreamento

Alternando Branches

git checkout feature-login                     # Alternar para branch
git checkout -b feature-signup                 # Criar e alternar para novo branch
git checkout -                                 # Alternar para branch anterior
git switch feature-login                       # Maneira moderna de alternar branches
git switch -c feature-signup                   # Criar e alternar (sintaxe moderna)

O comando git switch foi introduzido no Git 2.23 como uma alternativa mais clara ao git checkout, que tem múltiplos propósitos. Ambos funcionam identicamente para alternar branches.

Mesclando Branches

git merge feature-login                        # Mesclar branch no branch atual
git merge --no-ff feature-login                # Forçar commit de mesclagem (sem fast-forward)
git merge --squash feature-login               # Comprimir commits em um
git merge --abort                              # Cancelar mesclagem em andamento

Quando você mescla, o Git combina as alterações de dois branches. Se ambos os branches modificaram as mesmas linhas, você terá um conflito de mesclagem que precisa de resolução manual.

Resolvendo Conflitos de Mesclagem

Quando ocorrem conflitos, o Git marca as seções conflitantes em seus arquivos:

<<<<<<< HEAD
Suas alterações atuais
=======
Alterações recebidas do branch sendo mesclado
>>>>>>> feature-branch

Para resolver conflitos:

1. Abra os arquivos conflitantes e edite-os para resolver os conflitos
2. Remova os marcadores de conflito (<<<<<<<, =======, >>>>>>>)
3. Prepare os arquivos resolvidos com git add
4. Complete a mesclagem com git commit

git status                                     # Ver quais arquivos têm conflitos
git add arquivo-resolvido.js                   # Marcar conflito como resolvido
git merge --continue                           # Continuar mesclagem após resolver
git merge --abort                              # Desistir e começar de novo

Rebase

git rebase main                                # Fazer rebase do branch atual em main
git rebase -i HEAD~3                           # Rebase interativo dos últimos 3 commits
git rebase --continue                          # Continuar após resolver conflitos
git rebase --abort                             # Cancelar rebase em andamento
git rebase --skip                              # Pular commit atual durante rebase

Fazer rebase reescreve o histórico movendo seus commits para uma nova base. Ele cria um histórico mais limpo e linear, mas nunca deve ser feito em branches públicos que outros estão usando.

Operações Remotas

Repositórios remotos são versões do seu projeto hospedadas na internet ou rede. Eles permitem colaboração e backup.

Gerenciando Remotos

git remote                                     # Listar conexões remotas
git remote -v                                  # Listar remotos com URLs
git remote add origin <url>                    # Adicionar novo remoto
git remote remove origin                       # Remover remoto
git remote rename origin upstream              # Renomear remoto
git remote set-url origin <nova-url>           # Alterar URL remota
git remote show origin                         # Mostrar informações detalhadas do remoto

Buscando e Puxando

git fetch                                      # Baixar alterações remotas
git fetch origin                               # Buscar de remoto específico
git fetch --all                                # Buscar de todos os remotos
git fetch --prune                              # Remover branches remotos excluídos
git pull                                       # Buscar e mesclar alterações remotas
git pull --rebase                              # Buscar e fazer rebase em vez de mesclar
git pull origin main                           # Puxar branch específico

A diferença entre fetch e pull: fetch baixa alterações mas não modifica seu diretório de trabalho, enquanto pull busca e imediatamente mescla as alterações.

Enviando Alterações

git push                                       # Enviar para remoto/branch padrão
git push origin main                           # Enviar para remoto/branch específico
git push -u origin feature-login               # Enviar e definir rastreamento upstream
git push --all                                 # Enviar todos os branches
git push --tags                                # Enviar todas as tags
git push --force                               # Forçar envio (perigoso!)
git push --force-with-lease                    # Envio forçado mais seguro