Comment vérifier si un fichier a été supprimé dans Git

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un fichier a été supprimé dans un dépôt Git. Nous explorerons différentes méthodes pour identifier les fichiers supprimés, notamment en utilisant git log pour consulter l'historique des modifications et git status pour voir l'état actuel de votre répertoire de travail.

À travers des étapes pratiques, vous créerez, validerez (commit) puis supprimerez un fichier, en observant comment Git suit ces modifications. Vous utiliserez spécifiquement git log -- <file> pour voir le commit où le fichier a été supprimé et git status pour voir les fichiers supprimés avant qu'ils ne soient validés. Enfin, vous testerez ces méthodes sur des fichiers existants pour consolider votre compréhension.

Skills Graph

Exécuter git log -- File pour vérifier la suppression

Dans cette étape, nous allons explorer comment utiliser git log pour consulter l'historique des modifications de notre dépôt, en particulier pour voir comment il indique les suppressions de fichiers.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet. Ouvrez votre terminal et tapez :

cd ~/project/my-time-machine

Maintenant, créons un nouveau fichier que nous supprimerons plus tard. Nous l'appellerons to_be_deleted.txt.

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

Vérifions que le fichier a été créé :

cat to_be_deleted.txt

Vous devriez voir :

This file is temporary.

Maintenant, ajoutons ce fichier à la zone de préparation (staging area) et validons-le (commit). Cela enregistrera son existence dans l'historique Git de notre projet.

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

Vous devriez voir une sortie similaire à celle-ci, indiquant qu'un nouveau commit a été créé :

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

Maintenant, supprimons le fichier en utilisant la commande rm :

rm to_be_deleted.txt

Le fichier n'est plus présent dans votre système de fichiers. Mais que sait Git à ce sujet ? Vérifions l'état :

git status

Vous devriez voir quelque chose comme cela :

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)

Git identifie correctement que le fichier a été supprimé. C'est parce que Git suit l'état de vos fichiers. Lorsqu'un fichier suivi est supprimé, Git remarque le changement.

Maintenant, validons cette suppression. Nous utilisons à nouveau git add pour préparer la suppression, puis git commit.

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

Vous devriez voir une sortie indiquant que la suppression a été validée :

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

Enfin, utilisons git log pour voir l'historique, y compris la suppression.

git log

Vous verrez deux entrées de commit. La plus récente aura le message "Delete the temporary file" et indiquera que to_be_deleted.txt a été supprimé.

Appuyez sur q pour quitter la vue du journal.

Cela démontre que Git suit non seulement la création et la modification des fichiers, mais aussi leur suppression, fournissant ainsi un historique complet de l'évolution de votre projet.

Utiliser git status pour les fichiers supprimés

Dans cette étape, nous allons approfondir l'utilisation de git status pour gérer les fichiers supprimés avant de valider (commit) les modifications.

Assurez-vous que vous êtes toujours dans le répertoire de votre projet :

cd ~/project/my-time-machine

Nous avons précédemment supprimé to_be_deleted.txt et validé la suppression. Créons un autre fichier, puis supprimons-le sans valider immédiatement la suppression.

Créez un nouveau fichier appelé another_file.txt :

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

Ajoutez et validez ce nouveau fichier :

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

Vous devriez voir une sortie confirmant le commit :

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

Maintenant, supprimons another_file.txt en utilisant la commande rm :

rm another_file.txt

Le fichier est maintenant supprimé de votre système de fichiers. Vérifions l'état de notre dépôt :

git status

Cette fois, la sortie ressemblera à ceci :

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)

Notez que Git reconnaît la suppression et liste another_file.txt sous "Changes not staged for commit". Cela signifie que Git sait que le fichier a été supprimé, mais que cette modification n'a pas encore été préparée pour être incluse dans le prochain commit.

C'est un point crucial : supprimer un fichier de votre système de fichiers ne prépare pas automatiquement la suppression dans Git. Vous devez explicitement indiquer à Git que vous souhaitez enregistrer cette suppression dans votre historique.

La commande git status est votre fenêtre sur l'état actuel de votre dépôt. Elle vous indique quels fichiers ont été modifiés, quels sont nouveaux et non suivis, et quels ont été supprimés. En vérifiant régulièrement git status, vous pouvez rester informé des modifications de votre projet et décider quelles modifications vous souhaitez inclure dans votre prochain commit.

Dans l'étape suivante, nous verrons comment Git gère les fichiers existants qui ne sont pas supprimés.

Tester les fichiers existants

Dans cette étape, nous allons voir comment Git gère les modifications apportées aux fichiers déjà suivis.

Assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Nous avons le fichier message.txt que nous avons créé et validé (commit) dans le premier laboratoire. Modifions ce fichier. Nous pouvons utiliser la commande echo avec >> pour ajouter du texte au fichier existant.

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

L'opérateur >> ajoute le texte à la fin du fichier, plutôt que de l'écraser (ce que ferait >).

Voyons le contenu du fichier pour confirmer la modification :

cat message.txt

Vous devriez voir les deux lignes :

Hello, Future Me
Hello again, Future Me!

Maintenant, vérifions l'état de notre dépôt en utilisant git status :

git status

La sortie affichera quelque chose comme cela :

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)

Git identifie correctement que message.txt a été "modifié". Il le sait car il compare la version actuelle du fichier dans votre répertoire de travail avec la version stockée dans le dernier commit.

Tout comme pour les fichiers supprimés, Git vous indique que les modifications ne sont "pas prêtes pour le commit". Cela signifie que vous avez modifié le fichier, mais que vous n'avez pas encore indiqué à Git que vous souhaitez inclure ces modifications spécifiques dans votre prochain point de sauvegarde.

Ceci est le flux de travail standard dans Git : vous modifiez des fichiers, puis vous utilisez git status pour voir ce que vous avez modifié, ensuite vous utilisez git add pour préparer (stager) les modifications que vous souhaitez valider, et enfin, vous utilisez git commit pour enregistrer ces modifications préparées comme une nouvelle version dans l'historique de votre projet.

Comprendre la sortie de git status est essentiel pour travailler efficacement avec Git. Elle fournit un aperçu clair de l'état de votre projet et vous guide dans les prochaines étapes à suivre pour enregistrer vos modifications.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un fichier a été supprimé dans Git. Nous avons commencé par créer et valider (commit) un fichier pour l'enregistrer dans l'historique du dépôt. Ensuite, nous avons supprimé le fichier en utilisant la commande rm et avons observé comment git status signalait précisément la suppression comme une modification. Enfin, nous avons validé la suppression, enregistrant cet événement dans l'historique Git.

Grâce à ces étapes, nous avons compris que Git suit les suppressions de fichiers et fournit des outils tels que git status pour identifier ces modifications avant qu'elles ne soient validées. Ce processus montre comment Git conserve un enregistrement des événements du cycle de vie des fichiers, y compris la création et la suppression.