Aller au contenu

.gitignore : Ignorer les Fichiers Inutiles

Pourquoi utiliser un fichier .gitignore ?

Lorsque vous travaillez sur un projet, votre ordinateur crée souvent des fichiers dont Git n'a pas besoin. Imaginez des notes que vous prenez pendant que vous codez, des fichiers temporaires que votre logiciel crée automatiquement, ou encore des informations sensibles comme des mots de passe. Ces fichiers ne sont pas indispensables pour que votre projet fonctionne, et il est même préférable de ne pas les partager avec d'autres développeurs.

C'est là qu'intervient le fichier .gitignore. Il permet de dire à Git : "Ces fichiers-là, tu n'as pas besoin de les surveiller, ils ne font pas partie de l'histoire de notre projet."

Quels types de fichiers ignorer ?

Voici quelques exemples de fichiers que vous devriez ignorer avec .gitignore :

  • Fichiers de configuration de votre ordinateur : Ce sont des fichiers spécifiques à votre machine, comme les paramètres de votre éditeur de code. Ils ne sont pas utiles pour les autres développeurs et peuvent même contenir des informations personnelles.

  • Fichiers de compilation : Lorsque vous transformez votre code en un programme exécutable, des fichiers intermédiaires sont créés. Ces fichiers sont générés automatiquement et peuvent être recréés à tout moment, il n'est donc pas nécessaire de les garder dans Git.

  • Fichiers temporaires : Certains logiciels créent des fichiers temporaires pour fonctionner. Ces fichiers sont souvent supprimés une fois que vous avez terminé de travailler et ne sont pas pertinents pour l'historique de votre projet.

  • Fichiers sensibles : Il est crucial de ne jamais inclure de mots de passe, de clés d'API ou d'autres informations confidentielles dans votre dépôt Git. Le fichier .gitignore vous permet de les exclure pour des raisons de sécurité.

    Sécurité

    Si vous avez accidentellement ajouté des informations sensibles à votre dépôt, vous devez les supprimer et les remplacer immédiatement. Vous pouvez également révoquer les clés d'API ou les mots de passe compromis.

Des modèles de fichiers .gitignore prédéfinis

Vous pouvez trouver des modèles de fichiers .gitignore prédéfinis pour différents types de projets sur le site GitHub Gitignore

Comment fonctionne le fichier .gitignore ?

Le fichier .gitignore est un fichier texte que vous placez à la racine de votre projet. À l'intérieur, vous écrivez des règles pour indiquer à Git les fichiers et dossiers à ignorer. Ces règles peuvent être très simples, comme le nom d'un fichier, ou plus complexes, comme des motifs qui correspondent à plusieurs fichiers ou dossiers.

Mise en pratique : Ignorer les fichiers temporaires

1. Création de fichiers temporaires

  1. Nous allons maintenant créer des fichiers temporaires dans un répertoire build pour comprendre comment les ignorer avec .gitignore.

    mkdir build
    touch build/temp.txt
    
    Quelle est la structure de votre projet à cet instant ?
    mon-premier-projet/
    ├── build
    │   └── temp.txt
    ├── .git
    │   ├── ...
    │   ├── ...
    │   ...
    
    ├── README.md
    └── src
        └── MainActivity.java
    
  2. Verifiez l'état de votre dépôt :

    git status
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    On branch main
    Your branch is ahead of 'origin/main' by 1 commit.
    (use "git push" to publish your local commits)
    
    Untracked files:
    (use "git add <file>..." to include in what will be committed)
            build/
    
    nothing added to commit but untracked files present (use "git add" to track)
    

    Vous devriez voir que les fichiers sous le répertoire build/ sont listés comme des fichiers non suivis par Git.

2. Utilisation de .gitignore

  1. Créez un fichier .gitignore à la racine de votre projet:

    touch .gitignore
    
    Quelle est la structure de votre projet à cet instant ?
    mon-premier-projet/
    ├── build
    │   └── temp.txt
    ├── .git
    │   ├── ...
    │   ├── ...
    │   ...
    
    ├── .gitignore
    ├── README.md
    └── src
        └── MainActivity.java
    
  2. On peut ingorer soit un fichier spécifique, soit un répertoire entier. Ajoutez le répertoire build/ au fichier .gitignore :

    echo "build/" >> .gitignore
    

    Syntaxe du fichier .gitignore

    • Les lignes commençant par # sont des commentaires.
    • Les lignes vides sont ignorées.
    • Les modèles de fichiers ou de répertoires à ignorer sont spécifiés sur des lignes séparées.
    • Les modèles peuvent contenir des caractères génériques comme * (n'importe quel caractère), ? (un seul caractère) ou [] (un ensemble de caractères).
  3. Vérifiez à nouveau l'état de votre dépôt :

    git status
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    On branch main
    Your branch is ahead of 'origin/main' by 1 commit.
    (use "git push" to publish your local commits)
    
    Untracked files:
    (use "git add <file>..." to include in what will be committed)
            .gitignore
    
    nothing added to commit but untracked files present (use "git add" to track)
    

    Notez que le répertoire build/ n'est plus listé comme un repertoire non suivi. Seul le fichier .gitignore est listé.

  4. Ajoutez le fichier .gitignore à votre dépôt :

    1
    2
    3
    # On est toujours sur la branche main après la fusion de la branche dev
    git add .gitignore
    git commit -m "Ajout du fichier .gitignore"
    
    1
    2
    3
    [main f532283] Ajout du fichier .gitignore
     1 file changed, 1 insertion(+)
     create mode 100644 .gitignore
    
  5. Poussez les modifications sur GitHub :

    git push
    
    1
    2
    3
    4
    5
    6
    7
    8
    Enumerating objects: 4, done.
    Counting objects: 100% (4/4), done.
    Delta compression using up to 4 threads
    Compressing objects: 100% (2/2), done.
    Writing objects: 100% (3/3), 987 bytes | 987.00 KiB/s, done.
    Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
    To github.com:khammami/mon-premier-projet.git
        7adc5d1..f532283  main -> main
    

Est-ce que les fichiers déjà suivis sont ignorés ?

Les fichiers déjà suivis par Git ne sont pas ignorés par le fichier .gitignore. Si vous souhaitez ignorer un fichier déjà suivi, vous devez le supprimer du dépôt avec git rm --cached.

Est-ce que peut-on avoir plusieurs fichiers .gitignore ?

Oui, il est tout à fait possible d'avoir plusieurs fichiers .gitignore dans un même dépôt Git.

  • Combinaison des règles : Git combine les règles spécifiées dans tous les fichiers .gitignore pour déterminer quels fichiers ou répertoires doivent être ignorés. Les règles définies dans un fichier .gitignore situé dans un répertoire spécifique s'appliquent à ce répertoire et à ses sous-répertoires.

  • Règles spécifiques aux répertoires : En plaçant des fichiers .gitignore à différents niveaux de votre dépôt, vous pouvez définir des règles d'exclusion spécifiques à certains répertoires. Cela vous permet d'avoir un contrôle plus fin sur les fichiers à ignorer.

Example

Imaginez un projet avec la structure suivante :

1
2
3
4
5
6
mon-projet/
├── .gitignore         # Règles générales pour le projet
├── src/
│   └── .gitignore     # Règles spécifiques au répertoire src/
└── build/
    └── .gitignore     # Règles spécifiques au répertoire build/

Dans cet exemple, le fichier .gitignore situé à la racine du projet contiendra des règles générales, tandis que les fichiers .gitignore dans les répertoires src/ et build/ contiendront des règles spécifiques à ces répertoires.