Como Verificar se uma Branch Git Possui Commits Não Enviados

Introdução

Neste laboratório, você aprenderá como verificar se sua branch Git local possui commits que ainda não foram enviados para um repositório remoto. Exploraremos diferentes métodos para identificar esses commits não enviados, começando com o comando git status para ver se sua branch está à frente da remota.

Em seguida, você aprenderá como usar o comando git log com argumentos específicos para listar os commits que estão presentes localmente, mas não na branch de rastreamento remota. Finalmente, discutiremos como verificar essa informação comparando sua branch local com o repositório remoto. Ao final deste laboratório, você estará equipado com as habilidades para determinar facilmente se suas alterações locais precisam ser enviadas.

Usar git status para Verificar Commits Adiantados

Nesta etapa, aprenderemos como usar o comando git status para ver se nossa branch local possui commits que estão à frente da branch remota. Este é um cenário comum quando você fez alterações localmente e ainda não as enviou para um repositório remoto.

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

cd ~/project/my-time-machine

Agora, vamos criar um novo arquivo e adicionar algum conteúdo a ele. Chamaremos este arquivo de future_plans.txt:

echo "Plan for world domination." > future_plans.txt

Em seguida, precisamos preparar este novo arquivo para um commit:

git add future_plans.txt

Agora, vamos criar um commit com uma mensagem descrevendo nossa alteração:

git commit -m "Add future plans"

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

[master abcdefg] Add future plans
 1 file changed, 1 insertion(+)
 create mode 100644 future_plans.txt

Agora criamos um novo commit em nossa branch master local. No entanto, este commit existe apenas localmente e não foi enviado para nenhum repositório remoto.

Vamos usar git status para ver o estado atual do nosso repositório:

git status

A saída agora deve mostrar que sua branch local está à frente da branch remota (se você tiver uma configurada, o que não temos neste exemplo básico, mas o Git ainda lhe dá a dica):

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   future_plans.txt

nothing to commit, working tree clean

A linha importante aqui é Your branch is ahead of 'origin/master' by 1 commit.. Isso nos diz que nossa branch master local tem um commit que não está presente na branch origin/master (que é o nome padrão para a branch remota que o Git espera).

Esta é uma informação muito útil. Ela permite que você saiba que você tem alterações locais que ainda não foram compartilhadas com outras pessoas. Em um cenário do mundo real com um repositório remoto, isso indicaria que você precisa fazer git push de suas alterações.

Executar git log --oneline @{u}..HEAD

Na etapa anterior, vimos como git status pode nos dizer se nossa branch local está à frente da branch remota. Agora, vamos usar o comando git log com uma sintaxe especial para ver exatamente quais commits estão à frente.

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

O comando que usaremos é git log --oneline @{u}..HEAD. Vamos detalhar este comando:

• git log: Este é o comando para visualizar o histórico de commits.
• --oneline: Esta opção exibe cada commit em uma única linha, tornando a saída concisa e fácil de ler.
• @{u}: Esta é uma sintaxe especial que se refere à branch upstream. Em nosso caso, como não definimos explicitamente uma branch upstream, o Git assume por padrão origin/master (assumindo que origin é o nome do remoto e master é a branch).
• ..HEAD: Esta é uma notação de intervalo. HEAD se refere ao topo da branch atual (nosso master local). O intervalo @{u}..HEAD significa "mostre-me os commits que são alcançáveis a partir de HEAD, mas não alcançáveis a partir de @{u}". Em termos mais simples, ele mostra os commits que estão em nossa branch local, mas não na branch remota upstream.

Agora, vamos executar o comando:

git log --oneline @{u}..HEAD

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

abcdefg (HEAD -> master) Add future plans

Esta saída mostra o commit que criamos na etapa anterior (Add future plans). O identificador único (abcdefg) será diferente em seu terminal, mas a mensagem do commit deve corresponder.

Este comando é incrivelmente útil para ver exatamente quais commits você está prestes a enviar para um repositório remoto. Ele fornece uma lista clara das alterações que você fez localmente e que ainda não foram compartilhadas.

Comparando esta saída com a saída de git status da etapa anterior, você pode ver que git status informa quantos commits você está à frente, enquanto git log @{u}..HEAD informa quais commits específicos você está à frente. Ambos os comandos fornecem informações valiosas sobre o estado do seu repositório local em relação à sua contraparte remota.

Verificação com Comparação Remota

Em um cenário do mundo real, você normalmente teria um repositório remoto (como no GitHub, GitLab ou Bitbucket) ao qual seu repositório local está conectado. Neste ambiente de laboratório, não temos um repositório remoto ativo para enviar. No entanto, podemos simular o conceito de comparar nossa branch local com uma branch remota usando os comandos que aprendemos.

Já usamos git status e git log --oneline @{u}..HEAD para ver os commits que estão em nossa branch local, mas não na branch upstream simulada (origin/master).

Vamos revisar a saída de git status novamente:

git status

Você ainda deve ver a linha indicando que sua branch está à frente:

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
  (use "git push" to publish your local commits)

... (rest of the output)

E a saída de git log --oneline @{u}..HEAD:

git log --oneline @{u}..HEAD

Isso deve mostrar o único commit que fizemos:

abcdefg (HEAD -> master) Add future plans

Esses dois comandos trabalham juntos para fornecer uma imagem clara da diferença entre sua branch local e sua branch upstream configurada. git status fornece um resumo, enquanto git log @{u}..HEAD fornece os detalhes dos commits específicos.

Em um projeto real, depois de ver esta saída, você normalmente executaria git push para enviar seus commits locais para o repositório remoto, tornando-os disponíveis para outros e atualizando a branch remota.

Como não temos um remoto para enviar neste laboratório, concluímos com sucesso o objetivo de entender como identificar commits que estão à frente da branch remota usando git status e git log.

Esta habilidade é fundamental para colaborar com outras pessoas e manter seus repositórios locais e remotos sincronizados. Ao verificar regularmente o status e o log, você pode estar ciente de suas alterações pendentes e garantir que as envie quando estiver pronto.

Resumo

Neste laboratório, aprendemos como verificar se uma branch Git tem commits não enviados (unpushed commits). Começamos usando o comando git status após fazer um commit local. A saída de git status indica claramente se a branch local está "à frente" de sua contraparte remota e por quantos commits, fornecendo uma maneira direta de ver se há alterações não enviadas.

Em seguida, exploramos o uso de git log --oneline @{u}..HEAD para obter uma visão mais detalhada dos commits específicos que estão na branch local, mas não na branch de rastreamento remota. Este comando lista os hashes e mensagens dos commits não enviados, oferecendo uma maneira precisa de identificar quais alterações estão pendentes. Finalmente, discutimos o conceito de verificar isso comparando as branches local e remota, reforçando a compreensão de como confirmar a presença de commits não enviados.