Git: O Kit de Emergência

Exibe o status do diretório de trabalho e da área de staging de forma concisa. A flag -s (ou --short) mostra a saída em um formato abreviado e fácil de ler, indicando arquivos modificados, adicionados ou deletados.

git status -s

Fornece uma saída de status formatada para ser facilmente parseada por scripts. É uma interface estável e não projetada para leitura humana, ideal para automação.

git status --porcelain

Inclui arquivos ignorados (listados no .gitignore) na saída do status, mostrando-os na seção "Untracked files". Útil para verificar se as regras de ignorar estão funcionando como esperado.

git status --ignored

Exibe informações adicionais sobre a branch atual, como o nome da branch, se ela está à frente ou atrás do seu upstream, e o hash do commit atual.

git status --branch

Mostra a quantidade de stashes que você tem atualmente. Útil para lembrar se há mudanças guardadas que precisam ser aplicadas ou removidas.

git status --show-stash

Fornece uma visualização completa e compacta do histórico de commits. `--oneline` mostra cada commit em uma linha, `--graph` desenha um grafo ASCII do histórico, `--all` inclui branches remotas e tags, e `--decorate` mostra os nomes das branches e tags.

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

Exibe estatísticas de cada commit, mostrando quais arquivos foram modificados e o número de linhas adicionadas/deletadas. Útil para ter uma visão rápida do impacto de cada commit.

git log --stat

Mostra o diff completo (patch) para cada commit, exibindo as mudanças exatas de linha a linha. Essencial para revisar o conteúdo de cada alteração.

git log --patch

Filtra o histórico de commits para mostrar apenas aqueles feitos dentro de um período específico. Pode-se usar formatos como "2 weeks ago", "yesterday", "2023-01-01".

git log --since="2 weeks ago"

Filtra o histórico para exibir apenas os commits feitos por um autor específico. O nome do autor deve corresponder ao configurado no Git.

git log --author="nome"

Filtra o histórico de commits por uma palavra-chave ou padrão regex na mensagem do commit. Útil para encontrar commits relacionados a correções de bugs ou funcionalidades específicas.

git log --grep="fix"

Busca commits que introduziram ou removeram uma string específica no código (também conhecido como "pickaxe" option). É poderoso para rastrear onde uma função ou variável foi alterada pela primeira vez.

git log -S "função"

Exibe o histórico de um arquivo específico, seguindo seu histórico através de renomeações. Garante que você veja todas as mudanças no arquivo, mesmo que seu nome tenha mudado.

git log --follow arquivo.txt

Apresenta um log de commits altamente formatado e colorido, exibindo hash, branches/tags, mensagem, data relativa e autor. Personalizável para uma melhor legibilidade visual.

git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'

Uma visualização compacta e decorada do histórico, mostrando o grafo de branches e tags. Similar ao log completo, mas sem incluir todas as referências remotas por padrão.

git log --oneline --decorate --graph

Exibe o histórico de commits na ordem cronológica inversa, ou seja, do commit mais antigo para o mais recente. Útil para ver a evolução de um projeto.

git log --reverse

Mostra o conteúdo do último commit na branch atual, incluindo o diff. É uma forma rápida de revisar o que foi commitado mais recentemente.

git show HEAD

Exibe o conteúdo do commit que está dois commits antes do HEAD. Pode-se usar qualquer referência de commit (hash, tag, branch, HEAD~n).

git show HEAD~2

Mostra apenas os nomes dos arquivos que foram modificados no commit especificado, sem exibir o diff completo.

git show --name-only HEAD

Exibe estatísticas de modificação para o commit especificado, mostrando quais arquivos foram alterados e o número de linhas adicionadas/deletadas.

git show --stat HEAD

Cria uma nova branch com o nome especificado (ex: `feature/nova-funcionalidade`) e imediatamente troca para ela. É um atalho para `git branch <nome>` seguido de `git checkout <nome>`.

git checkout -b feature/nova-funcionalidade

Comando moderno e mais intuitivo para criar uma nova branch e trocar para ela. É a alternativa recomendada ao `git checkout -b` para essa finalidade.

git switch -c feature/nova-funcionalidade

Lista todas as branches, incluindo as locais e as remotas. As branches remotas são prefixadas com o nome do remote (ex: `remotes/origin/main`).

git branch -a

Lista apenas as branches remotas. Útil para ver quais branches existem nos repositórios remotos sem poluir a saída com as locais.

git branch -r

Lista as branches locais com informações adicionais, como o último commit de cada branch e a mensagem do commit. Ajuda a ter uma visão rápida do estado de cada branch.

git branch -v

Lista as branches que já foram totalmente mergeadas na branch atual. Geralmente, são branches que podem ser deletadas com segurança.

git branch --merged

Lista as branches que ainda não foram mergeadas na branch atual. Essas branches contêm trabalho que ainda não foi integrado e não devem ser deletadas sem cuidado.

git branch --no-merged

Deleta a branch local especificada (ex: `feature-branch`). Este é um "delete seguro" que falhará se a branch contiver commits não mergeados na branch atual.

git branch -d feature-branch

Força a exclusão da branch local especificada, mesmo que ela contenha commits não mergeados. Use com cautela, pois pode resultar em perda de trabalho.

git branch -D feature-branch

Deleta uma branch do repositório remoto (ex: `origin/feature-branch`). É o comando para remover branches remotas que não são mais necessárias.

git push origin --delete feature-branch

Renomeia a branch local `old-name` para `new-name`. Se `old-name` for omitido, renomeia a branch atual.

git branch -m old-name new-name

Força a renomeação de uma branch, mesmo que a `new-name` já exista. Use com cuidado para evitar sobrescrever branches existentes.

git branch -M old-name new-name

Exibe o nome da branch atual em que você está trabalhando. Útil para scripts ou para confirmar rapidamente a branch.

git branch --show-current

Lista todas as branches que contêm o commit especificado (ex: `abc123`). Útil para rastrear onde um commit específico foi integrado.

git branch --contains abc123

Lista as branches locais ordenadas pela data do último commit, do mais recente para o mais antigo. A flag `-` inverte a ordem.

git branch --sort=-committerdate

Integra as mudanças da `feature-branch` na branch atual. Se possível, realiza um fast-forward merge; caso contrário, cria um merge commit.

git merge feature-branch

Força a criação de um merge commit, mesmo que um fast-forward merge fosse possível. Isso preserva o histórico de branches, mostrando explicitamente onde a feature foi integrada.

git merge --no-ff feature-branch

Aplica as mudanças da `feature-branch` na branch atual como um único commit, sem registrar a `feature-branch` no histórico. Os commits da `feature-branch` são "esmagados" em um único commit na branch de destino.

git merge --squash feature-branch

Inicia um rebase interativo nos últimos 3 commits a partir do HEAD. Permite reordenar, editar, esmagar (squash) ou dividir commits, e remover commits. Abre um editor de texto com as opções.

git rebase -i HEAD~3

Inicia um rebase interativo de todos os commits na branch atual que não estão na branch `main`. Útil para limpar o histórico antes de fazer um merge na `main`.

git rebase -i main

Continua o processo de rebase após resolver conflitos de merge ou após editar um commit durante um rebase interativo.

git rebase --continue

Cancela o rebase em andamento e retorna a branch ao estado em que estava antes do início do rebase. Útil se você decidir não continuar ou se encontrar problemas insolúveis.

git rebase --abort

Aplica as mudanças introduzidas por um commit específico (ex: `abc123`) na branch atual, criando um novo commit com essas mudanças. Útil para portar correções ou funcionalidades pontuais.

git cherry-pick abc123

Aplica um range de commits (do `abc123` exclusivo até o `def456` inclusivo) na branch atual. Útil para portar múltiplas mudanças de uma vez.

git cherry-pick abc123..def456

Aplica as mudanças do commit `abc123` no diretório de trabalho e área de staging, mas sem criar um novo commit. Permite revisar e ajustar as mudanças antes de commitá-las.

git cherry-pick --no-commit abc123

Aplica o commit `abc123` e adiciona uma linha "cherry-picked from commit abc123" à mensagem do novo commit, indicando a origem.

git cherry-pick -x abc123

Aplica o commit `abc123` e adiciona uma linha "Signed-off-by: Your Name <your.email@example.com>" à mensagem do novo commit, indicando que você certifica a origem da mudança.

git cherry-pick --signoff abc123

Cancela um cherry-pick em andamento e retorna a branch ao estado anterior. Útil se houver conflitos ou se o cherry-pick não for mais desejado.

git cherry-pick --abort

Busca por uma string ou padrão regex nos arquivos rastreados pelo Git no diretório de trabalho. É como um `grep` tradicional, mas otimizado para repositórios Git.

git grep "função"

Busca por uma string ou padrão regex no código em um commit específico (ex: `HEAD~5`). Útil para encontrar onde uma string existia em um ponto anterior do histórico.

git grep "função" HEAD~5

Busca por uma string e exibe os números de linha onde a correspondência foi encontrada. Ajuda a localizar rapidamente a ocorrência no arquivo.

git grep -n "função"

Realiza uma busca case insensitive, ignorando a diferença entre letras maiúsculas e minúsculas ao procurar pela string.

git grep -i "função"

Mostra o histórico de revisões linha por linha para um arquivo específico. Para cada linha, exibe o commit que a modificou pela última vez, o autor e a data. Útil para identificar quem e quando alterou uma parte do código.

git blame arquivo.txt

Restringe a saída do `git blame` a um intervalo específico de linhas (da linha 10 à 20, inclusivo) de um arquivo. Útil para focar em uma seção problemática.

git blame -L 10,20 arquivo.txt

Exibe o histórico de commits que afetaram o `arquivo.txt`, incluindo o patch (diff) completo de cada alteração. Permite ver exatamente como o arquivo evoluiu.

git log -p arquivo.txt

Exibe o histórico de um arquivo específico, seguindo seu histórico através de renomeações. Garante que você veja todas as mudanças no arquivo, mesmo que seu nome tenha mudado.

git log --follow arquivo.txt

Inicia uma sessão de `git bisect`, que é uma ferramenta para encontrar o commit que introduziu um bug usando uma busca binária no histórico.

git bisect start

Marca o commit atual (HEAD) como "ruim", indicando que o bug está presente neste ponto.

git bisect bad HEAD

Marca um commit conhecido (ex: `v1.0.0`) como "bom", indicando que o bug não estava presente neste ponto. O Git então escolhe um commit intermediário para você testar.

git bisect good v1.0.0

Automatiza o processo de bisect executando um script ou comando (ex: `npm test`) em cada commit. O script deve retornar 0 para "bom" e um código de erro (1-127) para "ruim".

git bisect run npm test

Finaliza a sessão de `git bisect` e retorna a branch ao commit em que estava antes de iniciar o bisect.

git bisect reset

Abre uma interface gráfica (se configurada) para visualizar o grafo de commits e o progresso do bisect.

git bisect visualize

Mostra o log de todos os comandos `git bisect` executados na sessão atual, útil para revisar o processo.

git bisect log

Repete uma sessão de bisect a partir de um arquivo de log previamente salvo, permitindo recriar o processo de depuração.

git bisect replay arquivo.log

Cria uma tag leve (lightweight tag) com o nome `v1.0.0` no commit atual. Tags leves são apenas um ponteiro para um commit.

git tag v1.0.0

Cria uma tag anotada (annotated tag) com o nome `v1.0.0` e uma mensagem descritiva. Tags anotadas são objetos Git completos, contendo nome do tagueador, e-mail, data e mensagem, e são recomendadas para releases.

git tag -a v1.0.0 -m "Release 1.0.0"

Cria uma tag anotada `v1.0.0` em um commit específico (ex: `abc123`), em vez do HEAD. Útil para marcar commits passados.

git tag -a v1.0.0 abc123 -m "Tag commit específico"

Lista todas as tags no repositório local em ordem alfabética.

git tag

Lista tags que correspondem a um padrão específico (ex: todas as tags que começam com "v1.").

git tag -l "v1.*"

Exibe os detalhes de uma tag específica, incluindo a mensagem da tag (se for anotada) e o commit ao qual ela aponta.

git show v1.0.0

Deleta a tag `v1.0.0` do repositório local. Isso não remove a tag de repositórios remotos.

git tag -d v1.0.0

Deleta a tag `v1.0.0` do repositório remoto `origin`. É necessário para remover tags publicadas.

git push origin --delete v1.0.0

Envia uma tag específica (`v1.0.0`) para o repositório remoto `origin`. Tags não são enviadas automaticamente com `git push`.

git push origin v1.0.0

Envia todas as tags locais para o repositório remoto `origin`. Útil para publicar várias tags de uma vez.

git push origin --tags

Verifica a assinatura GPG de uma tag anotada. Requer que a tag tenha sido assinada e que a chave GPG do signatário esteja disponível.

git tag -v v1.0.0

Cria uma tag anotada e assinada com GPG. A assinatura garante a autenticidade e integridade da tag.

git tag -s v1.0.0 -m "Release"

Força a criação ou atualização de uma tag existente. Use com cautela, pois pode sobrescrever tags importantes.

git tag -f v1.0.0

Salva as mudanças não commitadas (modificações no diretório de trabalho e arquivos staged) em uma pilha de stashes, revertendo o diretório de trabalho para o estado do último commit. Arquivos não rastreados não são incluídos por padrão.

git stash

Salva as mudanças com uma mensagem descritiva. A mensagem ajuda a identificar o conteúdo do stash posteriormente, especialmente quando há vários stashes.

git stash push -m "WIP: feature X"

Salva apenas as mudanças de um arquivo específico no stash, deixando outros arquivos inalterados. O `--` é necessário para distinguir o caminho do arquivo de outras opções.

git stash push -- arquivo.txt

Salva as mudanças, incluindo também os arquivos não rastreados (untracked files) no stash. Útil para guardar todo o estado do diretório de trabalho.

git stash push --include-untracked

Lista todos os stashes atualmente armazenados, mostrando uma breve descrição e o índice de cada um (ex: `stash@{0}`).

git stash list

Exibe um resumo das mudanças contidas em um stash específico (ex: `stash@{0}`). Mostra quais arquivos foram modificados.

git stash show stash@{0}

Mostra o patch completo (diff) de um stash específico, exibindo as mudanças linha a linha. Essencial para revisar o conteúdo antes de aplicar.

git stash show -p stash@{0}

Aplica as mudanças de um stash específico no diretório de trabalho, mas mantém o stash na pilha. Útil se você quiser aplicar o mesmo stash em várias branches.

git stash apply stash@{0}

Aplica as mudanças de um stash específico no diretório de trabalho e, em seguida, remove o stash da pilha. É o comando mais comum para aplicar e limpar stashes.

git stash pop stash@{0}

Remove um stash específico da pilha sem aplicar suas mudanças. Útil para descartar stashes que não são mais necessários.

git stash drop stash@{0}

Remove todos os stashes da pilha. Use com extrema cautela, pois esta ação é irreversível.

git stash clear

Cria uma nova branch a partir do commit onde o stash foi criado, aplica o stash nela e, em seguida, remove o stash da pilha. Útil para continuar o trabalho de um stash em uma nova branch.

git stash branch nova-branch stash@{0}

Salva as mudanças não staged no stash, mas mantém as mudanças que já estavam na área de staging. Útil para commitar apenas parte das mudanças e guardar o restante.

git stash --keep-index

Desfaz o último commit, movendo o HEAD para o commit anterior, mas mantém as mudanças do commit desfeito na área de staging. O diretório de trabalho permanece inalterado.

git reset --soft HEAD~1

Desfaz o último commit e move as mudanças do commit desfeito para o diretório de trabalho (não staged). É o comportamento padrão do `git reset` se nenhuma flag for especificada. A área de staging é limpa.

git reset --mixed HEAD~1

Desfaz o último commit, descarta todas as mudanças do commit desfeito do diretório de trabalho e da área de staging. Esta ação é irreversível e pode resultar em perda de trabalho não commitado. Use com extrema cautela!

git reset --hard HEAD~1

Descarta as mudanças no `arquivo.txt` no diretório de trabalho, restaurando-o para o estado do último commit. É uma alternativa mais segura e intuitiva para `git checkout -- arquivo.txt`.

git restore arquivo.txt

Remove o `arquivo.txt` da área de staging, movendo suas mudanças de volta para o diretório de trabalho (unstage). O arquivo no diretório de trabalho permanece inalterado.

git restore --staged arquivo.txt

Restaura o `arquivo.txt` no diretório de trabalho e na área de staging para o estado em que ele estava em um commit específico (ex: `HEAD~1`). Útil para recuperar versões antigas de arquivos.

git restore --source=HEAD~1 arquivo.txt

Exibe um log de todas as ações que modificaram o HEAD do repositório local. É um histórico de "onde o HEAD esteve", permitindo recuperar commits que parecem ter sido perdidos após resets ou rebases.

git reflog

Exibe o reflog para uma branch específica (ex: `main`), mostrando todas as vezes que a referência `main` foi atualizada.

git reflog show main

Volta o HEAD (e a branch atual) para um estado anterior registrado no reflog (neste caso, o segundo estado mais recente). É a principal forma de recuperar commits após um `git reset --hard` acidental.

git reset --hard HEAD@{2}

Lista os repositórios remotos configurados para o projeto, mostrando seus nomes e URLs (verbose). Útil para verificar de onde você está puxando e para onde está enviando.

git remote -v

Adiciona um novo repositório remoto com o nome `upstream` e a URL especificada. Comum para configurar um remote para o repositório original em um fork.

git remote add upstream https://...

Altera a URL de um repositório remoto existente (ex: `origin`). Útil para atualizar o local de um repositório ou mudar entre SSH e HTTPS.

git remote set-url origin https://...

Remove um repositório remoto com o nome `upstream` da configuração local. Isso não afeta o repositório remoto em si.

git remote remove upstream

Baixa objetos e referências de todos os repositórios remotos configurados. Não integra as mudanças no diretório de trabalho, apenas atualiza as referências remotas locais.

git fetch --all

Remove as referências locais para branches remotas que foram deletadas no repositório remoto. Ajuda a manter a lista de branches remotas limpa e atualizada.

git fetch --prune

Baixa as mudanças do repositório remoto e, em seguida, aplica suas mudanças locais em cima delas usando rebase. Isso evita commits de merge desnecessários e mantém um histórico linear.

git pull --rebase

Baixa as mudanças do repositório remoto e tenta realizar um fast-forward merge. Se um fast-forward não for possível (ou seja, há commits locais que não são ancestrais do remote), o comando falha, exigindo um merge manual ou rebase.

git pull --ff-only

Envia a `feature-branch` para o repositório remoto `origin` e configura-a como a branch de upstream. Isso permite usar `git pull` e `git push` sem especificar o remote e a branch posteriormente.

git push -u origin feature-branch

Envia as mudanças para o repositório remoto, forçando a sobrescrita do histórico, mas com uma salvaguarda. Só funciona se o branch remoto não tiver sido atualizado por outra pessoa desde o seu último fetch, prevenindo sobrescritas acidentais de trabalho alheio.

git push --force-with-lease

Deleta a `feature-branch` do repositório remoto `origin`. O `:` antes do nome da branch local indica que você está enviando "nada" para a branch remota, efetivamente deletando-a.

git push origin :feature-branch

Envia todas as branches locais para o repositório remoto `origin`. Útil para garantir que todas as suas branches estejam sincronizadas com o remote.

git push --all origin

Espelha o repositório local no repositório remoto `origin`. Isso significa que todas as branches, tags e referências do local serão replicadas no remoto, incluindo a exclusão de qualquer coisa que não esteja no local. Use com extrema cautela, pois é uma operação destrutiva.

git push --mirror origin

Envia todas as tags locais para o repositório remoto, e também envia quaisquer commits que sejam referenciados por essas tags (se ainda não estiverem no remote). `--follow-tags` garante que tags anotadas que apontam para commits que ainda não foram enviados também sejam enviadas.

git push --tags --follow-tags