Guia de Comandos Git Essenciais para Desenvolvedores

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

Git é a espinha dorsal do desenvolvimento de software moderno. Seja trabalhando sozinho ou colaborando com uma equipe de centenas, dominar os comandos Git é essencial para controle de versão eficiente e gerenciamento de código.

Este guia abrangente cobre tudo, desde operações básicas até técnicas avançadas. Salve esta página nos favoritos e consulte sempre que precisar de uma referência rápida para comandos Git.

Configuração Inicial

Antes de começar a usar o Git, você precisa configurar sua identidade e preferências. Essas configurações determinam como o Git se comporta e como seus commits são atribuídos.

Configuração Inicial

Execute estes comandos uma vez por máquina para configurar seu ambiente Git:

# Defina seu nome e email (obrigatório)
git config --global user.name "Seu Nome"
git config --global user.email "[email protected]"

# Defina o nome do branch padrão como 'main'
git config --global init.defaultBranch main

# Habilite saída colorida para melhor legibilidade
git config --global color.ui auto

# Defina seu editor de texto preferido
git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"          # Vim
git config --global core.editor "nano"         # Nano

# Visualize todas as configurações
git config --list

# Visualize configuração específica
git config user.name
git config user.email

A flag --global aplica configurações a todos os repositórios em sua máquina. Para configurar definições para um único repositório, navegue até esse repo e omita a flag --global.

Níveis de Configuração

Git tem três níveis de configuração, cada um substituindo o anterior:

Opções de Configuração Úteis

# Configure cache de credenciais (evite prompts repetidos de senha)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Habilite conversão automática de finais de linha
git config --global core.autocrlf true   # Windows
git config --global core.autocrlf input  # Mac/Linux

# Configure aliases para comandos comuns
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'

# Configure ferramentas de merge e diff
git config --global merge.tool vimdiff
git config --global diff.tool vimdiff

Comandos Básicos do Git

Estes são os comandos fundamentais que você usará diariamente. Domine-os primeiro antes de passar para operações avançadas.

Inicialização de Repositório

# Inicialize um novo repositório Git
git init

# Inicialize com um nome de branch específico
git init -b main

# Clone um repositório existente
git clone https://github.com/usuario/repo.git
git clone [email protected]:usuario/repo.git  # SSH
git clone https://github.com/usuario/repo.git minha-pasta  # Nome de pasta personalizado

# Clone apenas o histórico recente (mais rápido para repos grandes)
git clone --depth 1 https://github.com/usuario/repo.git

Trabalhando com Alterações

# Verifique o status do diretório de trabalho
git status
git status -s  # Formato curto
git status -sb # Formato curto com informações do branch

# Prepare arquivos para commit
git add arquivo.js         # Arquivo único
git add src/               # Diretório inteiro
git add .                  # Todas as alterações no diretório atual
git add -A                 # Todas as alterações em todo o repo
git add -p                 # Preparação interativa (modo patch)
git add *.js               # Todos os arquivos JavaScript

# Remova arquivos da área de preparação
git reset arquivo.js       # Remover arquivo específico
git reset                  # Remover todos os arquivos

# Faça commit das alterações preparadas
git commit -m "feat: adicionar autenticação de usuário"
git commit -am "fix: resolver bug de login"  # Preparar + commit de arquivos rastreados
git commit --amend         # Modificar o último commit
git commit --amend --no-edit  # Modificar sem alterar a mensagem

# Visualize diferenças
git diff                   # Alterações não preparadas
git diff --staged          # Alterações preparadas
git diff HEAD              # Todas as alterações desde o último commit
git diff main..feature     # Entre branches
git diff --stat            # Resumo das alterações

Removendo e Movendo Arquivos

# Remova arquivos
git rm arquivo.js          # Remover do diretório de trabalho e preparar exclusão
git rm --cached arquivo.js # Remover do Git mas manter no diretório de trabalho
git rm -r diretorio/       # Remover diretório recursivamente

# Mova ou renomeie arquivos
git mv nome-antigo.js nome-novo.js
git mv src/arquivo.js lib/arquivo.js  # Mover para diretório diferente

Quando você usa git mv ou git rm, as alterações são automaticamente preparadas. Isso é mais conveniente do que usar comandos shell regulares e depois preparar as alterações separadamente.

Ramificação e Mesclagem

Branches são o recurso matador do Git. Eles permitem que você trabalhe em múltiplas funcionalidades simultaneamente sem interferir na base de código principal.

Gerenciamento de Branches

# Liste branches
git branch                 # Branches locais
git branch -r              # Branches remotos
git branch -a              # Todos os branches (local + remoto)
git branch -v              # Com informações do último commit
git branch --merged        # Branches mesclados no branch atual
git branch --no-merged     # Branches ainda não mesclados

# Crie branches
git branch feature-login   # Criar novo branch
git checkout -b feature-login  # Criar e mudar para novo branch
git switch -c feature-login    # Alternativa moderna ao checkout

# Mude de branches
git checkout main          # Mudar para branch main
git switch main            # Alternativa moderna
git checkout -            # Mudar para branch anterior

# Renomeie branches
git branch -m nome-antigo nome-novo  # Renomear branch
git branch -M nome-novo     # Forçar renomeação do branch atual

# Delete branches
git branch -d feature-login     # Deletar branch mesclado
git branch -D feature-login     # Forçar deleção (mesmo se não mesclado)
git push origin --delete feature-login  # Deletar branch remoto

Estratégias de Mesclagem

# Mescle branches
git merge feature-login    # Mesclar feature-login no branch atual
git merge --no-ff feature-login  # Criar commit de merge mesmo para fast-forward
git merge --squash feature-login # Comprimir todos os commits em um

# Aborte uma mesclagem
git merge --abort

# Continue após resolver conflitos
git merge --continue

Rebase

Rebase reescreve o histórico de commits movendo seu branch para um novo commit base. Isso cria um histórico mais limpo e linear, mas deve ser usado com cuidado.

# Faça rebase do branch atual em main
git rebase main

# Rebase interativo (editar, comprimir, reordenar commits)
git rebase -i HEAD~3       # Últimos 3 commits
git rebase -i main         # Todos os commits desde a ramificação de main

# Continue após resolver conflitos
git rebase --continue

# Pule o commit atual
git rebase --skip

# Aborte o rebase
git rebase --abort

Resolvendo Conflitos de Mesclagem

Quando o Git não consegue mesclar alterações automaticamente, você precisará resolver conflitos manualmente:

1. Execute git status para ver quais arquivos têm conflitos
2. Abra os arquivos em conflito e procure por marcadores de conflito (<<<<<<<, =======, >>>>>>>)
3. Edite o arquivo para resolver conflitos, removendo os marcadores
4. Prepare os arquivos resolvidos com git add
5. Complete a mesclagem com git commit ou git merge --continue

# Use ferramentas de merge para resolver conflitos
git mergetool

# Aceite todas as alterações de um lado
git checkout --ours arquivo.js    # Manter sua versão
git checkout --theirs arquivo.js  # Manter a versão deles

Operações Remotas

Repositórios remotos permitem colaboração. Estes comandos ajudam você a sincronizar seu trabalho local com servidores remotos como GitHub, GitLab ou Bitbucket.

Gerenciando Remotos

# Liste repositórios remotos
git remote
git remote -v              # Com URLs

# Adicione repositório remoto
git remote add origin https://github.com/usuario/repo.git
git remote add upstream https://github.com/original/repo.git

# Altere URL remota
git remote set-url origin [email protected]:usuario/repo.git

# Remova remoto
git remote remove origin

# Renomeie remoto
git remote rename origin upstream

# Mostre detalhes do remoto
git remote show origin

Buscando e Puxando

# Busque alterações do remoto (não mescla)
git fetch origin
git fetch --all            # Buscar de todos os remotos
git fetch --prune          # Remover branches remotos deletados

# Puxe alterações (fetch + merge)
git pull origin main
git pull --rebase origin main  # Fetch + rebase em vez de merge
git pull --ff-only         # Apenas fast-forward, falha se merge necessário

# Puxe com stash automático
git pull --autostash

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

Enviando Alterações

# Envie para remoto
git push origin main
git push -u origin feature-login  # Definir upstream e enviar
git push --all             # Enviar todos os branches
git push --tags            # Enviar todas as tags

# Forçar envio (use com cuidado!)
git push --force           # Sobrescrever histórico remoto
git push --force-with-lease # Envio forçado mais seguro, falha se remoto atualizado

# Delete branch remoto
git push origin --delete feature-login
git push origin :feature-login  # Sintaxe alternativa

Rastreando Branches

# Defina branch upstream
git branch --set-upstream-to=origin/main main
git branch -u origin/main  # Forma abreviada

# Crie branch de rastreamento
git checkout -b feature origin/feature
git checkout --track origin/feature  # Nomenclatura automática

# Visualize relacionamentos de rastreamento
git branch -vv

Guardando Alterações

Stashing guarda temporariamente alterações para que você possa trabalhar em outra coisa sem fazer commit de trabalho incompleto.

# Guarde alterações atuais
git stash
git stash save "trabalho em andamento na funcionalidade de login"
git stash -u               # Incluir arquivos não rastreados
git stash -a               # Incluir arquivos não rastreados e ignorados

# Liste stashes
git stash list

# Aplique alterações guardadas
git stash apply            # Aplicar stash mais recente
git stash apply stash@{2}  # Aplicar stash específico
git stash pop              # Aplicar e remover da lista de stash

# Visualize conteúdo do stash
git stash show
git stash show -p          # Mostrar diff completo
git stash show stash@{1}   # Mostrar stash específico

# Crie branch a partir do stash
git stash branch nome-feature

# Remova stashes
git stash drop stash@{1}   # Remover stash específico
git stash clear            # Remover todos os stashes

Stashing é perfei