.gitignore

Description

Dans la copie de travail, les fichiers sont visibles par Git comme l’un des éléments suivants : suivis, non suivis et ignorés.

Les fichiers ignorés sont ceux que Git a reçu l’instruction d’ignorer. Ils incluent généralement les artefacts de build, les journaux, les métadonnées du système d’exploitation et les configurations de l’IDE. Si vous voulez que ces fichiers soient commités, ils doivent d’abord être dérivés du code source du dépôt. Voici quelques exemples de fichiers ignorés par Git :

• Fichiers générés à l’exécution (par exemple .log, .lock),
• Fichiers système cachés (.DS_Store, Thumbs.db),
• Code compilé (.o, .class), etc.

Modèles d’ignorance Git

Les fichiers d’ignorance Git se trouvent dans un fichier appelé .gitignore. Ils sont modifiés et commités manuellement, car il n’existe pas de commande git ignore. Les fichiers d’ignorance Git contiennent des modèles comparés aux noms de fichiers, grâce auxquels vous décidez d’ignorer ou non chaque fichier. Ces modèles sont créés à l’aide de plusieurs symboles :

Pattern	Explanation
**/logs	Double asterisks are used to match directories anywhere in the repository
**/logs/debug.log	Double asterisks are used to match files based on their name and the name of their parent directory.
*.log	An asterisk matches zero or more characters.
*.log !important.log	Exclamation mark negates pattern. A file will not be ignored if it matches a negating pattern defined later.
*.log !important/*.log trace.*	A later pattern can re-ignore a file that was previously un-ignored, provided it matches the same file.
/debug.log	The slash matches files only in the repository root.
debug.log	By default, patterns match files in any directory.
debug?.log	The question mark matches just one character.
debug[0-9].log	Square brackets are used to match a single character from a particular range.
debug[01].log	Square brackets match a single character from the particular set.
debug[!01].log	The exclamation mark is used to match any character except one from the particular set.
debug[a-z].log	Ranges can be numeric or alphabetic.
logs	The pattern will match both files and the contents of directories with that name if it isn’t used with a slash.
logs/	Using a slash points out that the pattern is a directory. The whole content of any directory with its files and subdirectories in the repository which matches that name will be ignored by Git.
logs/**/debug.log	A double asterisk matches zero or more directories.
logs/*day/debug.log	Asterisks can be used in directory names too.

Voici un exemple avec l’un de ces modèles :

.gitignore patterns

debug0.log
debug1.log
#but not
debug10.log

Fichiers .gitignore partagés dans le dépôt

Vous pouvez définir plusieurs fichiers .gitignore dans différents répertoires du dépôt. Chacun des modèles est testé relativement au répertoire qui contient ce fichier. Cependant, la méthode la plus simple consiste à définir un seul fichier .gitignore à la racine du dépôt.

Comme votre fichier .gitignore est versionné dans votre dépôt, il est partagé avec votre équipe lorsque vous poussez. Vous ne devriez inclure dans .gitignore que des modèles utiles aux autres utilisateurs du dépôt.

Règles personnelles pour l’ignorance Git

Des modèles d’ignorance personnels peuvent également être définis pour un dépôt particulier dans un fichier spécial situé à .git/info/exclude. C’est un emplacement approprié pour inclure des modèles utiles uniquement pour vous, car ils ne sont ni versionnés ni distribués avec votre dépôt.

Règles globales d’ignorance Git

Vous pouvez définir la propriété Git core.excludesFile afin de spécifier en plus des modèles globaux d’ignorance Git pour tous les dépôts de votre système local. Ce fichier sera créé par vous-même. Vous pouvez placer votre fichier global .gitignore dans votre répertoire personnel pour le retrouver facilement. Une fois le fichier créé, configurez son emplacement avec la commande git config, comme ceci :

global gitignore rules

touch ~/.gitignore
git config --global core.excludesFile ~/.gitignore

Ignorer un fichier précédemment commit

Pour ignorer un fichier qui a déjà été commit, il faut le supprimer du dépôt. Ensuite, vous devez lui ajouter une règle .gitignore. À l’aide de l’option --cached de git rm, le fichier sera supprimé du dépôt mais restera dans le répertoire de travail en tant que fichier ignoré. Cependant, si vous voulez aussi le supprimer du répertoire de travail, il suffit d’omettre l’option --cached.

.gitignore commited files

echo debug.log >> .gitignore
git rm --cached debug.log
#rm 'debug.log'
git commit -m "Start ignoring debug.log"

Commit d’un fichier ignoré

Le fichier ignoré peut être commit au dépôt en combinant l’option -f (ou --force) avec git add. Cependant, choisissez cette méthode si vous avez un modèle général, comme *.log, mais que vous souhaitez commit un fichier spécifique :

commiting ignored files

cat .gitignore
# *.log
git add -f debug.log
git commit -m "Force adding debug.log"

Sinon, la méthode la plus simple consiste à définir une exception à la règle générale :

commit ignored files

echo '!debug.log' >> .gitignore

cat .gitignore
#*.log
#!debug.log

git add debug.log
git commit -m "Adding debug.log"

Mettre de côté un fichier ignoré

La commande git stash prend à la fois les modifications indexées et non indexées non commit, les met de côté pour une utilisation ultérieure, puis les restaure dans votre copie de travail. Par défaut, elle ignore les fichiers ignorés et ne met de côté que les modifications suivies par Git. Mais l’option --all fera en sorte que cette commande mette de côté les modifications des fichiers ignorés et non suivis.

Déboguer les fichiers .gitignore

Dans le cas de modèles .gitignore complexes, ou de modèles répartis sur plusieurs fichiers .gitignore, il peut être difficile de trouver pourquoi un fichier particulier est ignoré. La commande git check-ignore avec l’option -v (ou --verbose) détermine quel modèle provoque l’ignorance d’un fichier particulier :

git check ignored files

git check-ignore -v debug.log
#.gitignore:3:*.log debug.log

Voici la sortie :

git check-ignore

<file containing the pattern> : <line number of the pattern> : <pattern> <file name>

Practice

Which statements accurately describe the functionalities and rules of `.gitignore` files in Git?

Patterns in `.gitignore` are applied globally across all directories in a repository.Ignored files are files that Git has been explicitly told to ignore.The `.gitignore` file can include patterns to ignore specific files such as logs or compiled code.Changes in `.gitignore` files need to be committed like any other file.A single `.gitignore` file is always sufficient for a repository regardless of its size.You can create a `.gitignore` file in the `.git` directory to ignore files globally.`.gitignore` rules can be overridden by specific commands in Git.The `git check-ignore -v` command helps in identifying why certain files are ignored.