Como Verificar se um Commit Git é o Mais Recente

Introdução

Neste laboratório, você aprenderá como verificar se um commit (commit) específico do Git é o commit mais recente em seu repositório. Exploraremos como usar o comando git log -1 para visualizar o commit mais recente apontado por HEAD, e então usaremos git rev-parse HEAD para recuperar o identificador único desse commit. Finalmente, você testará esses comandos com commits mais antigos para solidificar sua compreensão de como HEAD representa a posição atual no histórico do seu projeto.

Executar git log -1 para Verificar HEAD

Nesta etapa, aprenderemos como verificar rapidamente o commit mais recente em nosso repositório Git usando o comando git log -1. Esta é uma maneira prática de ver o estado atual do histórico do seu projeto sem visualizar todo o log.

Primeiro, certifique-se de estar no seu diretório my-time-machine. Se você não estiver, use o comando cd para navegar até lá:

cd ~/project/my-time-machine

Agora, vamos executar o comando para ver o último commit:

git log -1

Você deve ver uma saída semelhante a esta:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Jane Doe <jane.doe@example.com>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

O comando git log -1 mostra os detalhes do último commit feito no branch (ramificação) atual. A opção -1 diz ao Git para mostrar apenas o commit mais recente.

Observe a parte (HEAD -> master). HEAD é um ponteiro que sempre aponta para o commit mais recente no branch atual. Neste caso, ele está apontando para o commit mais recente no branch master. Pense em HEAD como sua posição atual na linha do tempo do projeto. Quando você faz um novo commit, HEAD se move automaticamente para frente para apontar para esse novo commit.

Compreender HEAD é crucial porque muitos comandos Git operam no commit para o qual HEAD está apontando. Nas próximas etapas, exploraremos como HEAD se relaciona com identificadores de commit específicos.

Comparar Commit com git rev-parse HEAD

Na etapa anterior, vimos que git log -1 mostra o commit para o qual HEAD está apontando. Agora, vamos usar o comando git rev-parse HEAD para obter apenas o identificador único (o hash SHA-1) do commit que HEAD está atualmente apontando.

Certifique-se de ainda estar no diretório ~/project/my-time-machine.

Execute o seguinte comando:

git rev-parse HEAD

Você deve ver uma longa sequência de letras e números, que é o hash SHA-1 completo do seu último commit:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

Compare esta saída com o hash do commit que você viu na saída de git log -1 da etapa anterior. Eles devem ser os mesmos!

O comando git rev-parse é um comando Git de baixo nível que é frequentemente usado para traduzir vários tipos de referências Git (como nomes de branch, tags ou HEAD) em seus hashes SHA-1 correspondentes. É uma ferramenta poderosa para scripting e automação no Git.

Ao usar git rev-parse HEAD, você está essencialmente perguntando ao Git: "Qual é o ID exato do commit que minha posição atual (HEAD) representa?" Isso fornece o identificador bruto do snapshot com o qual você está trabalhando atualmente.

Compreender como obter o hash bruto do commit é importante porque esses hashes são a maneira fundamental como o Git rastreia versões específicas do seu projeto. Você pode usar esses hashes para se referir a qualquer ponto no histórico do seu projeto.

Testar com Commits Anteriores

Nas etapas anteriores, aprendemos sobre HEAD e como obter seu hash de commit. Agora, vamos ver como o Git se refere a commits mais antigos.

Atualmente, temos apenas um commit em nosso repositório. Para demonstrar como se referir a commits mais antigos, precisamos fazer outro commit.

Primeiro, vamos adicionar outra linha ao nosso arquivo message.txt. Use o comando echo com >> para anexar texto ao arquivo:

echo "This is a second message." >> message.txt

Agora, vamos verificar o status:

git status

Você deve ver que message.txt foi modificado:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add and/or git commit -a)

Agora, prepare as alterações e crie um novo commit:

git add message.txt
git commit -m "Add a second message"

Você deve ver a saída indicando que um novo commit foi criado:

[master a1b2c3d] Add a second message
 1 file changed, 1 insertion(+)

Agora temos dois commits. Vamos visualizar o log novamente:

git log --oneline

A opção --oneline fornece uma visualização concisa do log. Você deve ver algo como isto (os hashes serão diferentes):

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

O commit superior é o mais recente, e é para onde HEAD está apontando. O commit abaixo dele é o mais antigo.

O Git fornece maneiras de se referir a commits relativos a HEAD. O commit diretamente antes de HEAD pode ser referido como HEAD~1 ou HEAD^. Vamos tentar obter o hash do commit anterior usando git rev-parse:

git rev-parse HEAD~1

Você deve ver o hash do primeiro commit que você fez:

e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3

Este hash deve corresponder ao hash do commit "Send a message to the future" na sua saída git log --oneline.

Você pode usar HEAD~2, HEAD~3 e assim por diante, para se referir a commits mais distantes no histórico. Essa referência relativa é muito útil para navegar no histórico do seu projeto e realizar operações em versões específicas do passado.

Resumo

Neste laboratório, aprendemos como verificar se um commit Git é o mais recente, compreendendo o papel de HEAD. Usamos o comando git log -1 para visualizar os detalhes do commit mais recente, observando que HEAD aponta para este commit. Em seguida, usamos git rev-parse HEAD para recuperar o hash SHA-1 único do commit para o qual HEAD está atualmente apontando, que representa o commit mais recente no branch atual.