Le fichier .gitignore : le guide complet

Vous utilisez Git mais votre dépôt se remplit de fichiers temporaires, de dossiers inutiles ou même d’informations sensibles ? Le fichier .gitignore est justement là pour éviter ce genre de problème. Simple à mettre en place, il permet de garder un projet propre, léger et facile à gérer au quotidien.

Dans ce guide complet, vous allez découvrir ce qu’est un fichier .gitignore, comment il fonctionne, quelles règles utiliser et quelles erreurs éviter. Que vous débutiez avec Git ou que vous souhaitiez améliorer vos bonnes pratiques, vous apprendrez à configurer efficacement votre gitignore grâce à des exemples concrets et faciles à reproduire.

• Évitez les erreurs qui encombrent un dépôt Git et adoptez dès le départ de bonnes pratiques utilisées dans les projets professionnels.
• Protégez vos fichiers sensibles et comprenez pourquoi certains éléments ne devraient jamais être partagés sur GitHub.
• Gagnez du temps au quotidien grâce à des règles simples qui rendent vos projets plus propres, plus légers et plus faciles à maintenir.

Lorsque l’on débute avec Git, il arrive souvent de commettre une erreur très classique : envoyer dans son dépôt des fichiers qui n’ont absolument rien à y faire. Fichiers temporaires, mots de passe, sauvegardes automatiques, dépendances téléchargées automatiquement… tout cela peut rapidement transformer un projet propre en véritable bazar numérique.

• Git propose une solution simple et efficace : le fichier .gitignore.

Un fichier .gitignore est indispensable dans presque tous les projets.

Qu’est-ce que le fichier .gitignore ?

Le fichier .gitignore est un simple fichier texte utilisé par Git.

Son rôle consiste à indiquer à Git quels fichiers ou dossiers doivent être ignorés et ne pas être suivis dans le dépôt.

En d’autres termes, lorsqu’un fichier correspond à une règle définie dans .gitignore, Git fait comme s’il n’existait pas.

Prenons un exemple très simple : Vous développez un site web en PHP. Votre éditeur de code génère automatiquement des fichiers de configuration propres à votre ordinateur.

Ces fichiers ne sont utiles qu’à vous. Ils ne doivent pas être partagés avec vos collègues ou publiés sur GitHub.

Grâce à .gitignore, vous pouvez demander à Git de les ignorer complètement.

Sans ce mécanisme, votre dépôt risque rapidement de contenir :

• des fichiers inutiles
• des sauvegardes temporaires
• des mots de passe
• des journaux d’erreurs
• des milliers de fichiers générés automatiquement.

Autant dire que le ménage deviendrait vite compliqué.

Pourquoi utiliser un fichier .gitignore ?

À première vue, ignorer certains fichiers peut sembler anodin.

Pourtant, dans la pratique, le fichier .gitignore est l’un des éléments les plus importants d’un projet Git.

• Garder un dépôt propre

Imaginez un bureau sur lequel vous laissez tout traîner. Au bout de quelques semaines, retrouver un document devient un véritable cauchemar.

Un dépôt Git fonctionne exactement de la même manière.

En ignorant les fichiers inutiles, vous conservez uniquement les éléments importants du projet.

Les commits deviennent plus lisibles et les collaborateurs comprennent plus facilement ce qui change réellement.

• Éviter les fichiers sensibles

Certains fichiers contiennent des informations confidentielles :

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=motdepasse_secret

Si ce fichier est envoyé sur GitHub par erreur, n’importe qui pourrait potentiellement récupérer ces informations.

Le fichier .gitignore permet d’éviter ce type d’accident.

👉 Pensez toujours à vérifier vos projets ou dépôt GitHub avec TruffleHog pour détecter les infos sensibles.

• Réduire la taille du dépôt

Certaines technologies téléchargent automatiquement des milliers de fichiers.

Par exemple :

node_modules/
vendor/

Ces dossiers peuvent représenter plusieurs centaines de mégaoctets.

Les stocker dans Git est généralement inutile puisque leur contenu peut être régénéré automatiquement.

• Éviter les conflits inutiles

Les fichiers temporaires changent souvent d’un ordinateur à l’autre.

Si plusieurs développeurs les partagent dans Git, cela génère rapidement des conflits inutiles.

Le .gitignore évite ce problème.

👉 Tout savoir sur la résolution de conflits Git.

Où créer le fichier .gitignore ?

Le plus souvent, le fichier est placé à la racine du projet.

Exemple :

MonProjet/
│
├── .gitignore
├── index.php
├── css/
├── js/
└── images/

Git analysera automatiquement ce fichier et appliquera les règles définies à l’ensemble du dépôt.

Comment créer un fichier .gitignore ?

La création est extrêmement simple.

Sous Linux ou macOS, depuis le terminal :

touch .gitignore

Sous Windows :

echo. > .gitignore

Vous pouvez également créer le fichier directement depuis votre éditeur de code.

Une fois créé, il suffit d’ajouter les règles souhaitées.

Ignorer un fichier précis

Supposons que vous souhaitiez ignorer un fichier nommé :

config.php

Votre fichier .gitignore contiendra simplement :

config.php

Git ignorera alors ce fichier.

Ignorer plusieurs fichiers

Vous pouvez ajouter plusieurs lignes.

config.php
secret.txt
database.sql

Chaque ligne représente une règle indépendante.

Ignorer un dossier complet

C’est probablement l’utilisation la plus fréquente.

Exemple :

node_modules/

Git ignorera :

node_modules/
├── package1
├── package2
└── package3

Peu importe le nombre de fichiers présents à l’intérieur.

Même principe avec Composer :

vendor/

Utiliser les caractères génériques

Le fichier .gitignore accepte des caractères spéciaux appelés « wildcards ».

Ils permettent de créer des règles plus puissantes.

L’astérisque *

L’astérisque signifie :

N’importe quelle suite de caractères.

Exemple :

*.log

Git ignorera :

erreur.log
serveur.log
application.log

Mais pas :

erreur.txt

Le point d’interrogation ?

Le caractère ? remplace un seul caractère.

test?.txt

Correspond à :

test1.txt
test2.txt
testA.txt

Mais pas :

test12.txt

Les crochets []

Ils permettent de définir une plage.

test[1-5].txt

Correspond à :

test1.txt
test2.txt
test3.txt
test4.txt
test5.txt

Ignorer tous les fichiers d’une extension

C’est une pratique très courante.

Par exemple :

*.tmp

ou :

*.bak

ou encore :

*.log

Tous les fichiers possédant cette extension seront ignorés.

Ignorer les fichiers cachés

Sous Linux et macOS, les fichiers commençant par un point sont souvent cachés.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Exemple :

.DS_Store

Ce fichier est généré automatiquement par macOS.

Il est totalement inutile dans un dépôt Git.

Même chose pour :

Thumbs.db

sous Windows.

Exclure puis réautoriser un fichier

C’est une fonctionnalité que beaucoup de débutants ignorent.

Vous pouvez ignorer tous les fichiers puis en autoriser certains.

Exemple :

*.txt
!important.txt

Tous les fichiers .txt seront ignorés sauf :

important.txt

Le point d’exclamation sert à annuler une règle précédente.

Comment vérifier qu’une règle fonctionne ?

Git propose une commande très pratique :

git status

Elle affiche les fichiers actuellement suivis.

Si votre règle fonctionne correctement, le fichier ignoré n’apparaîtra pas dans la liste.

Vous pouvez également utiliser :

git check-ignore -v fichier.txt

Exemple :

git check-ignore -v secret.txt

Git indiquera précisément quelle règle provoque l’exclusion.

Attention aux fichiers déjà suivis

C’est probablement l’erreur la plus fréquente.

Imaginons que vous ayez déjà ajouté un fichier :

git add config.php
git commit -m "Ajout config"

Puis vous ajoutez :

config.php

Beaucoup de débutants pensent que Git va automatiquement arrêter de suivre ce fichier.

• Ce n’est pas le cas.

Git continue de le suivre car il est déjà enregistré dans l’historique.

Il faut le retirer manuellement de l’index :

git rm --cached config.php

Puis effectuer un nouveau commit :

git commit -m "Suppression du suivi de config.php"

À partir de ce moment-là, le .gitignore prendra effet.

Les fichiers souvent ignorés dans un projet web

Voici un exemple réaliste.

# Logs
*.log

# Fichiers temporaires
*.tmp
*.bak

# macOS
.DS_Store

# Windows
Thumbs.db

# Node.js
node_modules/

# Composer
vendor/

# Variables sensibles
.env

# IDE
.vscode/
.idea/

Ce type de configuration est utilisé dans de nombreux projets professionnels.

Exemple complet pour un projet PHP

Imaginons que vous développiez un site web.

Votre structure ressemble à ceci :

MonSite/
│
├── .env
├── vendor/
├── logs/
├── index.php
├── composer.json
└── composer.lock

Votre fichier .gitignore pourrait contenir :

# Variables sensibles
.env

# Dépendances
vendor/

# Journaux
logs/

# Fichiers temporaires
*.log

# Sauvegardes
*.bak

Résultat :

Git conservera uniquement les fichiers réellement nécessaires au projet.

Exemple pour un projet JavaScript

Dans l’univers JavaScript, un .gitignore typique ressemble souvent à ceci :

node_modules/

dist/

.env

coverage/

*.log

Cela évite d’envoyer plusieurs milliers de fichiers inutiles sur GitHub.

Générer automatiquement un fichier .gitignore

Vous n’êtes pas obligé d’écrire toutes les règles à la main. Le site officiel : gitignore.io permet de générer automatiquement un fichier adapté à votre environnement.

Par exemple :

• PHP
• Laravel
• WordPress
• Node.js
• Visual Studio Code
• macOS
• Windows

Vous sélectionnez vos technologies et le site génère un fichier prêt à l’emploi.

C’est un excellent gain de temps.

Les erreurs les plus fréquentes

Oublier le fichier .env

C’est l’une des erreurs les plus dangereuses.

Le fichier .env contient souvent :

• les mots de passe
• les clés API
• les accès à la base de données.

Il devrait presque toujours être ignoré.

Envoyer node_modules

Cette erreur arrive très souvent aux débutants.

Le dossier peut contenir plusieurs dizaines de milliers de fichiers.

Le dépôt devient énorme et lent.

Ajouter le .gitignore trop tard

Plus vous attendez, plus il devient compliqué de nettoyer le dépôt.

Le mieux est de créer le .gitignore dès le début du projet.

Ignorer trop de choses

À l’inverse, certains développeurs deviennent trop enthousiastes.

Ils ignorent des fichiers pourtant indispensables.

Le projet devient alors impossible à reconstruire sur un autre ordinateur.

L’objectif est de trouver le bon équilibre.

Mini projet : préparer un dépôt Git propre

Prenons un cas concret.

Vous créez un projet PHP pour votre futur plugin WordPress.

Structure :

MonPlugin/
│
├── .env
├── vendor/
├── logs/
├── plugin.php
├── readme.txt
└── composer.json

Étape 1 : créer le fichier .gitignore

touch .gitignore

Étape 2 : ajouter les règles

.env

vendor/

logs/

*.log

.DS_Store

Étape 3 : vérifier le résultat

git status

Vous devriez voir uniquement :

plugin.php
readme.txt
composer.json
.gitignore

Les éléments sensibles ou inutiles ne seront plus suivis.

Vous disposez désormais d’un dépôt propre, léger et prêt à être partagé sur GitHub.

Bonnes pratiques à retenir

Avec l’expérience, vous constaterez que le fichier .gitignore est presque aussi important que le code lui-même. Il protège vos données sensibles, évite l’accumulation de fichiers inutiles et facilite la collaboration avec d’autres développeurs.

Une bonne habitude consiste à créer votre .gitignore dès les premières minutes d’un nouveau projet. Cela évite de devoir nettoyer le dépôt plusieurs semaines plus tard. Pensez également à adapter les règles à la technologie utilisée : un projet PHP n’aura pas exactement les mêmes besoins qu’une application Node.js ou qu’un site WordPress.

Enfin, prenez le temps de relire régulièrement votre fichier d’exclusion. Les besoins évoluent au fil du développement et certaines règles peuvent devenir obsolètes.

---

---

Le fichier .gitignore est l’un de ces outils discrets que l’on découvre souvent par hasard, mais dont on ne peut plus se passer ensuite. Derrière sa simplicité se cache un véritable gardien de votre dépôt Git. Il vous aide à conserver un projet propre, à protéger des informations sensibles et à éviter de nombreuses erreurs qui peuvent devenir très coûteuses lorsque l’on travaille en équipe ou sur des projets publics.

Si vous débutez avec Git, ne considérez pas le .gitignore comme une option. Prenez l’habitude de le créer systématiquement, d’expérimenter différentes règles et de comprendre précisément ce que Git suit ou ignore. Plus vous pratiquerez, plus ces mécanismes deviendront naturels.

Et ce n’est qu’un début. Une fois le fonctionnement du .gitignore maîtrisé, vous pourrez approfondir d’autres notions essentielles de Git comme les branches, les fusions, les tags ou encore les workflows collaboratifs. Autant de compétences qui transformeront progressivement votre manière de développer et de gérer vos projets web.