Comment utiliser .gitignore : Une introduction pratique avec des exemples

Apprenez à utiliser .gitignore pour garder votre dépôt Git propre. Ce tutoriel couvre les bases, les cas d'utilisation courants et des exemples pratiques pour vous aider à démarrer !

Actualisé 4 mars 2025 · 17 min de lecture

Lorsque vous travaillez avec Git, garder votre référentiel propre et organisé n'est pas seulement une bonne pratique, c'est essentiel pour une collaboration fluide et un contrôle de version efficace. C'est là que .gitignore entre en jeu. Ce fichier pratique indique à Git les fichiers à ignorer, évitant ainsi un encombrement inutile et permettant à vos commits de se concentrer sur ce qui compte vraiment.

Sans .gitignore, votre répertoire peut rapidement se remplir de fichiers temporaires, de journaux et d'autres éléments qui n'ont rien à faire dans le contrôle de version. Pire encore, vous risquez de partager accidentellement des informations sensibles.

Dans ce tutoriel, vous apprendrez à créer et à utiliser un fichier .gitignore pour garder votre projet en ordre, éviter les pièges les plus courants et travailler plus efficacement avec Git. Plongeons dans l'aventure !

Qu'est-ce qu'un fichier .gitignore ?

Un fichier .gitignore est un fichier de configuration utilisé dans Git pour indiquer au système de contrôle de version quels fichiers ou répertoires doivent être ignorés lorsque des modifications sont mises en page ou livrées.

Il empêche les fichiers inutiles, tels que les fichiers temporaires, générés par le système ou liés à la construction, d'encombrer votre référentiel. Garder votre référentiel propre facilite la collaboration et garantit que seuls les fichiers essentiels font l'objet d'un cursus.

Le fichier .gitignore est un simple fichier texte placé dans le répertoire racine de votre dépôt Git. Il contient des motifs qui indiquent à Git les fichiers ou les répertoires à ignorer. Ces modèles peuvent être personnalisés pour répondre aux besoins de votre projet et vous aider à maintenir un référentiel bien organisé.

Nouveau pour Git et GitHub ? Ce tutoriel sur GitHub et Git permet aux débutants de se familiariser avec le contrôle de version.

Voici quelques catégories courantes de fichiers et de répertoires que vous devriez envisager d'ignorer :

Créez des artefacts: Fichiers générés pendant le processus de construction qui peuvent être recréés à partir du code source, tels que :

dist/build/ (sorties de builds frontend et backend)
target/ (Java et autres langages compilés)

Dépendances: Les systèmes de gestion des paquets créent des répertoires pour les bibliothèques installées, qui ne doivent pas faire l'objet d'un cursus :

node_modules/ (Node.js)
vendor/ (PHP, Composer)
.venv/, venv/ (environnements virtuels Python)

Fichiers spécifiques au système: Ces fichiers sont générés automatiquement par le système d'exploitation et ne contribuent pas au projet :

.DS_Store (macOS)
Thumbs.db (Windows)

Fichiers de configuration de l'IDE: Chaque développeur peut utiliser un environnement de développement différent, de sorte que ses paramètres personnels ne doivent pas être inclus dans le contrôle de version :

.vscode/ (Code VS)
.idea/ (IDE JetBrains)
.project.settings/ (Eclipse)

Journaux et fichiers temporaires: Les journaux, les caches et les fichiers temporaires doivent être ignorés pour éviter tout encombrement inutile :

*.log, npm-debug.log*, yarn-debug.log*, yarn-error.log* (Logs de divers outils)
*.tmp*.bak (fichiers temporaires et de sauvegarde)
.mypy_cache/, __pycache__/ (caches Python)
.ipynb_checkpoints/ (points de contrôle Jupyter Notebook)

Environnement et dossiers secrets: Les informations d'identification sensibles et les configurations spécifiques à l'environnement ne doivent jamais être engagées :

.env, .env.local, .env.development, .env.production
secrets.jsonconfig.json (fichiers de configuration sensibles)

Fichiers de base de données et de stockage: Ils sont générés localement et ne doivent pas être inclus dans le contrôle de version :

*.sqlite, *.sqlite3, *.db (fichiers de base de données SQLite)
dump.rdb (vidage de la base de données Redis)

CI/CD et fichiers de couverture: Les rapports de couverture des tests et autres artefacts CI/CD doivent être ignorés :

coverage/*.lcov (rapports sur la couverture du code)
.tox/, .pytest_cache/ (fichiers de test Python)

Besoin d'installer Git ? Suivez notre guide pas à pase dans ce tutoriel d'installation de Git pour vous installer rapidement.

Apprenez les bases de Git dès aujourd'hui

Pour les débutants : Maîtriser le contrôle des versions à l'aide de Git.

Commencez à apprendre gratuitement

Syntaxe de .gitignore

Comme indiqué, les fichiers .gitignore contiennent des motifs qui sont comparés aux noms de fichiers de votre référentiel afin de déterminer s'ils doivent être ignorés ou non.

Syntaxe de base

Le fichier .gitignore se compose essentiellement de lignes, chacune représentant un motif à ignorer. Les motifs peuvent correspondre :

Dossiers spécifiques
Types de fichiers
Annuaires

Le fichier prend également en charge les commentaires, qui peuvent être ajoutés en commençant une ligne par #, ainsi que les lignes vides pour améliorer la lisibilité.

Voici un aperçu de la structure de base :

Ignorer un fichier spécifique : Vous pouvez énumérer directement le nom du fichier pour l'ignorer.

secrets.txt

Ignorer un répertoire entier : En ajoutant un / à la fin du nom du répertoire, vous pouvez ignorer tout ce qui se trouve à l'intérieur de ce répertoire.

logs/

Ignorer tous les fichiers d'un type spécifique : Les caractères génériques (*) peuvent être utilisés pour ignorer tous les fichiers ayant une extension spécifique.

*.py

Négation: Vous pouvez utiliser ! pour annuler un motif et suivre explicitement certains fichiers ou répertoires qui seraient autrement ignorés.

*.txt  # Ignores all .txt files
!readme.txt  # Except for readme.txt

Comment créer et utiliser un fichier .gitignore ?

La création et l'utilisation de .gitignore sont assez simples. Dans cette section, je vais vous présenter les différentes étapes.

Création d'un fichier .gitignore

Étape 1 : Naviguez jusqu'à la racine de votre dépôt. Le fichier .gitignore est généralement placé dans le répertoire racine d'un projet Git. Ouvrez votre terminal ou votre ligne de commande et naviguez jusqu'au répertoire racine de votre dépôt Git :

cd /path/to/your/repo

Étape 2 : Créez le fichier .gitignore. Une fois dans le répertoire racine, créez le fichier .gitignore en utilisant n'importe quel éditeur de texte ou en lançant une commande dans le terminal, telle que :

touch .gitignore

Étape 3 : Ajoutez des motifs au fichier. Ouvrez le fichier .gitignore dans un éditeur de texte et ajoutez les motifs nécessaires pour ignorer des fichiers ou des répertoires. Chaque ligne représente un modèle différent.

Voici un exemple de fichier .gitignore couramment utilisé dans un projet de base :

# Ignore node_modules and dependency directories
node_modules/
vendor/

# Ignore build artifacts
dist/
build/
*.log

# Ignore system-generated files
.DS_Store
Thumbs.db

# Ignore environment and secret files
.env
config.json

Une fois que vous avez ajouté les motifs nécessaires, enregistrez le fichier. Git ignorera désormais automatiquement ces fichiers lors de la mise à disposition ou de la validation des modifications.

Étape 4 : Livrez le fichier au référentiel. Il est important d'enregistrer le fichier .gitignore dans le référentiel afin que tous les collaborateurs utilisent les mêmes règles d'ignorance. Cela permet d'assurer la cohérence du projet pour toutes les personnes concernées.

git add .gitignore
git commit -m "Add .gitignore file"
git push

Une fois le fichier .gitignore validé, vous établissez des règles d'ignorance partagées par l'ensemble de l'équipe.

Vous souhaitez maîtriser les fonctions "push" et "pull" de Git ? Apprenez à synchroniser votre travail avec des dépôts distantse dans ce tutoriel Git push et pull.

Meilleures pratiques pour l'utilisation de .gitignore

Bien que la création d'un fichier .gitignore fasse partie intégrante du maintien d'un dépôt Git propre, plusieurs bonnes pratiques doivent être suivies pour s'assurer que le fichier est géré efficacement au fil du temps.

Utiliser un .gitignore global

Pour les développeurs travaillant sur plusieurs projets, il existe des fichiers spécifiques que vous pouvez vouloir exclure de chaque dépôt, quel que soit le type de projet.

Au lieu de les ajouter au fichier .gitignore de chaque projet, vous pouvez configurer un fichier global .gitignore qui s'applique à tous les dépôts de votre système.

Pour configurer un fichier global .gitignore:

Créez un fichier .gitignore_global:

touch ~/.gitignore_global

Ajoutez des motifs pour les fichiers que vous souhaitez ignorer globalement, par exemple :

.DS_Store
*.log
/.vscode/
/.idea/

Configurez Git pour qu'il utilise la version globale de .gitignore:

git config --global core.excludesfile ~/.gitignore_global

Exploiter les modèles existants

Au lieu de créer un fichier .gitignore à partir de zéro pour chaque nouveau projet, vous pouvez utiliser des modèles .gitignore préconfigurés pour des langages, des cadres ou des environnements spécifiques.

L'une des meilleures ressources pour ces modèlesest le dépôt officiel .gitignore de GitHub, où vous pouvez trouver des fichiers .gitignore adaptés à des centaines de langages de programmation et de frameworks.

Révisez régulièrement le fichier .gitignore

Au fur et à mesure de l'évolution des projets, de nouveaux fichiers et répertoires peuvent devoir être inclus dans le fichier .gitignore. Il est important de revoir et de mettre à jour périodiquement votre dossier pour refléter l'état actuel de vos projets.

Voici quelques scénarios dans lesquels vous pourriez avoir besoin de mettre à jour le fichier .gitignore:

L'adoption de nouveaux outils ou de nouvelles bibliothèques qui génèrent des fichiers supplémentaires (par exemple, le passage à un nouveau système de construction).
Refonte ou réorganisation de répertoires, ce qui peut entraîner l'apparition de nouveaux fichiers à exclure.
Suppression des fichiers ou répertoires obsolètes qui ne font plus partie du projet.

Dépannage de .gitignore

Même après avoir mis en place un fichier .gitignore, vous pouvez rencontrer des scénarios dans lesquels des fichiers spécifiques sont en cours de cursus, ou des modèles qui ne semblent pas fonctionner comme prévu. Cette section aborde deux domaines de dépannage courants et la manière de les résoudre.

Cursus des fichiers déjà engagés

Le fichier .gitignore ne s'applique pas rétroactivement aux fichiers déjà engagés.

Si vous ajoutez un motif à .gitignore alors que certains fichiers ont déjà été livrés, Git continuera à les suivre même s'ils correspondent au motif du fichier .gitignore.

Pour arrêter le cursus des fichiers qui ont déjà été validés, procédez comme suit :

Supprimez les fichiers du cursus de Git : Utilisez la commande git rm pour les supprimer du référentiel tout en les conservant dans votre répertoire de travail.

git rm --cached <file_or_directory_name>

Validez les modifications : Après avoir supprimé les fichiers du cursus de Git, validez les modifications pour vous assurer que les fichiers ne font plus partie de l'historique de contrôle de version.

git commit -m "Stop tracking ignored files"

Transférez les modifications vers le référentiel distant: Enfin, transférez les modifications vers le référentiel distant pour vous assurer que les fichiers ne font plus l'objet d'un suivi.

git push

Après avoir effectué ces étapes, Git cessera de suivre les fichiers. Le fichier livré sera toujours dans votre répertoire de travail mais sera ignoré par les livraisons futures basées sur vos modèles .gitignore.

S'assurer que les modèles fonctionnent

Parfois, vous pouvez remarquer que des fichiers spécifiques que vous vous attendiez à voir ignorés apparaissent toujours dans l'état de Git ou font l'objet d'un cursus.

Suivez les étapes suivantes pour vous assurer que vos motifs .gitignore fonctionnent correctement :

Vérifiez l'état de vos dossiers : Utilisez la commande git status pour voir quels fichiers sont suivis par Git. Cela vous permettra de vérifier si vos fichiers ignorés sont toujours répertoriés.

git status

Assurez-vous que le modèle est correct : Vérifiez la syntaxe de vos modèles .gitignore pour vous assurer qu'ils sont correctement formatés. Par exemple :

Assurez-vous d'utiliser le bon chemin de répertoire (relatif à la racine du référentiel).
Ajoutez une adresse / pour cibler des répertoires spécifiques afin d'éviter de suivre tous les fichiers portant des noms similaires.

Actualisez le cache : Si vous avez récemment mis à jour votre fichier .gitignore et que les changements ne sont pas appliqués, il se peut que Git conserve son ancien cache. Pour actualiser le cache, exécutez la commande suivante :

git rm -r --cached .
git add .
git commit -m "Refresh .gitignore"

Vérifiez qu'il n'y a pas d'exceptions : Parfois, un motif spécifique dans .gitignore peut être remplacé par un motif plus spécifique ailleurs dans le fichier. Examinez vos règles pour vous assurer qu'il n'y a pas de modèles contradictoires.

Vous cherchez une référence rapide sur Git ? Gardez les commandes essentielles à portée de maingrâce à cet aide-mémoire Git.

Conclusion

Un fichier .gitignore peut sembler petit, mais il joue un rôle important dans la propreté et la gestion de votre dépôt Git. En ignorant les fichiers inutiles (dépendances, artefacts de construction et fichiers générés par le système), vous vous assurez que votre projet reste organisé et libre de tout encombrement.

Dans ce tutoriel, vous avez appris à créer un fichier .gitignore, à ajouter des motifs et à appliquer les meilleures pratiques pour maintenir l'efficacité de votre répertoire. Grâce à ces compétences, vous éviterez les maux de tête liés au contrôle des versions et rendrez la collaboration plus fluide pour tous les membres de votre équipe.

Si vous souhaitez approfondir vos compétences en matière de Git, consultez les principes fondamentaux de Git pour un parcours d'apprentissage structuré. Vous pouvez également suivre des cours pratiques tels que Foundations of Git et Introduction to GitHub Concepts pour acquérir une solide compréhension du contrôle des versions et des flux de travail collaboratifs !