Es gibt eine Datei, die verfolgt wurde git, aber jetzt ist die Datei in der .gitignoreListe.

Diese Datei wird jedoch git statusnach der Bearbeitung immer wieder angezeigt. Wie zwingen Sie es, gites komplett zu vergessen?

.gitignoreverhindert, dass nicht verfolgte Dateien (ohne ein add -f) zu dem von git verfolgten Dateisatz hinzugefügt werden. git verfolgt jedoch weiterhin alle Dateien, die bereits verfolgt werden.

Um die Verfolgung einer Datei zu beenden, müssen Sie sie aus dem Index entfernen. Dies kann mit diesem Befehl erreicht werden.

git rm --cached <file>

Wenn Sie einen ganzen Ordner entfernen möchten, müssen Sie alle darin enthaltenen Dateien rekursiv entfernen.

git rm -r --cached <folder>

Das Entfernen der Datei aus der Kopfrevision erfolgt beim nächsten Commit.

WARNUNG: Dadurch wird zwar die physische Datei nicht von Ihrem lokalen Computer entfernt, aber beim nächsten Mal werden die Dateien von anderen Entwicklercomputern entfernt git pull.

Die folgende Befehlsreihe entfernt alle Elemente aus dem Git-Index (nicht aus dem Arbeitsverzeichnis oder dem lokalen Repo) und aktualisiert dann den Git-Index, wobei git ignoriert wird. PS. Index = Cache

Zuerst:

git rm -r --cached . 
git add .

Dann:

git commit -am "Remove ignored files"

Oder einzeilig:

git rm -r --cached . && git add . && git commit -am "Remove ignored files"

git update-index erledigt den Job für mich:

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

Hinweis: Diese Lösung ist tatsächlich unabhängig von, .gitignoreda Gitignore nur für nicht verfolgte Dateien gilt.

Bearbeiten: Da diese Antwort veröffentlicht wurde, wurde eine neue Option erstellt, die bevorzugt werden sollte. Sie sollten --skip-worktreediese Option für geänderte nachverfolgte Dateien verwenden, die der Benutzer nicht mehr --assume-unchangedfestschreiben möchte, und die Leistung beibehalten, um zu verhindern, dass git den Status großer nachverfolgter Dateien überprüft. Weitere Informationen finden Sie unter https://stackoverflow.com/a/13631525/717372 ...

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

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

Dadurch wird die Liste der ignorierten Dateien aus dem Index entfernt und die Änderungen werden festgeschrieben.

Ich benutze diesen Befehl immer, um diese nicht verfolgten Dateien zu entfernen. Einzeilige, saubere Ausgabe im Unix-Stil:

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

Es listet alle ignorierten Dateien auf, ersetzt stattdessen jede Ausgabezeile durch eine Zeile in Anführungszeichen, um Pfade mit Leerzeichen zu behandeln, und git rm -r --cachedübergibt alles , um die Pfade / Dateien / Verzeichnisse aus dem Index zu entfernen.

Verschieben Sie es heraus, legen Sie es fest und dann wieder hinein. Dies hat in der Vergangenheit bei mir funktioniert. Es gibt wahrscheinlich einen "gittier" Weg, um dies zu erreichen.

Wenn Sie git rmeine nachverfolgte Datei nicht verwenden können, weil andere Personen sie möglicherweise benötigen (Warnung, auch wenn Sie git rm --cached , wenn jemand anderes diese Änderung erhält, deren Dateien in seinem Dateisystem gelöscht werden). Diese werden häufig aufgrund von Überschreibungen von Konfigurationsdateien, Authentifizierungsdaten usw. durchgeführt. Weitere Informationen finden Sie unter https://gist.github.com/1423106 für die das Problem haben.

Zusammenfassen:

• Lassen Sie Ihre Anwendung nach einer ignorierten Datei config-overide.ini suchen und diese über die festgeschriebene Datei config.ini verwenden (oder suchen Sie alternativ nach ~ / .config / myapp.ini oder $ MYCONFIGFILE).
• Übernehmen Sie die Datei config-sample.ini und ignorieren Sie die Datei config.ini. Lassen Sie die Datei bei Bedarf von einem Skript oder einer ähnlichen Datei kopieren.
• Versuchen Sie, gitattributes clean / smudge magic zu verwenden, um die Änderungen für Sie anzuwenden und zu entfernen. Verschmieren Sie beispielsweise die Konfigurationsdatei als Checkout aus einem alternativen Zweig und bereinigen Sie die Konfigurationsdatei als Checkout aus HEAD. Das ist kniffliges Zeug, ich empfehle es nicht für Anfänger.
• Bewahren Sie die Konfigurationsdatei in einem dafür vorgesehenen Bereitstellungszweig auf, der niemals mit dem Master zusammengeführt wird. Wenn Sie bereitstellen / kompilieren / testen möchten, werden Sie zu diesem Zweig zusammengeführt und erhalten diese Datei. Dies ist im Wesentlichen der Smudge / Clean-Ansatz, außer dass Human Merge-Richtlinien und Extra-Git-Module verwendet werden.
• Anti-Empfehlung: Verwenden Sie nicht unverändert, es wird nur in Tränen enden (weil das Lügen von sich selbst dazu führen kann, dass schlimme Dinge passieren, wie zum Beispiel, dass Ihre Veränderung für immer verloren geht).

Verwenden Sie dies, wenn:

1. Sie möchten viele Dateien entfernen, oder

2. Sie haben Ihre Gitignore-Datei aktualisiert

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

Angenommen, Sie haben bereits einige Dateien zu Ihrem Git-Repository hinzugefügt / festgeschrieben und fügen sie dann Ihrem .gitignore hinzu. Diese Dateien sind weiterhin in Ihrem Repository-Index vorhanden. In diesem Artikel werden wir sehen, wie man sie loswird.

Schritt 1: Übernehmen Sie alle Ihre Änderungen

Stellen Sie vor dem Fortfahren sicher, dass alle Ihre Änderungen festgeschrieben sind, einschließlich Ihrer Gitignore-Datei.

Schritt 2: Entfernen Sie alles aus dem Repository

Verwenden Sie zum Löschen Ihres Repos:

git rm -r --cached .

• rm ist der Befehl remove
• -r ermöglicht das rekursive Entfernen
• –Cached entfernt nur Dateien aus dem Index. Ihre Dateien bleiben erhalten.

Der rmBefehl kann unversöhnlich sein. Wenn Sie vorher ausprobieren möchten, was es tut, fügen Sie das -noder hinzu--dry-run Flag , um die Dinge zu testen.

Schritt 3: Fügen Sie alles erneut hinzu

git add .

Schritt 4: Festschreiben

git commit -m ".gitignore fix"

Dein Repository ist sauber :)

Übertragen Sie die Änderungen auf Ihre Fernbedienung, um zu sehen, ob die Änderungen auch dort wirksam sind.

Ich habe dies mit Git Filter-Branch erreicht . Der genaue Befehl, den ich verwendet habe, wurde der Manpage entnommen:

WARNUNG : Dadurch wird die Datei aus Ihrem gesamten Verlauf gelöscht

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

Dieser Befehl erstellt den gesamten Festschreibungsverlauf neu git rmund wird vor jedem Festschreiben ausgeführt. Dadurch wird die angegebene Datei entfernt. Vergessen Sie nicht , um es wieder auf , bevor der Befehl ausgeführt wird, wie es wird verloren.

Was bei mir nicht funktioniert hat

(Unter Linux) wollte ich die Beiträge hier verwenden, die den ls-files --ignored --exclude-standard | xargs git rm -r --cachedAnsatz vorschlagen . (Einige) der zu entfernenden Dateien hatten jedoch einen eingebetteten Zeilenumbruch / LF / \nin ihren Namen. Keine der Lösungen:

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

mit dieser Situation fertig werden (Fehler über nicht gefundene Dateien erhalten).

Also biete ich an

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

Dies verwendet das -zArgument für ls-Dateien und das -0Argument für xargs , um "böse" Zeichen in Dateinamen sicher / korrekt zu berücksichtigen.

In der Handbuchseite git-ls-files (1) heißt es:

Wenn die Option -z nicht verwendet wird, werden TAB-, LF- und Backslash-Zeichen in Pfadnamen als \ t, \ n bzw. \\ dargestellt.

Daher denke ich, dass meine Lösung benötigt wird, wenn Dateinamen eines dieser Zeichen enthalten.

1. Aktualisieren Sie Ihre .gitignoreDatei. Fügen Sie beispielsweise einen Ordner hinzu, in den Sie nicht verfolgen möchten .gitignore.

2. git rm -r --cached .- Entfernen Sie alle verfolgten Dateien, einschließlich gewünschter und unerwünschter. Ihr Code ist sicher, solange Sie lokal gespeichert haben.

3. git add .- Alle Dateien werden wieder hinzugefügt, außer denen in .gitignore.

Hutspitze an @AkiraYamamoto für den Hinweis in die richtige Richtung.

Ich denke, dass Git die Datei aufgrund ihrer Konzeption vielleicht nicht völlig vergessen kann ( Abschnitt "Schnappschüsse, keine Unterschiede"). ).

Dieses Problem fehlt beispielsweise bei der Verwendung von CVS. CVS speichert Informationen als Liste dateibasierter Änderungen. Informationen für CVS sind eine Reihe von Dateien und die Änderungen, die im Laufe der Zeit an jeder Datei vorgenommen wurden.

In Git wird jedoch jedes Mal, wenn Sie einen Commit durchführen oder den Status Ihres Projekts speichern, ein Bild davon erstellt, wie alle Ihre Dateien in diesem Moment aussehen, und ein Verweis auf diesen Snapshot gespeichert . Wenn Sie also eine Datei einmal hinzugefügt haben, ist sie in diesem Snapshot immer vorhanden.

Diese 2 Artikel waren hilfreich für mich:

git Annahme-unverändert vs Skip-Worktree und Wie man Änderungen in verfolgten Dateien mit Git ignoriert

Darauf aufbauend mache ich folgendes, wenn die Datei bereits verfolgt wird:

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

Ab diesem Moment werden alle lokalen Änderungen in dieser Datei ignoriert und nicht mehr auf Remote übertragen. Wenn die Datei auf der Fernbedienung geändert wird, tritt ein Konflikt auf, wenn git pull. Stash wird nicht funktionieren. Um das Problem zu beheben, kopieren Sie den Dateiinhalt an einen sicheren Ort und führen Sie die folgenden Schritte aus:

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

Der Dateiinhalt wird durch den Remote-Inhalt ersetzt. Fügen Sie Ihre Änderungen vom sicheren Ort in die Datei ein und führen Sie sie erneut aus:

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

Wenn jeder, der mit dem Projekt arbeitet, Leistung erbringt git update-index --skip-worktree <file>, sollten Probleme mit pullfehlen. Diese Lösung ist für Konfigurationsdateien in Ordnung, wenn jeder Entwickler seine eigene Projektkonfiguration hat.

Es ist nicht sehr praktisch, dies jedes Mal zu tun, wenn eine Datei auf einem Remote-Computer geändert wurde, kann sie jedoch vor dem Überschreiben durch Remote-Inhalte schützen.

Führen Sie die folgenden Schritte nacheinander aus, es wird Ihnen gut gehen.

1. Entfernen Sie die versehentlich hinzugefügten Dateien aus dem Verzeichnis / Speicher . Sie können den Befehl "rm -r" (für Linux) verwenden oder sie löschen, indem Sie die Verzeichnisse durchsuchen. Oder verschieben Sie sie an einen anderen Ort auf Ihrem PC. [Möglicherweise müssen Sie die IDE schließen, wenn Sie sie zum Verschieben / Entfernen ausführen möchten. ]

2. Fügen Sie die Dateien / Verzeichnisse gitignorejetzt zur Datei hinzu und speichern Sie sie.

3. Entfernen Sie sie jetzt mit diesen Befehlen aus dem Git-Cache (wenn mehr als ein Verzeichnis vorhanden ist, entfernen Sie sie nacheinander, indem Sie diesen Befehl wiederholt ausgeben).

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

4.Nehmen Sie jetzt ein Commit und Push , verwenden Sie diese Befehle. Dadurch werden diese Dateien von git remote entfernt und git hört auf, diese Dateien zu verfolgen .

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

Die Antwort zum Kopieren / Einfügen lautet git rm --cached -r .; git add .; git status

Dieser Befehl ignoriert die Dateien, die bereits in ein Git-Repository übernommen wurden, aber jetzt haben wir sie hinzugefügt .gitignore.

Die Antwort von Matt Fear war meiner Meinung nach die effektivste. Das Folgende ist nur ein PowerShell-Skript für Windows-Benutzer, mit dem nur Dateien aus ihrem Git-Repo entfernt werden können, die der Ausschlussliste entsprechen.

# 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 .

Verschieben oder kopieren Sie die Datei an einen sicheren Ort, damit Sie sie nicht verlieren. Dann git rm die Datei und Commit. Die Datei wird weiterhin angezeigt, wenn Sie zu einem dieser früheren Commits oder einem anderen Zweig zurückkehren, in dem sie nicht entfernt wurde. Bei allen zukünftigen Commits wird die Datei jedoch nicht mehr angezeigt. Wenn sich die Datei im Git-Ignorier befindet, können Sie sie wieder in den Ordner verschieben, und Git wird sie nicht sehen.

Die Verwendung des git rm --cachedBefehls beantwortet nicht die ursprüngliche Frage:

Wie erzwingen Sie, git[eine Datei] vollständig zu vergessen?

Tatsächlich führt diese Lösung dazu, dass die Datei in jeder anderen Instanz des Repositorys gelöscht wird, wenn ein git pull!

Der richtige Weg, um Git zum Vergessen einer Datei zu zwingen, wird hier von GitHub dokumentiert .

Ich empfehle die Dokumentation zu lesen, aber im Grunde:

git fetch --all
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all
git push origin --force --all
git push origin --force --tags
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

Ersetzen Sie einfach durch full/path/to/fileden vollständigen Pfad der Datei. Stellen Sie sicher, dass Sie die Datei zu Ihrem hinzugefügt haben .gitignore.

Sie müssen auch (vorübergehend) Pushs ohne schnellen Vorlauf in Ihr Repository zulassen , da Sie Ihren Git-Verlauf ändern.

Die BFG wurde speziell zum Entfernen unerwünschter Daten wie großer Dateien oder Kennwörter aus Git-Repos entwickelt. Sie verfügt daher über ein einfaches Flag, mit dem große historische Dateien (die nicht in Ihrem aktuellen Commit enthalten sind) entfernt werden: '--strip-blobs- größer als'

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

Wenn Sie Dateien nach Namen angeben möchten, können Sie dies auch tun:

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

Das BFG ist 10-1000x schneller als der Git-Filter-Zweig und im Allgemeinen viel einfacher zu verwenden - lesen Sie die vollständigen Gebrauchsanweisungen und Beispiele Weitere Informationen finden .

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

Wenn Sie die CLI nicht verwenden möchten und unter Windows arbeiten, besteht eine sehr einfache Lösung darin, TortoiseGit zu verwenden. Das Menü enthält die Aktion "Löschen (lokal halten)", die einwandfrei funktioniert.

Ich mochte JonBraves Antwort, aber ich habe genug unordentliche Arbeitsverzeichnisse, die mich verpflichten - ein bisschen macht mir ein bisschen Angst, also habe ich Folgendes getan:

git config --global alias.exclude-ignoriert '! 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 "neuer gitignore und ignorierte Dateien aus dem Index entfernen" '

Brechen sie ab:

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"

• Entfernen Sie ignorierte Dateien aus dem Index
• Stage .gitignore und die Dateien, die Sie gerade entfernt haben
• verpflichten

Dies ist im neuesten Git (v2.17.1 zum Zeitpunkt des Schreibens) kein Problem mehr .

Das .gitignoreignoriert schließlich verfolgte, aber gelöschte Dateien. Sie können dies selbst testen, indem Sie das folgende Skript ausführen. In der Schlusserklärung git statussollte "nichts zu begehen" angegeben werden.

# 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

Im Falle einer bereits begangenen DS_Store:

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

Ignoriere sie durch:

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

Machen Sie endlich ein Commit!

Speziell für die IDE-basierten Dateien verwende ich Folgendes:

Zum Beispiel die slnx.sqlite, ich habe sie gerade komplett wie folgt entfernt:

git rm {PATH_OF_THE_FILE}/slnx.sqlite -f
git commit -m "remove slnx.sqlite"

Denken Sie daran, dass in einigen dieser Dateien einige lokale Benutzereinstellungen und Einstellungen für Projekte gespeichert sind (z. B. welche Dateien Sie geöffnet haben). Jedes Mal, wenn Sie in Ihrer IDE navigieren oder Änderungen vornehmen, wird diese Datei geändert und daher ausgecheckt und angezeigt, wenn nicht festgeschriebene Änderungen vorliegen.

Die akzeptierte Antwort lässt Git nicht " eine Datei vergessen ..." (historisch). Git ignoriert die Datei nur in der Gegenwart / Zukunft.

Diese Methode lässt git ignorierte Dateien ( Vergangenheit / Gegenwart / Zukunft) vollständig vergessen , tut dies jedoch nicht löscht alles von Arbeitsverzeichnis (auch bei Wieder gezogen aus der Ferne).

Diese Methode erfordert die Verwendung von /.git/info/exclude(bevorzugt) ODER einer bereits vorhandenen .gitignore in allen Commits, deren Dateien ignoriert / vergessen werden müssen. ¹

Alle Methoden zur Durchsetzung von Git ignorieren das Verhalten nachträglich, schreiben den Verlauf effektiv neu und haben daher erhebliche Auswirkungen auf alle öffentlichen / gemeinsam genutzten / kollaborativen Repos, die nach diesem Prozess möglicherweise abgerufen werden. ²

Allgemeiner Rat: Beginnen Sie mit einem sauberen Repo - alles festgeschrieben, nichts steht im Arbeitsverzeichnis oder Index aus, und erstellen Sie ein Backup !

Auch die Kommentare / Revisionsgeschichte von dieser Antwort ( und Revisionsgeschichte von dieser Frage ) kann nützlich sein / erleuchten.

#commit up-to-date .gitignore (if not already existing)
#this command must be run on each branch

git add .gitignore
git commit -m "Create .gitignore"

#apply standard git ignore behavior only to current index, not working directory (--cached)
#if this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist
#this command must be run on each branch

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

#Commit to prevent working directory data loss!
#this commit will be automatically deleted by the --prune-empty flag in the following command
#this command must be run on each branch

git commit -m "ignored index"

#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)
#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above
#This step will also delete any "empty" commits.  If deliberate "empty" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command

git filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all

#List all still-existing files that are now ignored properly
#if this command returns nothing, it's time to restore from backup and start over
#this command must be run on each branch

git ls-files --other --ignored --exclude-standard

Befolgen Sie abschließend den Rest dieses GitHub-Handbuchs (ab Schritt 6), das wichtige Warnungen / Informationen zu den folgenden Befehlen enthält .

git push origin --force --all
git push origin --force --tags
git for-each-ref --format="delete %(refname)" refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

Andere Entwickler, die aus dem jetzt modifizierten Remote-Repo ziehen, sollten ein Backup erstellen und dann:

#fetch modified remote

git fetch --all

#"Pull" changes WITHOUT deleting newly-ignored files from working directory
#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed

git reset FETCH_HEAD

Fußnoten

¹ Da /.git/info/excludemit den obigen Anweisungen auf alle historischen Commits angewendet werden kann, liegen Details zum Einfügen einer .gitignoreDatei in die historischen Commits, die sie benötigen , möglicherweise über den Rahmen dieser Antwort hinaus. Ich wollte, dass ein richtiger Mitarbeiter .gitignoreim Root-Commit ist, als wäre es das erste, was ich getan habe. Anderen ist es vielleicht egal, da /.git/info/excludesie das Gleiche erreichen können, unabhängig davon, wo sie .gitignorein der Festschreibungshistorie vorhanden sind, und das klare Umschreiben der Historie ist ein sehr heikles Thema, selbst wenn sie sich der Auswirkungen bewusst sind .

FWIW können potenzielle Methoden enthalten git rebaseoder eine git filter-branch, die ein externes .gitignore in jedes Commit kopiert , wie die Antworten auf diese Frage

^{2 Das} Erzwingen des nachträglichen Ignorierens von Git durch Festschreiben der Ergebnisse eines eigenständigen git rm --cachedBefehls kann dazu führen, dass neu ignorierte Dateien in zukünftigen Abrufen von der erzwungenen Fernbedienung gelöscht werden . Das --prune-emptyFlag im folgenden git filter-branchBefehl vermeidet dieses Problem, indem das vorherige Nur-Index-Commit "Alle ignorierten Dateien löschen" automatisch entfernt wird. Durch das Umschreiben des Git-Verlaufs werden auch Commit-Hashes geändert, was bei zukünftigen Abrufen von öffentlichen / gemeinsam genutzten / kollaborativen Repos zu Chaos führen wird . Bitte verstehen Sie die Auswirkungen vollständig, bevor Sie dies für ein solches Repo tun. In diesem GitHub-Handbuch wird Folgendes angegeben:

Weisen Sie Ihre Mitarbeiter an , alle Zweige, die sie aus Ihrem alten (fehlerhaften) Repository-Verlauf erstellt haben, neu zu gründen und nicht zusammenzuführen. Ein Zusammenführungs-Commit könnte einen Teil oder die gesamte verdorbene Geschichte wieder einführen, die Sie gerade mit dem Löschen begonnen haben.

Alternative Lösungen, die das Remote-Repo nicht beeinflussen, sind git update-index --assume-unchanged </path/file>oder git update-index --skip-worktree <file>, Beispiele hierfür finden Sie hier .

Wenn jemand unter Windows Schwierigkeiten hat und Sie den gesamten Ordner ignorieren möchten, wählen Sie "cd", um den "Ordner" zu erhalten, und führen Sie "Git Bash Here" aus.

git ls-files -z | xargs -0 git update-index --assume-unchanged

In meinem Fall hatte ich mehrere .lock-Dateien in mehreren Verzeichnissen, die ich entfernen musste. Ich habe Folgendes ausgeführt und es hat funktioniert, ohne in jedes Verzeichnis gehen zu müssen, um sie zu entfernen:

git rm -r --cached **/*.lock

Dies ging in jeden Ordner unter dem Stammverzeichnis, in dem ich mich befand, und schloss alle Dateien aus, die dem Muster entsprachen.

Hoffe das hilft anderen!