Como Verificar se um Commit Git Está no Branch Atual

Introdução

Neste laboratório, você aprenderá como determinar se um commit Git específico existe dentro do branch atual. Começaremos explorando o comando git log e suas várias opções para pesquisar e filtrar eficientemente o histórico de commits, incluindo o uso de --grep para pesquisar mensagens de commit e --author para filtrar por autor.

Em seguida, você aprenderá como usar o comando git branch --contains para identificar quais branches em seu repositório incluem um determinado commit. Este exercício prático irá equipá-lo com as habilidades para navegar e entender efetivamente o histórico de commits do seu projeto em diferentes branches.

Usar git log para Encontrar o Commit

Nesta etapa, aprenderemos como usar o comando git log para encontrar commits específicos no histórico do nosso projeto. À medida que seu projeto cresce e você faz mais commits, a saída de git log pode se tornar bastante longa. Git fornece opções poderosas para filtrar e pesquisar no log.

Primeiro, vamos fazer mais alguns commits para termos um histórico com o qual trabalhar. Certifique-se de estar no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine
echo "Adding a second message" >> message.txt
git add message.txt
git commit -m "Add a second message"
echo "Adding a third message" >> message.txt
git add message.txt
git commit -m "Add a third message"

Agora, vamos visualizar o log completo novamente:

git log

Você verá três commits listados, com o mais recente no topo.

Às vezes, você pode estar procurando por um commit que contenha uma palavra específica em sua mensagem. Você pode usar a opção -grep para isso. Vamos encontrar o commit com "second message":

git log --grep "second message"

Este comando mostrará apenas o commit cuja mensagem contém a frase "second message".

Outra opção útil é -author para encontrar commits por um autor específico. Como configuramos nosso nome de autor na configuração, vamos tentar encontrar commits por "Jane Doe":

git log --author "Jane Doe"

Isso mostrará todos os commits feitos por "Jane Doe".

Finalmente, você pode limitar o número de commits exibidos usando a opção -n. Por exemplo, para ver apenas os dois últimos commits:

git log -n 2

Usar essas opções com git log ajuda você a navegar no histórico do seu projeto de forma eficiente, especialmente em projetos maiores com muitos commits.

Executar git branch --contains para o Commit

Nesta etapa, exploraremos como usar o comando git branch --contains. Este comando é útil para descobrir quais branches contêm um commit específico. Isso é particularmente útil quando você tem múltiplos branches e precisa rastrear onde uma determinada alteração foi incluída.

Primeiro, vamos obter o hash do commit de um de nossos commits anteriores. Podemos usar git log --oneline para ver uma visualização condensada do log e copiar facilmente um hash de commit. Certifique-se de estar no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine
git log --oneline

Você verá uma saída semelhante a esta (seus hashes de commit serão diferentes):

abcdefg (HEAD -> master) Add a third message
hijklmn Add a second message
opqrstu Send a message to the future

Copie o hash do commit do primeiro commit que você fez ("Send a message to the future"). No exemplo acima, é opqrstu.

Agora, vamos usar git branch --contains com este hash de commit. Substitua [commit_hash] pelo hash real que você copiou:

git branch --contains [commit_hash]

Por exemplo, usando o hash da saída de exemplo:

git branch --contains opqrstu

A saída deve mostrar * master. O asterisco * indica o branch atualmente verificado (checked-out). Isso nos diz que o commit opqrstu está presente no branch master.

No momento, temos apenas um branch (master), então a saída é simples. Na próxima etapa, criaremos outro branch e veremos como a saída de git branch --contains muda.

Entender quais branches contêm um commit específico é crucial para gerenciar o histórico do seu projeto e coordenar o trabalho em diferentes linhas de desenvolvimento.

Testar com Outras Branches

Nesta etapa, criaremos um novo branch e faremos um commit nele para ver como git branch --contains se comporta quando um commit está apenas em um branch. Isso ajudará a solidificar sua compreensão de como o Git rastreia commits em diferentes linhas de desenvolvimento.

Primeiro, vamos criar um novo branch chamado feature-branch. Certifique-se de estar no diretório ~/project/my-time-machine.

cd ~/project/my-time-machine
git branch feature-branch

Agora, vamos mudar para nosso novo branch:

git checkout feature-branch

Você deve ver uma saída indicando que você mudou para o novo branch:

Switched to branch 'feature-branch'

Vamos fazer um novo commit neste feature-branch.

echo "Adding a feature" >> feature.txt
git add feature.txt
git commit -m "Add a new feature file"

Agora, vamos obter o hash do commit deste novo commit usando git log --oneline:

git log --oneline

A saída mostrará seu novo commit no topo, seguido pelos commits anteriores. Copie o hash do commit "Add a new feature file".

Agora, vamos usar git branch --contains com o hash do commit "Add a new feature file". Substitua [feature_commit_hash] pelo hash real que você copiou:

git branch --contains [feature_commit_hash]

A saída deve mostrar apenas * feature-branch. Isso ocorre porque este commit específico foi feito depois que criamos e mudamos para feature-branch, então ele só existe no histórico deste branch.

Agora, vamos tentar git branch --contains com o hash do primeiro commit ("Send a message to the future") novamente. Substitua [first_commit_hash] pelo hash que você usou na etapa anterior:

git branch --contains [first_commit_hash]

Desta vez, a saída deve mostrar tanto feature-branch quanto * master. Isso ocorre porque o feature-branch foi criado a partir do branch master, então ele contém todos os commits que estavam no master naquele momento, incluindo o primeiro commit.

Isso demonstra como git branch --contains pode ajudá-lo a entender a relação entre branches e os commits que eles incluem.

Resumo

Neste laboratório, aprendemos como verificar se um commit do Git está presente no branch atual. Começamos explorando o comando git log e suas várias opções, como --grep, --author e -n, para pesquisar e filtrar eficientemente o histórico de commits. Isso é crucial para navegar em projetos com inúmeros commits.

Em seguida, aprendemos como usar o comando git branch --contains para identificar quais branches incluem um commit específico. Este comando é valioso para rastrear a propagação de alterações em diferentes branches dentro de um repositório Git.