Comment vérifier si un fichier est ignoré par Git

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser la commande git check-ignore pour déterminer si un fichier est ignoré par Git. Vous allez créer un fichier .gitignore, y ajouter des motifs (patterns), puis utiliser git check-ignore pour vérifier quels fichiers sont ignorés et pourquoi.

Vous explorerez également comment différents motifs dans le fichier .gitignore influencent quels fichiers sont exclus du suivi (tracking), ce qui vous permettra de mieux comprendre comment Git gère les fichiers ignorés.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/SetupandConfigGroup(["Setup and Config"]) git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/SetupandConfigGroup -.-> git/git("Show Version") git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/clean("Clean Workspace") git/BranchManagementGroup -.-> git/checkout("Switch Branches") subgraph Lab Skills git/git -.-> lab-560027{{"Comment vérifier si un fichier est ignoré par Git"}} git/add -.-> lab-560027{{"Comment vérifier si un fichier est ignoré par Git"}} git/status -.-> lab-560027{{"Comment vérifier si un fichier est ignoré par Git"}} git/clean -.-> lab-560027{{"Comment vérifier si un fichier est ignoré par Git"}} git/checkout -.-> lab-560027{{"Comment vérifier si un fichier est ignoré par Git"}} end

Exécuter git check-ignore sur un fichier

Dans cette étape, nous allons apprendre à utiliser la commande git check-ignore. Cette commande est très utile pour comprendre pourquoi Git ignore certains fichiers ou répertoires. Elle vous aide à déboguer votre fichier .gitignore.

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 fichier que nous attendons que Git ignore. Nous allons créer un fichier nommé temp.log. Souvent, les fichiers de journal (log files) sont ignorés dans les dépôts Git.

echo "This is a temporary log file." > temp.log

Ensuite, créons un fichier .gitignore et ajoutons un motif pour ignorer les fichiers .log.

echo "*.log" > .gitignore

Maintenant, nous pouvons utiliser git check-ignore pour voir si Git ignore temp.log.

git check-ignore temp.log

Si Git ignore le fichier, la commande affichera le motif du fichier .gitignore qui correspond au fichier. Vous devriez voir une sortie similaire à celle-ci :

.gitignore:1:*.log	temp.log

Cette sortie nous indique que le fichier temp.log est ignoré en raison du motif *.log à la ligne 1 du fichier .gitignore.

Si le fichier n'était pas ignoré, la commande ne produirait aucune sortie.

Comprendre git check-ignore est essentiel pour gérer efficacement les fichiers de votre projet. Cela vous empêche de commettre accidentellement des fichiers que vous ne voulez pas dans votre dépôt, comme des fichiers temporaires, des artefacts de construction (build artifacts) ou des fichiers de configuration sensibles.

Vérifier les motifs (patterns) de .gitignore

Dans cette étape, nous allons explorer comment différents motifs dans le fichier .gitignore influencent quels fichiers sont ignorés. Le fichier .gitignore utilise des motifs spécifiques pour indiquer à Git quels fichiers ou répertoires exclure du suivi (tracking).

Assurez-vous que vous êtes toujours dans le répertoire ~/project/my-time-machine.

Ajoutons quelques fichiers supplémentaires et modifions notre fichier .gitignore pour voir comment différents motifs fonctionnent.

Tout d'abord, créons quelques nouveaux fichiers :

mkdir build
echo "This is a build artifact." > build/output.txt
echo "Another log file." > error.log
echo "A temporary file." > temp.dat
echo "A configuration file." > config.ini

Maintenant, éditons le fichier .gitignore pour inclure plus de motifs. Nous pouvons utiliser l'éditeur nano pour cela.

nano .gitignore

À l'intérieur de l'éditeur nano, vous devriez voir *.log. Ajoutez les lignes suivantes en dessous :

build/
*.dat
config.ini

Votre fichier .gitignore devrait maintenant ressembler à ceci :

*.log
build/
*.dat
config.ini

Appuyez sur Ctrl + X, puis Y, et Enter pour enregistrer et quitter nano.

Maintenant, utilisons git check-ignore avec le drapeau -v pour voir quel motif ignore chaque fichier. Le drapeau -v fournit une sortie détaillée (verbose output), montrant le motif correspondant et le fichier source (.gitignore dans ce cas).

git check-ignore -v temp.log error.log build/output.txt temp.dat config.ini

Vous devriez voir une sortie similaire à celle-ci :

.gitignore:1:*.log	temp.log
.gitignore:1:*.log	error.log
.gitignore:2:build/	build/output.txt
.gitignore:3:*.dat	temp.dat
.gitignore:4:config.ini	config.ini

Cette sortie confirme que :

temp.log et error.log sont ignorés par le motif *.log.
build/output.txt est ignoré car tout le répertoire build/ est ignoré.
temp.dat est ignoré par le motif *.dat.
config.ini est ignoré par le motif config.ini.

Comprendre ces motifs est essentiel pour maintenir votre dépôt propre et concentré uniquement sur les fichiers que vous souhaitez suivre.

Tester les fichiers non ignorés

Dans cette étape, nous allons utiliser git check-ignore pour confirmer que les fichiers qui ne sont pas ignorés par le fichier .gitignore ne produisent aucune sortie. Cela vous aidera à mieux comprendre le fonctionnement de la commande et à vérifier que Git suit les fichiers que vous souhaitez qu'il suive.

Assurez-vous que vous êtes dans le répertoire ~/project/my-time-machine.

Nous avons déjà le fichier message.txt depuis un laboratoire précédent. Ce fichier n'est pas répertorié dans notre fichier .gitignore, donc Git ne devrait pas l'ignorer.

Utilisons git check-ignore sur le fichier message.txt :

git check-ignore message.txt

Comme prévu, cette commande ne devrait produire aucune sortie. Cela indique que message.txt n'est pas ignoré par aucun motif dans votre fichier .gitignore ni par toute autre règle d'ignorance.

Maintenant, créons un autre fichier que nous ne souhaitons pas ignorer :

echo "This file should be tracked." > important_file.txt

Et vérifions son statut d'ignorance :

git check-ignore important_file.txt

Encore une fois, vous ne devriez voir aucune sortie, confirmant que important_file.txt n'est pas ignoré.

Enfin, utilisons git status pour voir comment Git voit ces fichiers.

git status

Vous devriez voir une sortie similaire à celle-ci :

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	new file:   .gitignore

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	important_file.txt
	message.txt

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

Notez que important_file.txt et message.txt sont répertoriés sous "Untracked files" (fichiers non suivis). Cela signifie que Git les voit, mais ne suit pas actuellement leurs modifications. Les fichiers ignorés (temp.log, error.log, build/output.txt, temp.dat, config.ini) ne sont pas répertoriés ici car Git a été explicitement invité à les ignorer.

Cette étape renforce le concept selon lequel git check-ignore est un outil pour vérifier les règles d'ignorance, et que les fichiers qui ne correspondent pas aux règles d'ignorance apparaîtront comme "Non suivis" dans git status jusqu'à ce que vous les ajoutiez explicitement pour le suivi avec git add.

Résumé

Dans ce laboratoire, nous avons appris à utiliser la commande git check-ignore pour déterminer si un fichier spécifique est ignoré par Git. Nous avons pratiqué la création d'un fichier .gitignore, l'ajout de motifs (patterns) à celui-ci, puis l'utilisation de git check-ignore pour vérifier que les fichiers visés étaient effectivement ignorés. La sortie de git check-ignore nous a aidé à comprendre quel motif dans le fichier .gitignore était à l'origine de l'ignorance du fichier.

Nous avons également exploré comment différents motifs dans le fichier .gitignore influencent quels fichiers sont ignorés. En créant divers fichiers et en modifiant le fichier .gitignore avec différents motifs, nous avons mieux compris comment Git interprète ces motifs pour exclure des fichiers et des répertoires du suivi (tracking). Cette connaissance est essentielle pour gérer efficacement quels fichiers sont inclus dans un dépôt Git.