Como Verificar se um Branch Git Está Sincronizado com Outro Branch

Introdução

Neste laboratório, você aprenderá como verificar se um branch Git está sincronizado com outro branch. Esta é uma habilidade fundamental para gerenciar o histórico do seu projeto e garantir que os branches estejam atualizados.

Você explorará três métodos diferentes para alcançar isso: usando git log para comparar os históricos de commits, empregando git diff para identificar diferenças entre os branches e, finalmente, verificando a relação entre os branches usando git merge-base. Ao final deste laboratório, você estará equipado com técnicas práticas para determinar com confiança o status de sincronização de seus branches Git.

Usar git log para Comparar Commits

Nesta etapa, aprenderemos como usar o comando git log para comparar diferentes commits no histórico do seu projeto. Isso é como olhar para diferentes snapshots da sua máquina do tempo e ver como as coisas mudaram entre eles.

Primeiro, vamos garantir que estamos no diretório do nosso projeto. Abra seu terminal e navegue até a pasta my-time-machine:

cd ~/project/my-time-machine

Agora, vamos criar um novo arquivo e fazer um commit. Isso nos dará outro ponto no histórico para comparar com nosso primeiro commit.

echo "This is the second message." > second_message.txt
git add second_message.txt
git commit -m "Add a second message file"

Você deve ver uma saída semelhante a esta após o commit:

[master a1b2c3d] Add a second message file
 1 file changed, 1 insertion(+)
 create mode 100644 second_message.txt

Agora temos dois commits em nosso histórico. Vamos visualizar o log novamente:

git log

Você verá duas entradas de commit, com a mais recente no topo. Cada commit tem um identificador único (a longa sequência de caracteres).

Para comparar dois commits específicos, podemos usar git log com a sintaxe de intervalo commit1..commit2. Isso mostra os commits que são alcançáveis a partir de commit2, mas não a partir de commit1.

Vamos encontrar os IDs dos commits para nossos dois commits. Você pode obter os IDs curtos da saída git log --oneline. Por exemplo, se o ID do seu primeiro commit fosse a1b2c3d e o do seu segundo fosse e4f5g6h, você usaria esses IDs.

git log --oneline

Exemplo de saída:

e4f5g6h (HEAD -> master) Add a second message file
a1b2c3d Send a message to the future

Agora, vamos comparar o estado do projeto entre o primeiro commit (a1b2c3d) e o segundo commit (e4f5g6h). Substitua os IDs de exemplo pelos seus IDs de commit reais:

git log a1b2c3d..e4f5g6h

Este comando mostrará os commits que foram feitos após o commit com o ID a1b2c3d até e incluindo o commit com o ID e4f5g6h. Neste caso, ele deve mostrar o segundo commit.

Compreender como comparar commits usando git log é crucial para navegar no histórico do seu projeto. Ele permite que você veja a sequência de mudanças e entenda a evolução do seu código base.

Executar git diff branch1 branch2

Na etapa anterior, usamos git log para ver quais commits estavam presentes em diferentes partes do nosso histórico. Agora, vamos usar o comando git diff para ver as mudanças reais entre dois pontos diferentes no tempo ou entre diferentes branches. Isso é como comparar duas versões da sua máquina do tempo e ver exatamente quais partes foram adicionadas, removidas ou modificadas.

Primeiro, certifique-se de estar no diretório do seu projeto:

cd ~/project/my-time-machine

Atualmente, temos apenas um branch, master. Para demonstrar a comparação de branches, vamos criar um novo branch chamado feature-branch. Pense em um branch como uma linha do tempo alternativa onde você pode trabalhar em novos recursos ou experimentos sem afetar a linha do tempo principal (master).

git branch feature-branch

Agora, vamos mudar para o nosso novo branch:

git checkout feature-branch

Você deve ver uma saída indicando que você mudou de branch:

Switched to branch 'feature-branch'

Neste novo branch, vamos fazer uma alteração no nosso arquivo message.txt:

echo "Adding a line on the feature branch." >> message.txt

Este comando anexa uma nova linha ao arquivo message.txt.

Agora, vamos commitar essa alteração no feature-branch:

git add message.txt
git commit -m "Add a line to message.txt on feature branch"

Você deve ver uma saída semelhante a esta após o commit:

[feature-branch a1b2c3d] Add a line to message.txt on feature branch
 1 file changed, 1 insertion(+)

Agora temos dois branches (master e feature-branch) com diferentes históricos de commits. O branch master tem os dois primeiros commits, e o feature-branch tem esses dois commits mais o novo commit que acabamos de fazer.

Vamos usar git diff para ver as diferenças entre o branch master e o feature-branch.

git diff master feature-branch

A saída mostrará as linhas exatas que são diferentes entre os dois branches:

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a line on the feature branch.

Esta saída mostra que o arquivo message.txt é diferente. A linha que começa com + indica uma linha que foi adicionada no feature-branch em comparação com o branch master.

Usar git diff é incrivelmente poderoso para entender exatamente quais mudanças foram feitas entre diferentes versões do seu projeto ou entre diferentes branches. Ele ajuda você a revisar as mudanças antes de mesclá-las e identificar onde modificações específicas ocorreram.

Pressione q para sair da visualização de diff e retornar à linha de comando.

Verificar com git merge-base

Nesta etapa, exploraremos o comando git merge-base. Este comando é útil para encontrar o melhor ancestral comum entre dois commits. Pense nisso como encontrar o ponto no tempo onde duas linhas do tempo diferentes (branches) divergiram.

Primeiro, certifique-se de estar no diretório do seu projeto:

cd ~/project/my-time-machine

Temos dois branches, master e feature-branch. O feature-branch foi criado a partir do master, e então um novo commit foi adicionado ao feature-branch. O ancestral comum desses dois branches é o commit no master logo antes do feature-branch ser criado.

Vamos usar git merge-base para encontrar o ancestral comum de master e feature-branch:

git merge-base master feature-branch

A saída deste comando será o ID do commit do ancestral comum. Este deve ser o ID do commit do segundo commit que fizemos no branch master antes de criar o feature-branch.

Exemplo de saída:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

(O ID do commit real será diferente no seu caso).

Para verificar se este é de fato o ancestral comum, você pode usar git log --oneline para ver o histórico de ambos os branches e confirmar visualmente o ID do commit.

git log --oneline --graph --all

Este comando mostrará uma representação gráfica do seu histórico de commits em todos os branches. Você pode rastrear a partir dos topos de master e feature-branch para encontrar onde seus históricos convergem. O ID do commit identificado por git merge-base deve ser esse ponto de convergência.

Compreender o ancestral comum é importante no Git, especialmente quando você está se preparando para mesclar branches. O Git usa o ancestral comum para descobrir as mudanças que precisam ser combinadas.

Resumo

Neste laboratório, aprendemos como verificar se um branch Git está sincronizado com outro branch usando vários comandos Git. Começamos usando git log para comparar commits entre branches, entendendo como visualizar o histórico de commits e identificar diferenças usando a sintaxe de intervalo. Isso nos permitiu ver quais commits existem em um branch, mas não no outro.

Em seguida, exploramos o comando git diff para examinar as diferenças reais de conteúdo entre branches, vendo as mudanças linha por linha. Finalmente, usamos git merge-base para encontrar o commit ancestral comum de dois branches, o que ajuda a determinar se um branch está totalmente incluído no outro. Essas etapas fornecem uma abordagem abrangente para verificar a sincronização de branches no Git.