Como Verificar se um Repositório Git Possui Alterações Não Commitadas

Introdução

Neste laboratório, você aprenderá como verificar alterações não confirmadas em um repositório Git. Exploraremos o comando essencial git status para visualizar o estado geral do seu diretório de trabalho e as alterações preparadas (staged).

Além disso, você descobrirá como usar o comando git diff para inspecionar as modificações específicas feitas em seus arquivos, permitindo que você veja exatamente o que foi alterado antes de confirmar (commit). Por fim, abordaremos brevemente a combinação de verificações para alterações preparadas (staged) e não preparadas (unstaged).

Executar git status para Visualizar as Alterações

Nesta etapa, aprenderemos como usar o comando git status para ver o estado atual do nosso repositório Git. Este comando é seu melhor amigo ao trabalhar com Git, pois ele informa exatamente o que está acontecendo.

Primeiro, certifique-se de estar no seu diretório my-time-machine. Você pode fazer isso digitando:

cd ~/project/my-time-machine

Agora, vamos executar o comando git status:

git status

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

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Vamos analisar essa saída:

• On branch master: Isso informa que você está atualmente na branch master. Branches são como diferentes linhas do tempo em seu projeto.
• Your branch is up to date with 'origin/master': Isso indica que sua branch master local está sincronizada com a branch remota origin/master (aprenderemos mais sobre repositórios remotos mais tarde).
• nothing to commit, working tree clean: Este é o estado ideal! Significa que não há alterações em seu projeto que não tenham sido salvas (commitadas) em seu histórico Git.

O comando git status é crucial porque ajuda você a entender quais arquivos foram modificados, quais são novos e não rastreados (untracked), e quais alterações estão prontas para serem commitadas. É o primeiro comando que você deve executar após fazer qualquer alteração em seu projeto para ver como o Git vê essas alterações.

Usar git diff para Inspecionar as Modificações

Nesta etapa, aprenderemos como usar o comando git diff para ver as alterações exatas que você fez em seus arquivos. Enquanto git status informa quais arquivos foram alterados, git diff mostra o que foi alterado dentro desses arquivos.

Primeiro, vamos fazer uma alteração em nosso arquivo message.txt. Certifique-se de ainda estar no diretório ~/project/my-time-machine.

Abra o arquivo usando o editor nano:

nano message.txt

Adicione uma nova linha ao arquivo, por exemplo:

Hello, Future Me
This is a new line.

Pressione Ctrl + X para sair, depois Y para salvar e Enter para confirmar o nome do arquivo.

Agora que modificamos o arquivo, vamos ver como o Git vê essa alteração usando git status:

git status

Você deve ver uma saída indicando que message.txt foi modificado:

On branch master
Your branch is up to date with 'origin/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")

O Git nos diz que message.txt foi modificado e as alterações não foram preparadas para commit. Isso significa que alteramos o arquivo, mas ainda não dissemos ao Git para preparar essa alteração para um commit.

Agora, vamos usar git diff para ver as alterações específicas:

git diff

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

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+This is a new line.

Vamos entender essa saída:

• As linhas que começam com --- e +++ mostram o arquivo original (a/message.txt) e o novo arquivo (b/message.txt).
• A linha que começa com @@ é chamada de "hunk header" (cabeçalho do bloco). Ele mostra onde as alterações estão localizadas no arquivo. -1 +1,2 significa que, a partir da linha 1 no arquivo original, 1 linha foi removida e, a partir da linha 1 no novo arquivo, 2 linhas foram adicionadas.
• As linhas que começam com - mostram as linhas que foram removidas.
• As linhas que começam com + mostram as linhas que foram adicionadas.

Em nosso caso, adicionamos uma linha, então você vê uma linha começando com +.

O comando git diff é incrivelmente útil para revisar suas alterações antes de prepará-las (staging) ou commitá-las. Ele ajuda você a detectar erros e garantir que você está incluindo apenas as modificações pretendidas em seus commits.

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

Combinar Verificações de Alterações Preparadas e Não Preparadas

Nesta etapa, exploraremos como o Git lida com alterações preparadas (staged) e não preparadas (unstaged) e como git diff pode ser usado para inspecioná-las.

Lembre-se da etapa anterior que modificamos message.txt, mas não preparamos as alterações. Vamos preparar as alterações agora usando git add:

git add message.txt

Agora, execute git status novamente:

git status

A saída deve mostrar que as alterações agora estão preparadas:

On branch master
Your branch is up to date with 'origin/master'.

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

O Git agora mostra Changes to be committed (Alterações a serem commitadas), indicando que as modificações em message.txt estão na área de preparação (staging area), prontas para o próximo commit.

O que acontece se executarmos git diff agora?

git diff

Você pode se surpreender ao não ver nenhuma saída. Isso ocorre porque git diff por padrão mostra a diferença entre seu diretório de trabalho e a área de preparação. Como as alterações em nosso diretório de trabalho agora são as mesmas que as alterações na área de preparação (porque acabamos de adicioná-las), não há diferença a ser mostrada.

Para ver a diferença entre a área de preparação e o último commit, precisamos usar uma forma diferente do comando git diff:

git diff --staged

Ou, equivalentemente:

git diff --cached

Ambos os comandos fazem a mesma coisa. Vamos executá-lo:

git diff --staged

Agora você deve ver a diferença entre as alterações preparadas e o último commit:

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+This is a new line.

Isso mostra a alteração exata que fizemos: adicionar a linha "This is a new line.".

Entender a diferença entre git diff (diretório de trabalho vs. área de preparação) e git diff --staged (área de preparação vs. último commit) é fundamental para usar o Git de forma eficaz. Ele permite que você revise cuidadosamente suas alterações em diferentes estágios antes de fazer um commit permanente.

Resumo

Neste laboratório, aprendemos como verificar alterações não commitadas em um repositório Git. Começamos usando o comando git status para obter uma visão geral do estado do repositório, incluindo o branch atual e se há arquivos modificados, novos ou não rastreados. Este comando é essencial para entender quais alterações estão presentes.

Em seguida, exploramos o comando git diff para inspecionar as modificações específicas feitas dentro dos arquivos. Enquanto git status nos informa quais arquivos foram alterados, git diff mostra as diferenças exatas linha por linha, permitindo que revisemos o conteúdo de nossas alterações antes de prepará-las (staging) ou commitá-las.