Como Verificar se um Arquivo foi Excluído no Git

Introdução

Neste laboratório, você aprenderá como verificar se um arquivo foi excluído em um repositório Git. Exploraremos diferentes métodos para identificar arquivos excluídos, incluindo o uso de git log para visualizar o histórico de alterações e git status para ver o estado atual do seu diretório de trabalho.

Através de passos práticos, você criará, fará commit e, em seguida, excluirá um arquivo, observando como o Git rastreia essas alterações. Você usará especificamente git log -- <file> para ver o commit onde o arquivo foi removido e git status para ver os arquivos excluídos antes que sejam commitados. Finalmente, você testará esses métodos em arquivos existentes para solidificar sua compreensão.

Executar git log -- Arquivo para Verificar a Exclusão

Nesta etapa, exploraremos como usar git log para ver o histórico de alterações em nosso repositório, focando especificamente em como ele mostra as exclusões de arquivos.

Primeiro, vamos garantir que estamos no diretório do nosso projeto. Abra seu terminal e digite:

cd ~/project/my-time-machine

Agora, vamos criar um novo arquivo que posteriormente excluiremos. Vamos chamá-lo de to_be_deleted.txt.

echo "This file is temporary." > to_be_deleted.txt

Verifique se o arquivo foi criado:

cat to_be_deleted.txt

Você deve ver:

This file is temporary.

Agora, vamos adicionar este arquivo à área de staging (staging area) e fazer o commit. Isso registrará sua existência em nosso histórico do Git.

git add to_be_deleted.txt
git commit -m "Add a file to be deleted"

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

[master <commit-id>] Add a file to be deleted
 1 file changed, 1 insertion(+)
 create mode 100644 to_be_deleted.txt

Agora, vamos excluir o arquivo usando o comando rm:

rm to_be_deleted.txt

O arquivo agora desapareceu do seu sistema de arquivos. Mas o que o Git sabe sobre isso? Vamos verificar o status:

git status

Você deve ver algo como isto:

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

no changes added to commit but untracked files present (use "git add" to track)

O Git identifica corretamente que o arquivo foi excluído. Isso ocorre porque o Git rastreia o estado de seus arquivos. Quando um arquivo rastreado é removido, o Git percebe a alteração.

Agora, vamos fazer o commit desta exclusão. Usamos git add novamente para preparar a exclusão e, em seguida, git commit.

git add to_be_deleted.txt
git commit -m "Delete the temporary file"

Você deve ver uma saída indicando que a exclusão foi commitada:

[master <commit-id>] Delete the temporary file
 1 file changed, 1 deletion(-)
 delete mode 100644 to_be_deleted.txt

Finalmente, vamos usar git log para ver o histórico, incluindo a exclusão.

git log

Você verá duas entradas de commit. A mais recente terá a mensagem "Delete the temporary file" e mostrará que to_be_deleted.txt foi excluído.

Pressione q para sair da visualização do log.

Isso demonstra como o Git rastreia não apenas a criação e modificação de arquivos, mas também sua exclusão, fornecendo um histórico completo da evolução do seu projeto.

Usar git status para Arquivos Excluídos

Nesta etapa, exploraremos mais a fundo como git status nos ajuda a gerenciar arquivos excluídos antes de commitar as alterações.

Certifique-se de que você ainda está no diretório do seu projeto:

cd ~/project/my-time-machine

Anteriormente, excluímos to_be_deleted.txt e commitamos a exclusão. Vamos criar outro arquivo e, em seguida, excluí-lo sem commitar a exclusão imediatamente.

Crie um novo arquivo chamado another_file.txt:

echo "This is another file." > another_file.txt

Adicione e comite este novo arquivo:

git add another_file.txt
git commit -m "Add another file"

Você deve ver a saída confirmando o commit:

[master <commit-id>] Add another file
 1 file changed, 1 insertion(+)
 create mode 100644 another_file.txt

Agora, vamos excluir another_file.txt usando o comando rm:

rm another_file.txt

O arquivo agora é removido do seu sistema de arquivos. Vamos verificar o status do nosso repositório:

git status

Desta vez, a saída será semelhante a esta:

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

no changes added to commit but untracked files present (use "git add" to track)

Observe que o Git reconhece a exclusão e lista another_file.txt em "Changes not staged for commit". Isso significa que o Git sabe que o arquivo foi removido, mas essa alteração ainda não foi preparada para ser incluída no próximo commit.

Este é um ponto crucial: excluir um arquivo do seu sistema de arquivos não prepara automaticamente a exclusão no Git. Você precisa dizer explicitamente ao Git que deseja registrar essa exclusão em seu histórico.

O comando git status é sua janela para o estado atual do seu repositório. Ele informa quais arquivos foram modificados, quais são novos e não rastreados e quais foram excluídos. Verificando regularmente o git status, você pode se manter informado sobre as alterações em seu projeto e decidir quais alterações deseja incluir em seu próximo commit.

Na próxima etapa, veremos como o Git lida com arquivos existentes que não são excluídos.

Testar Arquivos Existentes

Nesta etapa, veremos como o Git lida com modificações em arquivos que já estão sendo rastreados.

Certifique-se de que você está no diretório do seu projeto:

cd ~/project/my-time-machine

Temos o arquivo message.txt que criamos e commitamos no primeiro laboratório. Vamos modificar este arquivo. Podemos usar o comando echo com >> para anexar texto ao arquivo existente.

echo "Hello again, Future Me!" >> message.txt

O operador >> anexa o texto ao final do arquivo, em vez de sobrescrevê-lo (o que > faria).

Vamos visualizar o conteúdo do arquivo para confirmar a alteração:

cat message.txt

Você deve ver ambas as linhas:

Hello, Future Me
Hello again, Future Me!

Agora, vamos verificar o status do nosso repositório usando git status:

git status

A saída mostrará algo como isto:

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 but untracked files present (use "git add" to track)

O Git identifica corretamente que message.txt foi "modificado". Ele sabe disso porque compara a versão atual do arquivo em seu diretório de trabalho com a versão armazenada no último commit.

Assim como com arquivos excluídos, o Git informa que as alterações "não foram preparadas para commit". Isso significa que você modificou o arquivo, mas ainda não informou ao Git que deseja incluir essas modificações específicas em seu próximo ponto de salvamento.

Este é o fluxo de trabalho padrão no Git: você faz alterações nos arquivos, então usa git status para ver o que você alterou, então usa git add para preparar as alterações que deseja commitar e, finalmente, usa git commit para salvar essas alterações preparadas como uma nova versão no histórico do seu projeto.

Compreender a saída de git status é fundamental para trabalhar de forma eficaz com o Git. Ele fornece uma visão geral clara do estado do seu projeto e orienta você sobre as próximas etapas que você precisa tomar para registrar suas alterações.

Resumo

Neste laboratório, aprendemos como verificar se um arquivo foi excluído no Git. Começamos criando e commitando um arquivo para estabelecer sua presença no histórico do repositório. Em seguida, excluímos o arquivo usando o comando rm e observamos como git status relatou com precisão a exclusão como uma alteração. Finalmente, commitamos a exclusão, registrando este evento no histórico do Git.

Por meio dessas etapas, entendemos que o Git rastreia as exclusões de arquivos e fornece ferramentas como git status para identificar essas alterações antes que sejam commitadas. Este processo demonstra como o Git mantém um registro dos eventos do ciclo de vida dos arquivos, incluindo criação e exclusão.