Introdução
Neste laboratório, você aprenderá como determinar se um commit Git específico existe dentro de um branch (ramificação) particular. Exploraremos o comando git branch --contains para identificar todos os branches que incluem um determinado commit, fornecendo informações sobre o histórico do commit e seus pontos de integração.
Você também aprenderá como usar git log com o nome de um branch para verificar a presença de um commit dentro do histórico desse branch e como verificar eficientemente múltiplos branches em busca de um commit. Este laboratório irá equipá-lo com habilidades essenciais para entender e navegar pelo histórico do seu projeto Git.
Executar git branch --contains Commit
Nesta etapa, aprenderemos como usar o comando git branch --contains para descobrir quais branches contêm um commit específico. Este é um comando muito útil quando você deseja entender o histórico do seu projeto e ver onde uma alteração particular foi integrada.
Primeiro, vamos garantir que estamos no nosso diretório my-time-machine. Abra seu terminal e digite:
cd ~/project/my-time-machine
Agora, vamos criar um novo arquivo e fazer um commit. Isso nos dará um novo commit para trabalhar.
echo "Another message for the future" > message2.txt
git add message2.txt
git commit -m "Add another message"
Você deve ver uma saída semelhante a esta após o commit:
[master <commit-id>] Add another message
1 file changed, 1 insertion(+)
create mode 100644 message2.txt
Agora temos um novo commit. Vamos encontrar o ID do commit deste novo commit. Podemos usar git log --oneline para ver um log condensado:
git log --oneline
A saída será algo parecido com isto:
<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future
O primeiro ID do commit listado é o de "Add another message". Copie este ID do commit.
Agora, vamos usar git branch --contains com este ID do commit. Substitua <commit-id-2> pelo ID do commit real que você copiou:
git branch --contains <commit-id-2>
A saída deve mostrar o branch master, indicando que este commit está no branch master:
* master
O comando git branch --contains <commit> é poderoso porque ajuda você a rastrear a linhagem de um commit. Se você tiver múltiplos branches, este comando listará todos os branches que incluem aquele commit específico. Isso é essencial para entender como as alterações fluem pelas diferentes linhas de desenvolvimento do seu projeto.
Usar git log Branch para Verificar
Na etapa anterior, usamos git branch --contains para ver quais branches contêm um commit específico. Agora, vamos usar o comando git log com o nome de um branch para verificar o histórico desse branch. Isso nos mostrará todos os commits que fazem parte do histórico desse branch.
Certifique-se de que você ainda está no diretório ~/project/my-time-machine:
cd ~/project/my-time-machine
Sabemos da etapa anterior que nosso último commit está no branch master. Vamos visualizar o log especificamente para o branch master:
git log master --oneline
Você deve ver uma saída semelhante a esta, mostrando os commits no branch master:
<commit-id-2> (HEAD -> master) Add another message
<commit-id-1> Send a message to the future
Esta saída confirma que ambos os nossos commits estão, de fato, no branch master. Usar git log <branch-name> é uma ótima maneira de inspecionar o histórico de um branch específico e ver todos os commits que são alcançáveis a partir da ponta (tip) desse branch.
Comparar a saída de git branch --contains <commit> e git log <branch-name> ajuda você a entender a relação entre commits e branches. git branch --contains informa quais branches incluem um commit em qualquer lugar de seu histórico, enquanto git log <branch-name> mostra o histórico linear levando até a ponta desse branch específico.
Pressione q para sair da visualização do log.
Verificar Múltiplas Branches
Nesta etapa, criaremos um novo branch e veremos como git branch --contains se comporta quando um commit está presente em múltiplos branches. Isso ilustrará ainda mais o poder deste comando na compreensão da estrutura de branching do seu projeto.
Primeiro, certifique-se de que você está no diretório ~/project/my-time-machine:
cd ~/project/my-time-machine
Agora, vamos criar um novo branch chamado feature-branch:
git branch feature-branch
Este comando cria um novo branch, mas não o muda para ele. Você ainda está no branch master.
Vamos verificar nossos branches:
git branch
Você deve ver ambos os branches listados, com master destacado (indicando que é o branch atual):
* master
feature-branch
Agora, vamos obter o ID do commit do nosso último commit novamente usando git log --oneline:
git log --oneline
A saída será semelhante à anterior:
<commit-id-2> (HEAD -> master, feature-branch) Add another message
<commit-id-1> Send a message to the future
Observe que o último commit agora mostra tanto HEAD -> master quanto feature-branch. Isso significa que o feature-branch foi criado neste commit.
Agora, vamos usar git branch --contains com este ID do commit novamente. Substitua <commit-id-2> pelo ID do commit real:
git branch --contains <commit-id-2>
Desta vez, a saída deve mostrar ambos os branches, porque o commit existe no histórico de ambos master e feature-branch:
* master
feature-branch
Isso demonstra como git branch --contains pode mostrar todos os branches que têm um commit específico em seu histórico. Isso é incrivelmente útil para rastrear onde as alterações foram mescladas ou integradas em diferentes linhas de desenvolvimento.
Resumo
Neste laboratório, aprendemos como verificar se um commit do Git está presente em um branch específico. Começamos usando o comando git branch --contains <commit-id>, que lista todos os branches que incluem o commit especificado. Esta é uma ferramenta fundamental para entender o histórico e a integração de alterações dentro de um repositório Git.
Em seguida, exploramos como verificar a presença de um commit em um branch usando git log <branch-name>. Este comando exibe o histórico de commits de um branch específico, permitindo-nos confirmar visualmente se o commit alvo faz parte da linhagem desse branch. Finalmente, vimos como estender essas técnicas para verificar um commit em múltiplos branches, fornecendo uma visão abrangente de sua distribuição dentro da estrutura de branching do projeto.
