la série de commandes ci-dessous va supprimer tous les éléments de L'Index Git (pas du répertoire de travail ou de la mise à jour locale), puis met à jour l'Index git, tout en respectant les ignorants git. PS. Index = Cache

d'Abord:

git rm -r --cached . 
git add .

puis:

git commit -am "Remove ignored files"

git update-index fait le travail pour moi:

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

Note: cette solution est en fait indépendante sur .gitignore comme gitignore est seulement pour les fichiers non tracés.

edit: Depuis cette réponse a été publiée, une nouvelle option a été créé et qui doit être préférée. Vous devez utiliser --skip-worktree qui est pour les fichiers traqués modifiés que le l'utilisateur ne veut plus s'engager et garde --assume-unchanged pour les performances pour empêcher git de vérifier l'état des gros fichiers suivis. Voir https://stackoverflow.com/a/13631525/717372 pour plus de détails...

git ls-files --ignored --exclude-standard -z | xargs -0 git rm --cached
git commit -am "Remove ignored files"

Cela prend la liste des fichiers ignorés et les supprime de l'index, puis valide les modifications.

j'utilise toujours cette commande pour supprimer ces fichiers non tracés. Une ligne, style Unix, sortie propre:

git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

il Liste tous vos fichiers ignorés, remplace chaque ligne de sortie par une ligne Citée à la place pour gérer les chemins avec des espaces à l'intérieur, et passe tout à git rm -r --cached pour supprimer les chemins/fichiers/dirs de l'index.

si vous ne pouvez pas git rm un fichier de suivi parce que d'autres personnes pourraient en avoir besoin (attention, même si vous git rm --cached , lorsque quelqu'un d'autre obtient ce changement, leurs fichiers seront supprimés dans leur système de fichiers). Celles-ci sont souvent faites en raison de la suppression des fichiers de configuration, des justificatifs d'authentification, etc. S'il vous plaît regarder https://gist.github.com/1423106 pour les façons dont les gens ont contourné le problème.

pour résumer:

• demandez à votre application de rechercher un fichier de configuration ignoré.ini et utilisez cela sur la configuration du fichier committed.(ou alternativement, chercher~/.config / myapp.ini, or $MYCONFIGFILE)
• Commettre un fichier de config-sample.ini et ignorer la configuration du fichier.ini, avoir un script ou une copie similaire du fichier si nécessaire.
• essayez d'utiliser gitattributes clean / smudge magic pour appliquer et supprimer les changements pour vous, par exemple smudge le fichier de configuration comme un checkout à partir d'une branche alternative et nettoie le fichier de configuration comme un checkout à partir de la tête. C'est un truc délicat, Je ne le recommande pas à l'utilisateur novice.
• conserver le fichier de configuration sur une branche de déploiement qui lui est dédiée et qui n'est jamais fusionnée à master. Quand vous voulez déployer/compiler/tester vous fusionnez à cette branche et obtenez ce fichier. Il s'agit essentiellement de l'approche smudge/clean sauf en utilisant des politiques de fusion humaine et des modules extra-git.
• Anti-recommandation: Ne pas utiliser assume inchangé, il terminera dans les larmes.

sortir, s'engager, puis déplacez-le de nouveau. Cela a fonctionné pour moi dans le passé. Il y a probablement un moyen "gittier" d'y parvenir.

Ce qui n'a pas de travail pour moi

(sous Linux), je voulais utiliser les messages ici suggérant l'approche ls-files --ignored --exclude-standard | xargs git rm -r --cached . Cependant, certains des fichiers à supprimer avaient une nouvelle ligne/LF/ \n dans leur nom. Aucune des deux solutions:

git ls-files --ignored --exclude-standard | xargs -d"\n" git rm --cached
git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

faire face à cette situation (obtenir des erreurs sur les fichiers non trouvés).

Donc, je vous offre

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached

utilise le -z argument à ls-files , et le -0 argument à xargs pour répondre en toute sécurité / correctement pour les caractères "méchants" dans les noms de fichiers.

Dans la page de manuel de git-ls-fichiers(1) , il déclare: "les 1519110920"

lorsque l'option-z n'est pas utilisée, les caractères TAB, LF, et antislash dans les noms de chemins sont représentés respectivement par \t, \N et\\.

donc je pense que ma solution est nécessaire si les noms de fichiers ont l'un de ces caractères.

EDIT: on m'a demandé d'ajouter que --- comme n'importe quelle commande git rm - - - cela doit être suivi d'un commit pour rendre les suppressions permanentes, par exemple git commit -am "Remove ignored files" .

j'ai accompli ceci en utilisant git filter-branch . La commande exacte que j'ai utilisée est tirée de la page de manuel:

WARNING : ceci supprimera le fichier de toute votre histoire

git filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD

cette commande va recréer toute l'histoire de la propagation, en exécutant git rm avant chaque propagation et ainsi se débarrasser du fichier spécifié. N'oubliez pas de sauvegarder avant de lancer la commande comme il sera perdu.

utilisez ceci quand:

1. Vous voulez déballer beaucoup de fichiers, ou

2. Vous avez mis à jour votre fichier gitignore

lien vers la Source: http://www.codeblocq.com/2016/01/Untrack-files-already-added-to-git-repository-based-on-gitignore/

disons que vous avez déjà ajouté/engagé des fichiers dans votre dépôt git et vous ajoutez ensuite à votre .gitignore; ces fichiers seront toujours présents dans votre index de dépôt. Cet article nous verrons comment se débarrasser d'eux.

Étape 1: Engager tous vos modifications

avant de procéder, assurez-vous que tous vos changements sont engagés, y compris le vôtre .dossier gitignore.

Étape 2: Tout supprimer du dépôt

pour effacer votre pension, utilisez:

git rm -r --cached .

• rm est la commande remove
• -r permettra la suppression récursive
• –cache ne supprimera que les fichiers de l'index. Vos dossiers seront toujours là.

la commande rm peut être impitoyable. Si vous souhaitez essayer ce qu'il fait à l'avance, ajouter -n ou --dry-run drapeau de tester des choses.

Étape 3: Ajouter tout

git add .

Etape 4: Commit

git commit -m ".gitignore fix"

votre dépôt est propre:)

Pousser les modifications de votre télécommande pour voir les changements en vigueur.

1. mise à Jour de votre .gitignore fichier – par exemple, ajouter un dossier que vous ne voulez pas suivre .gitignore .

2. git rm -r --cached . – supprimez tous les fichiers suivis, y compris wanted et unwanted. Votre code sera sécurisé tant que vous aurez sauvegardé localement.

3. git add . – tous les fichiers seront ajoutés de nouveau, sauf ceux dans .gitignore .

chapeau à @AkiraYamamoto pour nous pointer dans la bonne direction.

je pense, que peut-être git ne peut pas totalement oublier le fichier en raison de sa conception ( section" Snapshots, Not Differences " ).

ce problème est absent, par exemple, lors de L'utilisation de CVS. CVS stocke l'information sous forme de liste de modifications basées sur des fichiers. L'Information pour CVS est un ensemble de fichiers et les changements apportés à chaque fichier au fil du temps.

mais en Git chaque fois que vous vous engagez, ou sauver l'état de votre projet, il faut l'image de ce tous vos fichiers à ce moment et stocke une référence à cet instantané. Donc, si vous avez ajouté le fichier une fois, il sera toujours présent dans cet instantané.

ces 2 articles m'ont été utiles:

git Assumption-unchanged vs skip-worktree et comment ignorer les changements dans les fichiers suivis avec Git

Basing sur ce je fais ce qui suit, si le dossier est déjà suivi:

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

A partir de ce moment toutes les modifications locales de ce fichier seront ignorées et ne seront pas envoyées à distance. Si le fichier est modifié à distance, le conflit se produira, quand git pull . Stash ne marchera pas. Pour le résoudre, copier le contenu du fichier à l'endroit sûr et suivre ces étapes:

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

sera remplacé par le contenu distant. Coller vos modifications de lieu sûr pour déposer et exécuter à nouveau:

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

si tout le monde, qui travaille avec le projet, effectuera git update-index --skip-worktree <file> , les problèmes avec pull devraient être absents. Cette solution est acceptable pour les fichiers de configuration, lorsque chaque développeur a sa propre configuration de projet.

il n'est pas très commode de faire cela à chaque fois, lorsque le fichier a été modifié à distance, mais peut le protéger de la réécriture par le contenu à distance.

Déplacer ou copier le fichier à un endroit sûr, afin de ne pas le perdre. Puis git rm le fichier et commit. Le fichier apparaîtra toujours si vous revenez à l'une de ces propagations précédentes, ou à une autre branche où il n'a pas été supprimé. Cependant, dans tous les futurs commits, vous ne verrez plus le fichier. Si le fichier est dans le git d'ignorer, alors vous pouvez le déplacer dans le dossier, et git de ne pas le voir.

la réponse de Matt Fear fut la plus efficace des IMHO. Ce qui suit est juste un script PowerShell pour ceux dans windows pour supprimer les fichiers de leur git repo qui correspondent à leur liste d'exclusion.

# Get files matching exclusionsfrom .gitignore
# Excluding comments and empty lines
$ignoreFiles =  gc .gitignore | ?{$_ -notmatch  "#"} |  ?{$_ -match  "\S"} | % {
                    $ignore = "*" + $_ + "*"
                    (gci -r -i $ignore).FullName
                }
$ignoreFiles = $ignoreFiles| ?{$_ -match  "\S"}

# Remove each of these file from Git 
$ignoreFiles | % { git rm $_}

git add .

le BFG est spécifiquement conçu pour supprimer les données indésirables comme les gros fichiers ou les mots de passe de Git repos, il a donc un drapeau simple qui va supprimer tous les grands fichiers historiques (pas-dans-votre-courant-commit): '-- strip-blobs-bigger-than'

$ java -jar bfg.jar --strip-blobs-bigger-than 100M

Si vous souhaitez spécifier les fichiers par nom, vous pouvez le faire aussi:

$ java -jar bfg.jar --delete-files *.mp4

le BFG est 10-1000x plus rapide que git filtre-branche, et généralement beaucoup plus facile à utiliser - cocher la case "151990920 complet" instructions d'utilisation et exemples pour plus de détails.

Source: https://confluence.atlassian.com/bitbucket/reduce-repository-size-321848262.html

si vous ne voulez pas utiliser le CLI et travaillez sur Windows, une solution très simple est d'utiliser TortoiseGit , il a L'Action" Delete (keep local) " dans le menu qui fonctionne très bien.

j'ai aimé la réponse de JonBrave mais j'ai assez de répertoires qui fonctionnent mal qui me font un peu peur, alors voilà ce que j'ai fait:

git config -- global alias.exclure ignoré '!git ls-fichiers -z --ignoré --exclude-standard | xargs -0 git rm -r --cache && git ls-fichiers -z --ignoré --exclude-standard | xargs -0 git scène && git scène .gitignore && git commit -m "nouveau gitignore et supprimer les fichiers ignorés à partir de l'index"'

en le décomposant:

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached 
git ls-files -z --ignored --exclude-standard | xargs -0 git stage 
git stage .gitignore 
git commit -m "new gitignore and remove ignored files from index"

• supprimer les fichiers ignorés de l'index
• étape .gitignore et les fichiers que vous venez de supprimer
• commit

cette question n'est plus à l'ordre du jour de la dernière édition du git (v2.17.1 au moment de la rédaction).

le .gitignore ignore finalement les fichiers tracés mais supprimés. Vous pouvez tester vous-même en exécutant le script suivant. La déclaration finale git status doit indiquer"rien à commettre".

# Create empty repo
mkdir gitignore-test
cd gitignore-test
git init

# Create a file and commit it
echo "hello" > file
git add file
git commit -m initial

# Add the file to gitignore and commit
echo "file" > .gitignore
git add .gitignore
git commit -m gitignore

# Remove the file and commit
git rm file
git commit -m "removed file"

# Reintroduce the file and check status.
# .gitignore is now respected - status reports "nothing to commit".
echo "hello" > file
git status

dans le cas de déjà commis DS_Store :

find . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch

ignorez-les par:

echo ".DS_Store" >> ~/.gitignore_global
echo "._.DS_Store" >> ~/.gitignore_global
echo "**/.DS_Store" >> ~/.gitignore_global
echo "**/._.DS_Store" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

enfin, s'engager!

faites les étapes suivantes en série,vous serez très bien.

1. supprimer les fichiers ajoutés par erreur du répertoire/stockage . Vous pouvez utiliser la commande "rm-r"(Pour linux) ou les supprimer en parcourant les répertoires.

2.ajoutez les fichiers / répertoires au fichier gitignore maintenant et enregistrez-le.

3.maintenant supprimer eux de git cache en utilisant ces commandes (s'il y a plus d'un répertoire, supprimez-les un par un en émettant cette commande à plusieurs reprises)

git rm -r --cached path-to-those-files

4.maintenant faire un commit et push , l'utilisation de ces commandes. Cela va supprimer ces fichiers de Git distant et faire git arrêter de suivre ces fichiers.

git add .
git commit -m "removed unnecessary files from git"
git push origin