Git
Ignorer les fichiers et les dossiers

Introduction

Ignorer les fichiers et les répertoires avec un fichier .gitignore

Vous pouvez faire en sorte que Git ignore certains fichiers et répertoires - c'est-à-dire les exclure du suivi par Git - en créant un ou plusieurs fichiers .gitignore dans votre référentiel.

Dans les projets logiciels, .gitignore contient généralement une liste des fichiers et / ou des répertoires générés au cours du processus de génération ou à l'exécution. Les entrées du fichier .gitignore peuvent inclure des noms ou des chemins pointant vers:

1. ressources temporaires, par exemple caches, fichiers journaux, code compilé, etc.
2. fichiers de configuration locaux à ne pas partager avec d'autres développeurs
3. les fichiers contenant des informations secrètes, telles que les mots de passe de connexion, les clés et les informations d'identification

Lorsqu'elles sont créées dans le répertoire de niveau supérieur, les règles s'appliquent de manière récursive à tous les fichiers et sous-répertoires de l'ensemble du référentiel. Lorsqu'elles sont créées dans un sous-répertoire, les règles s'appliquent à ce répertoire spécifique et à ses sous-répertoires.

Lorsqu'un fichier ou un répertoire est ignoré, il ne sera pas:

1. suivi par Git
2. signalé par des commandes telles que git status ou git diff
3. mis en scène avec des commandes telles que git add -A

Dans le cas inhabituel où vous devez ignorer les fichiers suivis, vous devez faire particulièrement attention. Voir: Ignorer les fichiers qui ont déjà été validés dans un référentiel Git .

Exemples

Voici quelques exemples génériques de règles dans un fichier .gitignore , basées sur des modèles de fichiers glob :

# Lines starting with `#` are comments.

# Ignore files called 'file.ext'
file.ext

# Comments can't be on the same line as rules!
# The following line ignores files called 'file.ext # not a comment'
file.ext # not a comment 

# Ignoring files with full path.
# This matches files in the root directory and subdirectories too.
# i.e. otherfile.ext will be ignored anywhere on the tree.
dir/otherdir/file.ext
otherfile.ext

# Ignoring directories
# Both the directory itself and its contents will be ignored.
bin/
gen/

# Glob pattern can also be used here to ignore paths with certain characters.
# For example, the below rule will match both build/ and Build/
[bB]uild/

# Without the trailing slash, the rule will match a file and/or
# a directory, so the following would ignore both a file named `gen`
# and a directory named `gen`, as well as any contents of that directory
bin
gen

# Ignoring files by extension
# All files with these extensions will be ignored in
# this directory and all its sub-directories.
*.apk
*.class

# It's possible to combine both forms to ignore files with certain
# extensions in certain directories. The following rules would be
# redundant with generic rules defined above.
java/*.apk
gen/*.class

# To ignore files only at the top level directory, but not in its
# subdirectories, prefix the rule with a `/`
/*.apk
/*.class

# To ignore any directories named DirectoryA 
# in any depth use ** before DirectoryA
# Do not forget the last /, 
# Otherwise it will ignore all files named DirectoryA, rather than directories
**/DirectoryA/
# This would ignore 
# DirectoryA/
# DirectoryB/DirectoryA/ 
# DirectoryC/DirectoryB/DirectoryA/
# It would not ignore a file named DirectoryA, at any level

# To ignore any directory named DirectoryB within a 
# directory named DirectoryA with any number of 
# directories in between, use ** between the directories
DirectoryA/**/DirectoryB/
# This would ignore 
# DirectoryA/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryW/DirectoryB/

# To ignore a set of files, wildcards can be used, as can be seen above.
# A sole '*' will ignore everything in your folder, including your .gitignore file.
# To exclude specific files when using wildcards, negate them.
# So they are excluded from the ignore list:
!.gitignore 

# Use the backslash as escape character to ignore files with a hash (#)
# (supported since 1.6.2.1)
\#*#

La plupart des fichiers .gitignore sont standard dans différents langages. Pour commencer, voici un ensemble de fichiers .gitignore répertoriés par langue à partir desquels cloner ou copier / modifier dans votre projet. Sinon, pour un nouveau projet, vous pouvez envisager de générer automatiquement un fichier de démarrage à l'aide d'un outil en ligne .

Autres formes de .gitignore

.gitignore fichiers .gitignore sont destinés à être .gitignore dans le cadre du référentiel. Si vous souhaitez ignorer certains fichiers sans valider les règles d’ignorance, voici quelques options:

• Editez le .git/info/exclude (en utilisant la même syntaxe que .gitignore ). Les règles seront globales dans le périmètre du référentiel;
• Configurez un fichier gitignore global qui appliquera les règles ignore à tous vos référentiels locaux:

De plus, vous pouvez ignorer les modifications locales apportées aux fichiers suivis sans modifier la configuration globale de git avec:

• git update-index --skip-worktree [<file>...] : pour les modifications locales mineures
• git update-index --assume-unchanged [<file>...] : pour les fichiers prêts à changer en amont de la production

Voir plus de détails sur les différences entre les derniers indicateurs et la documentation de git update-index pour d'autres options.

Nettoyage des fichiers ignorés

Vous pouvez utiliser git clean -X pour git clean -X les fichiers ignorés:

git clean -Xn #display a list of ignored files
git clean -Xf #remove the previously displayed files

Remarque: -X (majuscules) nettoie uniquement les fichiers ignorés. Utilisez -x (no caps) pour supprimer également les fichiers non suivis.

Consultez la documentation de git clean pour plus de détails.

Voir le manuel de Git pour plus de détails.

Exceptions dans un fichier .gitignore

Si vous ignorez des fichiers en utilisant un modèle mais que vous avez des exceptions, préfixez un point d'exclamation (!) À l'exception. Par exemple:

*.txt
!important.txt

L'exemple ci-dessus indique à Git d'ignorer tous les fichiers portant l'extension .txt exception des fichiers nommés important.txt .

Si le fichier est dans un dossier ignoré, vous ne pouvez PAS le ré-inclure si facilement:

folder/
!folder/*.txt

Dans cet exemple, tous les fichiers .txt du dossier resteraient ignorés.

La bonne manière est de ré-inclure le dossier lui-même sur une ligne distincte, puis d'ignorer tous les fichiers du folder par * , enfin d'inclure à nouveau le fichier *.txt dans le folder , comme suit:

!folder/
folder/*
!folder/*.txt

Remarque : Pour les noms de fichiers commençant par un point d'exclamation, ajoutez deux points d'exclamation ou un échappement avec le caractère \ :

!!includethis
\!excludethis

Un fichier global .gitignore

Pour que Git ignore certains fichiers sur tous les référentiels, vous pouvez créer un fichier .gitignore global avec la commande suivante dans votre terminal ou votre invite de commande:

$ git config --global core.excludesfile <Path_To_Global_gitignore_file>

Git l'utilisera désormais en plus du fichier .gitignore de chaque dépôt. Les règles sont les suivantes:

• Si le fichier .gitignore local .gitignore explicitement un fichier alors que le fichier .gitignore ignore, le .gitignore local est prioritaire (le fichier sera inclus)
• Si le référentiel est cloné sur plusieurs machines, le .gigignore global doit être chargé sur toutes les machines ou au moins l'inclure, car les fichiers ignorés seront .gitignore alors que le PC avec le .gitignore global .gitignore mettra pas à jour. . Ceci est la raison pour laquelle un particulier repo .gitignore est une meilleure idée que un mondial si le projet est travaillé par une équipe

Ce fichier est un bon endroit pour garder des ignorés spécifiques aux plates-formes, aux machines ou aux utilisateurs, par exemple OSX .DS_Store , Windows Thumbs.db ou Vim *.ext~ et *.ext.swp ignore si vous ne souhaitez pas conserver ceux du référentiel . Ainsi, un membre de l'équipe travaillant sur OS X peut ajouter tous les .DS_STORE et _MACOSX (ce qui est en fait inutile), tandis qu'un autre membre de l'équipe sous Windows peut ignorer tous les thumbs.bd

Ignorer les fichiers qui ont déjà été validés dans un référentiel Git

Si vous avez déjà ajouté un fichier à votre référentiel Git et que vous souhaitez maintenant arrêter de le suivre (afin qu’il ne soit plus présent dans les futurs commits), vous pouvez le supprimer de l’index:

git rm --cached <file>

Cela supprimera le fichier du référentiel et empêchera Git de suivre d'autres modifications. L'option --cached s'assurera que le fichier n'est pas physiquement supprimé.

Notez que le contenu précédemment ajouté du fichier sera toujours visible via l'historique Git.

Gardez à l'esprit que si quelqu'un d'autre tire du référentiel après avoir supprimé le fichier de l'index, sa copie sera supprimée physiquement .

Vous pouvez faire en sorte que Git prétende que la version du répertoire de travail du fichier est à jour et lit la version de l'index (ignorant ainsi les modifications apportées) avec le bit " skip worktree ":

git update-index --skip-worktree <file>

L'écriture n'est pas affectée par ce bit, la sécurité du contenu reste la première priorité. Vous ne perdrez jamais vos précieux changements ignorés; par contre ce bit est en conflit avec le cache: pour supprimer ce bit, utilisez

git update-index --no-skip-worktree <file>

Il est parfois recommandé à tort de mentir à Git et de lui faire supposer que le fichier n'a pas été modifié sans l'examiner. À première vue, il ignore les modifications apportées au fichier sans le supprimer de son index:

git update-index --assume-unchanged <file>

Cela forcera git à ignorer les modifications apportées au fichier (gardez à l'esprit que si vous apportez des modifications à ce fichier ou si vous le rangez, vos modifications ignorées seront perdues )

Si vous voulez que git se soucie de ce fichier, lancez la commande suivante:

git update-index --no-assume-unchanged <file>

Vérifier si un fichier est ignoré

La commande git check-ignore rapporte les fichiers ignorés par Git.

Vous pouvez passer des noms de fichiers sur la ligne de commande et git check-ignore listera les noms de fichiers ignorés. Par exemple:

$ cat .gitignore
*.o
$ git check-ignore example.o Readme.md
example.o

Ici, seuls les fichiers * .o sont définis dans .gitignore, Readme.md n'est donc pas répertorié dans la sortie de git check-ignore .

Si vous voulez voir la ligne dont .gitignore est responsable d'ignorer un fichier, ajoutez -v à la commande git check-ignore:

$ git check-ignore -v example.o Readme.md
.gitignore:1:*.o        example.o

A partir de Git 1.7.6, vous pouvez également utiliser git status --ignored pour voir les fichiers ignorés. Vous pouvez trouver plus d'informations à ce sujet dans la documentation officielle ou dans Recherche de fichiers ignorés par .gitignore .

Ignorer les fichiers dans les sous-dossiers (fichiers gitignore multiples)

Supposons que vous ayez une structure de référentiel comme celle-ci:

examples/
    output.log
src/
    <files not shown>
    output.log
README.md

output.log dans le répertoire des exemples est valide et nécessaire pour que le projet prenne une compréhension tandis que celui sous src/ est créé lors du débogage et ne doit pas figurer dans l'historique ou une partie du référentiel.

Il existe deux manières d’ignorer ce fichier. Vous pouvez placer un chemin absolu dans le fichier .gitignore à la racine du répertoire de travail:

# /.gitignore
src/output.log

Vous pouvez également créer un fichier .gitignore dans le répertoire src/ et ignorer le fichier relatif à ce .gitignore :

# /src/.gitignore
output.log

Ignorer un fichier dans n'importe quel répertoire

Pour ignorer un fichier foo.txt dans n'importe quel répertoire, vous devez simplement écrire son nom:

foo.txt # matches all files 'foo.txt' in any directory

Si vous souhaitez ignorer le fichier uniquement dans une partie de l'arborescence, vous pouvez spécifier les sous-répertoires d'un répertoire spécifique avec ** pattern:

bar/**/foo.txt # matches all files 'foo.txt' in 'bar' and all subdirectories

Ou vous pouvez créer un fichier .gitignore dans le répertoire bar/ . Équivalent à l'exemple précédent serait créer un fichier bar/.gitignore avec ces contenus:

foo.txt # matches all files 'foo.txt' in any directory under bar/

Ignorer les fichiers localement sans valider les règles ignore

.gitignore ignore les fichiers localement, mais il est destiné à être .gitignore au référentiel et partagé avec d'autres contributeurs et utilisateurs. Vous pouvez définir un .gitignore global, mais tous vos référentiels partageraient ces paramètres.

Si vous souhaitez ignorer certains fichiers dans un référentiel localement et ne pas inclure le fichier dans un référentiel, éditez le .git/info/exclude dans votre référentiel.

Par exemple:

# these files are only ignored on this repo
# these rules are not shared with anyone
# as they are personal                                              
gtk_tests.py
gui/gtk/tests/*
localhost
pushReports.py
server/

Modèles .gitignore pré-remplis

Si vous ne savez pas quelles règles .gitignore dans votre fichier .gitignore ou si vous souhaitez simplement ajouter des exceptions généralement acceptées à votre projet, vous pouvez choisir ou générer un fichier .gitignore :

• https://www.toptal.com/developers/gitignore
• https://github.com/github/gitignore

De nombreux services d'hébergement, tels que GitHub et BitBucket, permettent de générer des fichiers .gitignore en fonction des langages de programmation et des IDE que vous utilisez:

Ignorer les modifications ultérieures apportées à un fichier (sans le supprimer)

Parfois, vous voulez avoir un fichier dans Git mais ignorez les modifications ultérieures.

Dites à Git d'ignorer les modifications apportées à un fichier ou à un répertoire en utilisant update-index :

git update-index --assume-unchanged my-file.txt

La commande ci-dessus indique à Git de supposer que my-file.txt n'a pas été modifié et de ne pas vérifier ou signaler les modifications. Le fichier est toujours présent dans le référentiel.

Cela peut être utile pour fournir des valeurs par défaut et autoriser des substitutions d’environnement local, par exemple:

# create a file with some values in
cat <<EOF
MYSQL_USER=app
MYSQL_PASSWORD=FIXME_SECRET_PASSWORD
EOF > .env

# commit to Git
git add .env
git commit -m "Adding .env template"

# ignore future changes to .env
git update-index --assume-unchanged .env

# update your password
vi .env

# no changes!
git status

Ignorer seulement une partie d'un fichier [stub]

Parfois, vous souhaiterez peut-être modifier localement un fichier que vous ne souhaitez ni valider ni publier. Dans l'idéal, les paramètres locaux devraient être concentrés dans un fichier distinct pouvant être placé dans .gitignore , mais parfois, dans le cadre d'une solution à court terme, il peut être utile d'avoir quelque chose de local dans un fichier .gitignore .

Vous pouvez faire Git "unsee" ces lignes en utilisant un filtre propre. Ils ne vont même pas apparaître dans les diffs.

Supposons ici un extrait du fichier file1.c :

struct settings s;
s.host = "localhost";
s.port = 5653;
s.auth = 1;
s.port = 15653; // NOCOMMIT
s.debug = 1; // NOCOMMIT
s.auth = 0; // NOCOMMIT

Vous ne voulez pas publier les lignes NOCOMMIT n'importe où.

Créez le filtre "nocommit" en ajoutant ce fichier au fichier de configuration Git tel que .git/config :

[filter "nocommit"]
    clean=grep -v NOCOMMIT

Ajoutez (ou créez) ceci à .git/info/attributes ou .gitmodules :

file1.c filter=nocommit

Et vos lignes NOCOMMIT sont cachées de Git.

Mises en garde:

• L'utilisation d'un filtre propre ralentit le traitement des fichiers, en particulier sous Windows.
• La ligne ignorée peut disparaître du fichier lorsque Git le met à jour. Il peut être contrecarré par un filtre à taches, mais c'est plus compliqué.
• Non testé sur Windows

Ignorer les modifications dans les fichiers suivis. [bout]

.gitignore et .git/info/exclude ne fonctionnent que pour les fichiers non suivis.

Pour définir l'indicateur ignore sur un fichier suivi, utilisez la commande update-index :

git update-index --skip-worktree myfile.c

Pour revenir en arrière, utilisez:

git update-index --no-skip-worktree myfile.c

Vous pouvez ajouter cet extrait à votre configuration git globale pour disposer de commandes git hide , git unhide et git hidden plus pratiques:

[alias]
    hide   = update-index --skip-worktree
    unhide = update-index --no-skip-worktree
    hidden  = "!git ls-files -v | grep ^[hsS] | cut -c 3-"

Vous pouvez également utiliser l'option --assume-unchanged avec la fonction update-index

git update-index --assume-unchanged <file>

Si vous voulez revoir ce fichier pour les modifications, utilisez

git update-index --no-assume-unchanged <file>

Lorsque l'option --assume-unchanged est spécifiée, l'utilisateur s'engage à ne pas modifier le fichier et permet à Git de supposer que le fichier de l'arborescence de travail correspond à ce qui est enregistré dans l'index. Git échoue s'il doit modifier ce fichier dans l'index par exemple lors de la fusion dans un commit; ainsi, si le fichier supposé non suivi est modifié en amont, vous devrez gérer la situation manuellement. Dans ce cas, l'accent est mis sur les performances.

Alors que l'option --skip-worktree est utile lorsque vous indiquez à git de ne pas toucher un fichier spécifique parce que le fichier doit être modifié localement et que vous ne souhaitez pas commettre accidentellement les modifications (fichier de configuration / propriétés configuré pour un fichier particulier) environnement). Skip-worktree est prioritaire par rapport à assumer-inchangé lorsque les deux sont définis.

Effacer les fichiers déjà validés, mais inclus dans .gitignore

Parfois, il arrive qu'un fichier soit suivi par git, mais à un moment ultérieur, il a été ajouté à .gitignore, afin de ne plus le suivre. C'est un scénario très courant d'oublier de nettoyer de tels fichiers avant son ajout à .gitignore. Dans ce cas, l'ancien fichier sera toujours dans le référentiel.

Pour résoudre ce problème, il est possible d'effectuer une suppression "sèche" de tout ce qui se trouve dans le référentiel, puis de rajouter tous les fichiers. Tant que vous n'avez pas de modifications en attente et que le paramètre --cached est passé, cette commande est assez sûre pour être exécutée:

# Remove everything from the index (the files will stay in the file system) 
$ git rm -r --cached .

# Re-add everything (they'll be added in the current state, changes included)
$ git add .

# Commit, if anything changed. You should see only deletions
$ git commit -m 'Remove all files that are in the .gitignore'

# Update the remote
$ git push origin master

Créer un dossier vide

Il n’est pas possible d’ajouter et de valider un dossier vide dans Git car Git gère les fichiers et leur associe leur répertoire, ce qui ralentit les validations et améliore la vitesse. Pour contourner cela, il existe deux méthodes:

.gitkeep méthode: .gitkeep

Pour contourner ce .gitkeep utilisez un fichier .gitkeep pour enregistrer le dossier de Git. Pour ce faire, créez simplement le répertoire requis et ajoutez un fichier .gitkeep au dossier. Ce fichier est vide et ne sert à rien d'autre que d'enregistrer le dossier. Pour ce faire, dans Windows (qui a des conventions de nommage de fichiers peu pratiques), ouvrez simplement git bash dans le répertoire et exécutez la commande:

$ touch .gitkeep

Cette commande crée simplement un fichier .gitkeep vierge dans le répertoire en cours

Méthode deux: dummy.txt

Un autre hack pour cela est très similaire à ce qui précède et les mêmes étapes peuvent être suivies, mais au lieu d'un .gitkeep , utilisez simplement un dummy.txt place. Cela a l'avantage supplémentaire de pouvoir le créer facilement dans Windows en utilisant le menu contextuel. Vous pouvez également y laisser des messages amusants. Vous pouvez également utiliser le fichier .gitkeep pour suivre le répertoire vide. .gitkeep est normalement un fichier vide qui est ajouté pour suivre le directoy vide.

Recherche de fichiers ignorés par .gitignore

Vous pouvez lister tous les fichiers ignorés par git dans le répertoire courant avec la commande:

git status --ignored

Donc, si nous avons une structure de référentiel comme celle-ci:

.git
.gitignore
./example_1
./dir/example_2
./example_2

... et le fichier .gitignore contenant:

example_2

... que le résultat de la commande sera:

$ git status --ignored

On branch master

Initial commit

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

.gitignore
.example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/
example_2

Si vous souhaitez répertorier les fichiers ignorés récursivement dans les répertoires, vous devez utiliser des paramètres supplémentaires - --untracked-files=all

Le résultat ressemblera à ceci:

$ git status --ignored --untracked-files=all
On branch master

Initial commit

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

.gitignore
example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/example_2
example_2