Comment arrêter le suivi et ignorer les modifications apportées à un fichier dans Git?

Question

J'ai cloné un projet contenant des fichiers .csproj. Je n'ai pas besoin/aime que mes fichiers csproj locaux soient suivis par Git (ou affichés lors de la création d'un correctif), mais ils sont clairement nécessaires dans le projet.

J'ai ajouté *.csproj à mon LOCAL .gitignore, mais les fichiers sont déjà dans le référentiel.

Lorsque je tape le statut git, il affiche les modifications que j'ai apportées à csproj et que je ne suis pas intéressé par le suivi ou la soumission de correctifs.

Comment puis-je supprimer le "suivi" de ces fichiers de mon dépôt personnel (tout en les conservant dans le source afin que je puisse les utiliser) afin que je ne voie pas les modifications lorsque je fais un statut (ou crée un correctif)?

Existe-t-il un moyen correct/canonique de gérer cette situation?

anthony · Accepted Answer

Il suffit d’appeler git rm --cached sur chacun des fichiers que vous souhaitez supprimer du contrôle de révision. Tant que vos modèles d'ignorage locaux sont corrects, vous ne verrez pas ces fichiers inclus dans la sortie du statut de git.

Notez que cette solution supprime les fichiers du référentiel, de sorte que tous les développeurs doivent conserver leurs propres copies locales du fichier (non contrôlées par la révision).

Pour empêcher git de détecter les changements dans ces fichiers, vous devez également utiliser cette commande:

git update-index --assume-unchanged [path]

Ce que vous voudrez probablement faire: (d'en bas @Ryan Taylor answer )

Ceci indique à git que vous voulez votre propre version indépendante du fichier ou du dossier. Par exemple, vous ne voulez pas écraser (ou supprimer) fichiers de configuration production/staging.

git update-index --skip-worktree <path-name>

La réponse complète se trouve dans l'URL suivante: http://source.kohlerville.com/2009/02/untrack-files-in-git/

araqnid · Answer

Si vous faites git update-index --assume-unchanged file.csproj, git ne vérifiera pas automatiquement les modifications apportées à fichier.csproj: cela les empêchera de passer à l'état de git chaque fois que vous les modifierez. Ainsi, vous pouvez marquer tous vos fichiers .csproj de cette manière, même si vous devez marquer manuellement les nouveaux que le référentiel en amont vous envoie. (Si vous les avez dans votre .gitignore ou .git/info/exclude, ceux que vous créez seront ignorés)

Je ne suis pas tout à fait sûr de ce que sont les fichiers .csproj ... S'ils ressemblent à des configurations IDE (similaires aux fichiers .Eclipse et .classpath d'Eclipse), je dirais qu'ils ne devraient tout simplement pas être contrôlé par la source du tout. D'un autre côté, s'ils font partie du système de construction (comme Makefiles), alors clairement, ils le devraient --- et un moyen de récupérer des modifications locales optionnelles (par exemple, depuis un fichier.csproj local à config.mk) serait utile : divise la construction en parties globales et en substitutions locales.

rjha94 · Answer

C'est un processus en deux étapes:

Supprimer le suivi du fichier/dossier - mais les conserver sur le disque - en utilisant
```
git rm --cached 
```
Maintenant, ils ne s'affichent pas comme "modifiés", mais toujours comme
```
 untracked files in git status -u 
```
Ajoutez-les à .gitignore

Ryan Taylor · Answer

Il y a 3 options, vous voulez probablement # 3

1. Ceci gardera le fichier local pour vous, mais le supprimera pour tous les autres lorsqu'ils les extrairont.

git rm --cached <file-name> ou git rm -r --cached <folder-name>

2. Ceci est pour l'optimisation, comme un dossier avec un grand nombre de fichiers, par exemple. SDK qui ne changeront probablement jamais. Il dit à git de cesser de vérifier chaque fois cet énorme dossier pour des modifications, localement, car il n'en aura pas. L'index assume-unchanged sera réinitialisé et le ou les fichiers seront écrasés s'il y a des modifications en amont du fichier/dossier (lorsque vous extrayez).

git update-index --assume-unchanged <path-name>

3. Ceci indique à git que vous voulez votre propre version indépendante du fichier ou du dossier. Par exemple, vous ne souhaitez pas écraser (ou supprimer) les fichiers de configuration de production/stockage intermédiaire.

git update-index --skip-worktree <path-name>

Il est important de savoir que git update-index ne propagera pas avec git et que chaque utilisateur devra l'exécuter indépendamment.

Buddhika Hasthanayake · Answer

La réponse acceptée n'a toujours pas fonctionné pour moi

J'ai utilisé

git rm -r --cached.

git add.

git commit -m "correction de .gitignore"

Trouvé la réponse de ici

Joe Lloyd · Answer

Vous avez oublié votre .gitignore?

Si vous avez localement l'intégralité du projet mais que vous avez oublié de vous y ajouter, git ignore et suivez maintenant certains fichiers inutiles, utilisez cette commande pour tout supprimer

git rm --cached -r .

assurez-vous d'être à la racine du projet.

Ensuite, vous pouvez faire l'habituel

Ajouter

git add .

Commettre

git commit -m 'removed all and added with git ignore'

Pousser

git Push Origin master

Conclusion

J'espère que cela aidera les personnes qui doivent modifier leur .gitignore ou tout oublier ensemble.

Il supprime la totalité du cache
Regarde ton .gitignore
Ajoute les fichiers que vous voulez suivre
Pousse à votre repo

the_new_mr · Answer

Comme indiqué dans d'autres réponses, la réponse sélectionnée est fausse.

Le answer à une autre question suggère qu'il serait peut-être nécessaire de sauter un arbre de travail.

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

Peter · Answer

Pour gagner du temps, les règles que vous ajoutez à votre .gitignore peuvent être utilisées pour supprimer plusieurs fichiers/dossiers, c.-à-d.

git rm --cached app/**/*.xml

ou

git rm --cached -r app/widgets/yourfolder/

etc.

belka · Answer

Beaucoup de gens vous conseillent d'utiliser git update-index --assume-unchanged. En effet, cela peut être une bonne solution, mais seulement à court terme.

Ce que vous voulez probablement faire est ceci: git update-index --skip-worktree.

(La troisième option, que vous ne voulez probablement pas, est: git rm --cached. Elle conservera votre fichier local, mais sera marquée comme étant supprimée du référentiel distant.)

Différence entre les deux premières options?

assume-unchanged est temporaire pour vous permettre de masquer les modifications d’un fichier. Si vous souhaitez masquer les modifications apportées à un fichier, modifier le fichier, puis extraire une autre branche, vous devez utiliser no-assume-unchanged puis probablement masquer les modifications effectuées.
skip-worktree vous suivra quelle que soit la succursale choisie, avec vos modifications!

Cas d'utilisation de assume-unchanged

Cela suppose que ce fichier ne doit pas être modifié, et vous donne une sortie plus propre en faisant git status. Mais lorsque vous passez à une autre branche, vous devez réinitialiser l'indicateur et valider ou masquer les modifications avant. Si vous tirez avec cette option activée, vous devrez résoudre les conflits et git ne se fusionnera pas automatiquement. En fait, il ne cache que les modifications (git status ne vous montrera pas les fichiers marqués).

J'aime l'utiliser lorsque je veux seulement arrêter de suivre les modifications pendant un certain temps + valider un groupe de fichiers (git commit -a) liés à la modification same.

Cas d'utilisation de skip-worktree

Vous avez une classe d'installation contenant des paramètres (par exemple, y compris des mots de passe) que vos amis doivent modifier en fonction de leur installation.

1: Créez une première version de cette classe, remplissez les champs que vous pouvez remplir et laissez les autres vides/nuls.
2: Commit et transmettez-le au serveur distant.
3: git update-index --skip-worktree MySetupClass.Java
4: Mettez à jour votre classe de configuration avec vos propres paramètres.
5: Retour au travail sur une autre fonctionnalité.

Les modifications que vous faites vous suivront quelle que soit la branche. Attention: si vos amis veulent aussi modifier cette classe, ils doivent avoir la même configuration, sinon leurs modifications seraient placées dans le référentiel distant. Lors du tirage, la version distante du fichier devrait écraser la vôtre.

PS: faites l'un ou l'autre, mais pas les deux car vous aurez des effets secondaires indésirables. Si vous voulez essayer un autre drapeau, vous devez d'abord le désactiver.

Ruto Collins · Answer

Pour dire à Git de ne pas suivre les modifications apportées à votre fichier/dossier local (ce qui signifie que l'état de Git ne détectera aucune modification), procédez comme suit:

git update-index --skip-worktree path/to/file

Et pour dire à Git de suivre à nouveau les modifications apportées à votre version locale (pour que vous puissiez les valider), faites:

git update-index --no-skip-worktree path/to/file

shijin · Answer

Pour empêcher la surveillance d'un fichier par git

git update-index --assume-unchanged [file-path]

Et pour revenir en arrière utiliser

git update-index --no-assume-unchanged [file-path]

Un référentiel à référencer pour des cas d'utilisation similaires https://github.com/awslabs/git-secrets

Vraj Pandya · Answer

Je suppose que vous demandez comment supprimer TOUS les fichiers d'un dossier spécifique ou du dossier bin plutôt que de sélectionner chaque fichier séparément.

Vous pouvez utiliser cette commande:

git rm -r -f /<floder-name>\*

Assurez-vous que vous vous trouvez dans le répertoire parent de ce répertoire.
Cette commande "supprimera" de manière récursive tous les fichiers qui se trouvent dans le dossier bin/ou build /. Par le mot delete, je veux dire que git prétendra que ces fichiers sont "supprimés" et que ces fichiers ne seront pas suivis. Le git marque vraiment ces fichiers pour être en mode suppression.

Assurez-vous que votre .gitignore est prêt pour les prochains commits.
Documentation: git rm

thearyong · Answer

Le problème peut être dû à l'ordre d'opération . Si vous avez d'abord modifié le fichier .gitignore, puis git rm --cached xxx, vous devrez peut-être continuer à rencontrer ce problème.

Solution correcte:

git rm --cached xxx
modifié le .gitignore

Ordre invariant!

Le .gitignore recharger après modification!

Pankaj Sonani · Answer

Je suppose que vous essayez de supprimer un seul fichier de git tacking ..__ pour cela, je recommanderais la commande ci-dessous.

git update-index --assume-inchangé

Ex - git update-index --assume-unchanged .gitignore .idea/compiler.xml

KutalmisB · Answer

Une approche presque git sans commande a été donnée dans cette réponse :

Pour ignorer certains fichiers pour chaque dépôt local:

Créez un fichier ~/.gitignore_global, par exemple. par touch ~/.gitignore_global dans votre terminal.
Exécutez git config --global core.excludesfile ~/.gitignore_global pour une fois.
Ecrivez les chemins de fichiers/répertoires que vous voulez ignorer dans ~/.gitignore_global. par exemple. modules/*.H, qui sera supposé se trouver dans votre répertoire de travail, c.-à-d. $WORK_DIR/modules/*.H.

Pour ignorer certains fichiers pour un seul dépôt local:

Effectuez la troisième étape ci-dessus pour le fichier .git/info/exclude dans le référentiel, c’est-à-dire, écrivez les chemins de fichiers/répertoires à ignorer dans .git/info/exclude. par exemple. modules/*.C, qui sera supposé se trouver dans votre répertoire de travail, c.-à-d. $WORK_DIR/modules/*.C.

mpag · Answer

Pour ignorer les modifications apportées à tous les fichiers (d'un certain type) d'un répertoire, je devais combiner certaines de ces approches, sinon les fichiers étaient créés s'ils n'existaient pas auparavant.

Dans la liste ci-dessous, "exclus" est le nom du répertoire sur lequel je souhaite ne pas regarder les modifications.

Commencez par supprimer tout nouveau fichier existant de votre cache de suivi des modifications (sans le supprimer de votre système de fichiers).

git status | grep "new file:" | cut --complement -d " " -f1-4 | grep "^excludedir" | xargs git rm --cache

Vous pouvez faire la même chose avec modified:. renamed: est un peu plus compliqué, car vous devrez examiner le bit post -> pour le nouveau nom de fichier et effectuer le bit pre -> comme décrit pour deleted: ci-dessous.

Les fichiers deleted: s'avèrent un peu plus compliqués, car vous ne pouvez pas sembler mettre à jour-index pour un fichier qui n'existe pas sur le système local

echo .deletedfiles >> .gitignore git status | grep "deleted:" | cut --complement -d " " -f1-4 | grep "^excludedir" > .deletedfiles cat .deletedfiles | xargs -d '
' touch cat .deletedfiles | xargs -d '
' git add -f cat .deletedfiles | xargs -d '
' git update-index --assume-unchanged cat .deletedfiles | xargs -d '
' rm

La dernière commande de la liste ci-dessus supprimera à nouveau les fichiers de votre système de fichiers, alors n'hésitez pas à l'omettre.

Ensuite, bloquer le suivi des modifications à partir de ce répertoire

git ls-files excludedir/ | xargs git update-index --skip-worktree git update index --skip-worktree excludedir/