Dateien aus Git-Repositories entfernen, ohne dein Projekt zu zerschießen

Dateien in Git zu entfernen, ist nicht immer so simpel, wie es klingt. Du löschst eine Datei auf deinem System, aber damit ist sie nicht automatisch aus dem Repository verschwunden. Sie kann weiterhin in der Historie existieren oder schlimmer noch versehentlich erneut committed werden, etwa eine Config-Datei oder ein API-Schlüssel.

In diesem Guide lernst du, wie du Dateien in Git entfernst. Wir starten mit Basisbefehlen wie git rm und gehen dann zu fortgeschrittenen Methoden über, etwa zum Aufräumen unversionierter Dateien und zum Bearbeiten deiner Commit-Historie.

Voraussetzungen

Bevor wir mit Git Dateien entfernen, stellen wir sicher, dass alles eingerichtet ist.

Prüfe zunächst, ob Git installiert ist. Öffne dein Terminal und führe aus:

git --versionBereitgestellt von

Wenn eine Versionsnummer erscheint, kannst du loslegen. 

Wenn eine Versionsnummer erscheint, kannst du loslegen.

Wenn du lieber visuell arbeitest, kannst du auch ein Git-GUI wie GitHub Desktop, Sourcetree oder GitKraken installieren. In diesem Guide nutze ich jedoch die Kommandozeile (Git Bash).

Stelle sicher, dass du Berechtigungen für Änderungen im Repository hast, besonders wenn du im Team arbeitest oder mit einem Remote-Repo wie GitHub oder GitLab.

Hinweis: Manche Löschaktionen lassen sich nicht rückgängig machen. Es ist daher sinnvoll, dein Projekt zu sichern oder zumindest den Status deines Repos doppelt zu prüfen, bevor du Befehle ausführst, die Dateien löschen.

Wenn das passt, legen wir los.

Dateien in Git grundlegend entfernen

Es gibt verschiedene Wege, Dateien in Git zu entfernen, je nach Ziel. Hier sind gängige Optionen:

Mit git rm

Der Befehl git rm entfernt Dateien aus deinem Git-Repository. Beim Ausführen passieren zwei Dinge:

• Git entfernt die Datei aus deinem Working Directory
• Die Änderung wird für den nächsten Commit vorgemerkt (gestaged)

Git löscht die Datei also nicht nur. Die Löschung wird in der Historie nachverfolgt. Sobald du committest, ist die Datei offiziell aus dem Projekt entfernt.

git rm file1.txtBereitgestellt von

Du kannst eine Datei, mehrere Dateien oder eine Gruppe per Wildcard entfernen. 

Beispiel: Alle Logdateien entfernen:

git rm *.logBereitgestellt von

Damit weist du Git an, jede Datei im Ordner zu entfernen, die auf .log endet. Prüfe die Änderung mit:

git statusBereitgestellt von

Mehrere Dateien mit einem einzigen git rm löschen. Bild: Autorin.

Du willst alle Dateien in einem Ordner löschen, aber den Ordner behalten? Nutze:

git rm temp/*Bereitgestellt von

Das löscht jede Datei im Ordner temp, ohne den Ordner selbst zu löschen.

Git schützt dich zusätzlich: Wenn eine Datei uncommittete Änderungen hat, löscht Git sie nicht, außer du erzwingst es. Nutze das nur, wenn du sicher bist, dass die Änderungen verworfen werden können:

git rm -fBereitgestellt von

Um einen kompletten Ordner samt Inhalt zu entfernen, füge das Flag -r hinzu:

git rm -r testfolderBereitgestellt von

Dadurch werden testfolder und alle enthaltenen Dateien entfernt.

Um die Änderung zu committen, führe aus:

git commit -m "removed log files”Bereitgestellt von

Wichtige Optionen für git rm

Das sind die häufigsten Optionen, die du mit git rm verwenden wirst:

1. <filename>

Die Basisvariante: Liste die Dateien auf, die du entfernen willst:

git rm file1.txt file2.txtBereitgestellt von

Du kannst auch Wildcards nutzen, um mehrere Dateien gleichen Typs zu löschen. Zum Beispiel alle .txt-Dateien:

git rm *.txtBereitgestellt von

(Hier bedeutet * „alle“. Es passt auf jeden Dateinamen, der auf .txt endet.)

2. --cached

Damit entfernst du die Datei aus dem Repository, behältst sie aber lokal. Angenommen, ich habe versehentlich eine sensible Datei wie config.env hinzugefügt. Ich will sie nicht im Repo, brauche sie aber lokal. Dann würde ich ausführen:

git rm --cached config.envBereitgestellt von

Standardmäßig löscht git rm aus Repository und Working Directory. --cached entfernt die Datei nur aus der Nachverfolgung (sie wird nicht gepusht), belässt sie aber physisch auf deinem Rechner.

Damit sie nicht wieder hinzugefügt wird, füge sie zu .gitignore hinzu:

echo config.env >> .gitignoreBereitgestellt von

3. -r

Steht für rekursiv. Statt nur einer Datei wird das Verzeichnis mitsamt Inhalt rekursiv gelöscht. Ohne diese Option gibt Git einen Fehler aus, wenn du einen Ordner entfernen willst.

git rm -r <folder-name>Bereitgestellt von

Hier habe ich einen Ordner namens testfolder und zwei Dateien darin erstellt: a.txt und b.txt. Anschließend führe ich Folgendes aus:

git rm -r testfolderBereitgestellt von

Dadurch wurde der Ordner mitsamt allen enthaltenen Dateien gelöscht.

4. --dry-run

Wenn du unsicher bist, was beim Entfernen passiert, nutze git rm mit der Option --dry-run so:

git rm --dry-run <filename>Bereitgestellt von

So kannst du sicher vorab prüfen, was gelöscht würde. 

Oder wenn du unversionierte Dateien aufräumen willst und vorher prüfen möchtest, was gelöscht wird, nutze:

git clean -nBereitgestellt von

Das zeigt nur an, was dieser Befehl löschen würde.

Vergleich von Workflows

Es gibt mehr als einen Weg, eine Datei in Git zu entfernen. Die Methoden wirken ähnlich, verhalten sich aber unterschiedlich.

git rm vs. manuelles Löschen

Nehmen wir eine Datei namens file.txt. Angenommen, ich brauche sie nicht mehr.

Eine Möglichkeit ist, sie direkt im System zu löschen.

Unter Linux, macOS oder Git Bash:

rm file.txtBereitgestellt von

Unter Windows (Eingabeaufforderung): 

del file.txtBereitgestellt von

Das löscht die Datei aus deinem Ordner. Git weiß davon aber noch nichts. Du musst Git also manuell mitteilen, dass die Datei entfernt wurde:

git add file.txtBereitgestellt von

Damit wird die Löschung gestaged, sodass sie im nächsten Commit enthalten ist.

Wenn du mehrere Dateien gelöscht hast und nicht mehr genau weißt, welche, kannst du ausführen:

git add -uBereitgestellt von

Damit werden alle getrackten, geänderten oder gelöschten Dateien gestaged. Ungetrackte Dateien sind nicht enthalten.

Jetzt committest du die Änderung:

git commit -m "Remove file.txt"Bereitgestellt von

Wenn du git rm nutzt, erledigt es alles in einem Schritt. Die Datei wird gelöscht und die Änderung sofort gestaged:

git rm file.txtgit commit -m "Remove file.txt"Bereitgestellt von

Du musst git add nicht separat ausführen. Das ist sauberer und du vergisst nicht, die Löschung zu stagen.

Kurz gesagt:

• Manuelles Löschen erfordert zusätzliche Schritte, damit Git die Änderung erkennt.
• Wenn du vergisst, die Löschung zu stagen, denkt Git weiterhin, dass die Datei existiert – das führt zu Verwirrung bei Commits oder Merges.
• git rm ist sauberer und sicherer, wenn du getrackte Dateien gezielt entfernst.

Gelöschte Dateien in Git wiederherstellen

Was, wenn du eine Datei löschst und später merkst, dass du sie noch brauchst? Kein Problem. Git bietet mehrere Wege, sie wiederherzustellen – je nachdem, wann dir der Fehler auffällt.

Wenn du noch nicht committet hast:

Angenommen, du hast die Datei gelöscht, aber den Commit noch nicht gemacht. Dann kannst du sie aus dem letzten Commit so wiederherstellen: 

git restore file.txtBereitgestellt von

Damit holst du die Datei aus dem letzten Commit zurück in dein Working Directory.

Wenn du die Löschung bereits committed hast:

Auch okay. Finde zunächst den letzten Commit, in dem die Datei noch existierte:

git log -- file.txtBereitgestellt von

Gehe das Log durch und kopiere den Commit-Hash, in dem die Datei noch vorhanden war. Führe dann aus:

git checkout <commit hash> -- file.txtBereitgestellt von

In älteren Git-Versionen konntest du den obigen Befehl nutzen. Er stellt eine Datei aus einem bestimmten Commit wieder her, kann aber auch Branches wechseln.

Seit Git 2.23 wurde das in zwei klarere Befehle aufgeteilt:

• git switch (zum Wechseln von Branches)
• git restore (zum Wiederherstellen von Dateien)

Wenn du nur eine Datei aus einem Commit zurückholen willst, nutze:

git restore --source=<commit-hash> --file.txtBereitgestellt von

Das holt die Datei aus diesem Commit zurück in dein Working Directory.

Wenn du nicht weißt, wann die Datei gelöscht wurde:

Vielleicht hast du viele Änderungen gemacht und weißt nicht mehr, wann die Datei verschwunden ist. Dann hilft git reflog (Reference Log): 

git reflogBereitgestellt von

Das zeigt die komplette Historie deiner Git-Commits, Checkouts, Resets und mehr.

Achtung: git reflog ist nur lokal und funktioniert nicht für Remotes. Wenn du mit einem Remote-Repo arbeitest, nutze besser git log -- file.txt, um die Dateihistorie zu verfolgen.

Sobald du den Punkt findest, an dem die Datei noch existierte, stelle sie wie oben mit git checkout oder git restore wieder her.

Fehlende Dateien in Git beheben

Manchmal werden Dateien direkt im System gelöscht – z. B. über den Dateimanager, einen Terminal-rm-Befehl oder schlicht aus Versehen. Git räumt dann nicht automatisch auf. Stattdessen markiert es diese Dateien als fehlend und wartet darauf, dass du die Entfernung korrekt verarbeitest.

So gehst du Schritt für Schritt vor.

Schritt 1: Auf fehlende Dateien prüfen

Führe in deinem Projektordner aus:

git statusBereitgestellt von

Wenn Git angibt, dass eine Datei gelöscht wurde, ist sie zwar vom System verschwunden, die Änderung aber noch nicht gestaged.

Schritt 2: Löschung stagen 

Um Git alle Änderungen (inkl. gelöschter Dateien) mitzuteilen, führe aus:

git add -ABereitgestellt von

• git add -A = alle Änderungen stagen (neu, geändert, gelöscht).
• git add -u = geändert + gelöscht stagen, aber keine neuen Dateien.

Damit werden alle Dateiänderungen gestaged: neue, geänderte und gelöschte. Danach committen:

git commit -m "Removed missing files"Bereitgestellt von

So räumst du am sichersten auf, weil alle Änderungen in einem Rutsch erfasst werden.

Schritt 3: In das Remote pushen 

Wenn du mit einem Remote-Repository arbeitest, pushe den Commit:

git push origin <branch-name>Bereitgestellt von

Schritt 4: Alternative

Angenommen, du hast viele Dateien manuell gelöscht, aus Versehen oder beim Aufräumen. Git denkt weiterhin, dass diese Dateien existieren, bis du es anders sagst.

Wenn du nicht jede einzeln mit git rm entfernen willst, gibt es eine schnellere Aufräummethode.

Führe im Terminal aus:

git ls-files --deleted -z | xargs -0 git rmBereitgestellt von

Das passiert dabei:

• git ls-files --deleted listet alle Dateien auf, die Git trackt, die aber auf deiner Disk fehlen.
• xargs -0 git rm übergibt diese Dateinamen an git rm und entfernt sie aus dem Index.

Das ist sehr hilfreich in großen Projekten, wenn du schnell aufräumen willst.

Hinweis: Diese Meldung erscheint, weil es derzeit keine getrackten Dateien gibt, die auf deiner Festplatte fehlen.

Fortgeschrittenes Entfernen von Dateien in Git

Nachdem wir die Grundlagen abgedeckt haben, schauen wir auf komplexere Situationen, in denen das Entfernen einer Datei nicht so einfach wie git rm ist. Etwa wenn sensible Daten im Spiel sind oder ungetrackte Dateien sorgfältig bereinigt werden müssen.

Sensible Daten aus Git entfernen

Manchmal wird versehentlich eine Datei mit vertraulichen Daten wie API-Keys oder Passwörtern committed. Ein normales Löschen hilft dann nicht. Da Git die komplette Historie speichert, existiert die Datei weiterhin in früheren Commits.

Um sie vollständig zu entfernen, kannst du git filter-repo verwenden: git filter-repo (empfohlen)

Das ist die modernere, bessere Alternative zu filter-branch – schneller, sicherer und einfacher.

Installiere es zuerst (du brauchst Python und pip):

pip install git-filter-repoBereitgestellt von

Dann führe aus:

git filter-repo --path hide.txt --invert-pathsBereitgestellt von

Damit wird die Datei hide.txt aus jedem Commit in der Repo-Historie entfernt.

Zur Bestätigung führe aus:

git log --all -- supersecrets.txtBereitgestellt von

Wenn die Datei verschwunden ist, füge sie zu .gitignore hinzu, damit sie nicht wieder getrackt wird:

echo hide.txt >> .gitignoreBereitgestellt von

Wenn du im Team arbeitest, bereinige die umgeschriebene Historie und force-pushe die Änderungen:

git push origin --force --allBereitgestellt von

Informiere anschließend dein Team. Sie müssen neu klonen oder ihre lokalen Kopien zurücksetzen, um Fehler zu vermeiden.

Ungetrackte Dateien mit git clean aufräumen

Kurz zur Einordnung:

• Getrackte Dateien sind in der Git-Historie. Zum Entfernen nutze git rm und committe.
• Ungetrackte Dateien sind Git unbekannt. Sie sammeln sich an und vermüllen dein Projekt.

Um ungetrackte Dateien oder Ordner zu löschen, nutze git clean.

Die nützlichsten Optionen:

git clean -n     # Zeigt, welche ungetrackten Dateien entfernt würdengit clean -nd    # Zeigt, welche ungetrackten Ordner entfernt würdengit clean -fd    # Löscht alle ungetrackten Dateien und Ordner. Destruktiv.Bereitgestellt von

Dabei gilt:

• -n bedeutet nur Vorschau.
• -f bedeutet hartes Löschen.
• -d bezieht Ordner in die Bereinigung ein.

Hinweis: git clean fasst getrackte Dateien nicht an. Es löscht aber alles Ungetrackte – auch Dateien, die du vielleicht behalten wolltest. Nutze daher immer erst -n, um zu sehen, was entfernt würde.

Dateien in GitHub & GUI-Tools entfernen

Bisher haben wir die Kommandozeile genutzt. Aber nicht alle arbeiten so, und das ist völlig okay. Manche Entwickler nutzen visuelle Tools direkt in GitHub.

Schauen wir uns an, wie das Löschen in der GitHub-Weboberfläche und in anderen GUI-Tools funktioniert – und wie das im Vergleich zur Kommandozeile aussieht.

Dateien auf der GitHub-Website löschen

Wenn du im Browser auf GitHub arbeitest, kannst du Dateien ohne Terminal löschen.

So funktioniert es in der 2025er Oberfläche:

1. Öffne die zu löschende Datei.
2. Klicke oben rechts auf die drei Punkte.
3. Wähle im Dropdown „Delete file“.

GitHub zeigt dir dann ein Feld für die Commit-Nachricht. Füge eine kurze Nachricht hinzu wie:

Delete practice.pyBereitgestellt von

Du kannst optional eine Beschreibung ergänzen.

Wähle dann, wie die Änderung gespeichert wird:

• Direkt in den Branch main committen
• Oder einen neuen Branch anlegen und einen Pull Request starten (empfohlen für Team-Workflows)

Klicke auf Commit changes, und GitHub entfernt die Datei und speichert die Löschung als Commit – genau wie git rm an der Kommandozeile.

Dateien mit Git-GUI-Tools löschen

Wenn du ein Git-GUI wie GitHub Desktop, Sourcetree oder Tower nutzt, ist der Ablauf ebenso einfach:

1. Lösche die Datei im Dateimanager oder in der App.
2. Die App zeigt die Löschung unter „Changes“ oder „File Status“.
3. Prüfe, stage und committe die Änderung.

Die Oberflächen unterscheiden sich leicht, aber der Workflow ist ähnlich: Du verfolgst Änderungen visuell und commitest, wenn du bereit bist.

Best Practices je Plattform

So funktioniert das Löschen über verschiedene Plattformen – und wofür sie sich am besten eignen:

• GitHub (Web): Gut für schnelle Fixes und kleine Updates. Für große Aufräumarbeiten oder sensible Dateien eher meiden. 
• Git-GUI-Tools: Ideal für den Alltag. Änderungen sind leicht einsehbar und sicher zu committen. 
• Kommandozeile: Am flexibelsten und mächtigsten. Optimal für fortgeschrittene Aufgaben wie Massenänderungen oder Historie-Neuschreibungen. 

Best Practices zum Entfernen von Dateien in Git

Dateien in Git zu entfernen wirkt simpel, aber ein falscher Schritt kann deinen Code brechen. Hier sind ein paar praxisnahe Tipps, mit denen ich Löschungen sicher und kontrolliert halte – besonders in gemeinsamen oder langfristigen Projekten.

Vor dem Löschen immer prüfen

Bevor du eine Datei entfernst, nimm dir eine Minute für die Prüfung:

• Führe git status aus, um zu sehen, ob sie gestaged oder geändert ist.
• Nutze git log -- <filename>, um die Commit-Historie der Datei zu prüfen.

Dieser kurze Check spart später oft Stunden an Wiederherstellung.

Atomare Commits nutzen

Ein atomarer Commit bedeutet: ein Commit pro logischer Änderung.

Wenn ich z. B. ungenutzte Dateien lösche, committe ich nur diese Löschungen – getrennt von Codeänderungen.

Das ist hilfreich, weil:

• Debugging leichter wird. Tools wie git bisect funktionieren besser, wenn Commits klein und fokussiert sind.
• Die Commit-Historie sauber und verständlich bleibt.
• Code-Reviews schneller gehen.

Bei History-Rewrites im Team sorgfältig vorgehen

Das Umschreiben der Historie mit Tools wie git filter-repo betrifft alle im Team. Um Chaos zu vermeiden:

• Kommuniziere, bevor du gemeinsame Branches umschreibst.
• Nutze git push --force mit Bedacht, da damit die Remote-Historie neu geschrieben wird.
• Bitte dein Team, die lokalen Repos neu zu klonen oder zurückzusetzen.

--dry-run vor destruktiven Befehlen einsetzen

Bevor du einen Befehl ausführst, der Dateien löscht, teste ihn:

git clean -nBereitgestellt von

Das zeigt, was gelöscht würde, ohne etwas zu löschen. Ich empfehle das immer, weil: 

• Du vermeidest, versehentlich wichtige Dateien zu entfernen.
• Es ist ein Sicherheitsnetz – besonders in großen Projekten, wo ein Fehler Logs oder generierte Dateien wegputzen könnte.

git rm --cached mit .gitignore kombinieren

Wenn du etwas versehentlich committed hast, das nicht ins Repo gehört (z. B. eine Config-Datei oder Logs), behebe das in zwei Schritten:

1. Tracking beenden:```git rm --cached <filename>

git rm --cached <filename>Bereitgestellt von

Damit sagst du Git, die Datei nicht mehr zu tracken – lokal bleibt sie erhalten.

1. Zu .gitignore hinzufügen:

echo <filename> >> .gitignoreBereitgestellt von

Warum das hilft:

• Hält sensible oder lokale Dateien (z. B. .env, .log oder node_modules) aus dem Repo heraus.
• Verhindert Müll in deiner Git-Historie.
• Zukünftige Änderungen an diesen Dateien lösen keine Git-Änderungen mehr aus.

Git-Sonderfälle: Staging & leere Ordner

Manchmal läuft das Entfernen nicht wie erwartet. Du staget versehentlich die falsche Datei oder stößt auf Probleme mit leeren Ordnern. 

So gehe ich mit typischen Edge Cases um.

Datei entstagen, ohne Änderungen zu verlieren

Angenommen, ich habe git add . ausgeführt und dabei versehentlich eine Datei gestaged. Ich will die Änderungen behalten – nur das Staging rückgängig machen.

Dafür nutze ich:

git reset HEAD <filename>Bereitgestellt von

Das entfernt die Datei aus dem Staging-Bereich, belässt aber die lokalen Änderungen.

Zur Kontrolle nutze ich:

git statusBereitgestellt von

Jetzt sollte die Datei als „modified“ statt „staged“ erscheinen.

Leere Ordner im Repo behalten

Standardmäßig ignoriert Git leere Ordner. Versuchst du, einen leeren Ordner zu committen, überspringt Git ihn.

Manchmal willst du den Ordner aber behalten, etwa für künftige Logs oder Uploads. Der übliche Trick: eine Platzhalterdatei .gitkeep.

So geht’s:

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"Bereitgestellt von

Damit ist der Ordner „nicht leer“ und wird von Git getrackt.

Hinweis: .gitkeep ist kein Git-Feature, sondern eine Konvention. Du kannst die Datei beliebig nennen – .gitkeep macht anderen klar, wofür sie da ist.

Troubleshooting beim Entfernen von Dateien

Hier sind ein paar häufige Probleme beim Entfernen von Dateien in Git – und wie du sie löst.

Die Datei erscheint weiterhin im Remote-Repository

Du hast die Datei gelöscht und committed, aber sie ist im Remote noch sichtbar. Vielleicht hast du das Pushen vergessen.

Stelle also sicher, dass du ausführst:

git push origin <branch-name>Bereitgestellt von

Prüfe außerdem:

• Bist du auf dem richtigen Branch?
• Hat dein Commit die Löschung tatsächlich enthalten?

Probleme mit Submodulen

Submodule sind Git-Repos in anderen Git-Repos. Sie verhalten sich nicht wie normale Ordner.

Wenn du Dateien in einem Submodul löschst:

• Wechsle in den Submodul-Ordner
• Committe und pushe die Änderungen innerhalb des Submoduls

Wenn du das Submodul komplett entfernst:

• Lösche den Submodul-Ordner
• Entferne Referenzen in .gitmodules und .git/config

Detached-HEAD-Zustand

In Git zeigt HEAD normalerweise auf den aktuellen Branch. Manchmal zeigt es aber auf einen bestimmten Commit – das nennt sich Detached HEAD.

Das passiert, wenn du:

• Einen Commit per Hash auscheckst
• Auf einen Tag wechselst
• Einen Remote-Branch auscheckst, ohne ihn zu tracken

Prüfe deinen Status:

git statusBereitgestellt von

Wenn du siehst:

HEAD detached at <commit-hash>Bereitgestellt von

Du bist auf keinem Branch, und neue Änderungen können verloren gehen, wenn du wegwechselst.

So behebst du das: 

Wenn du Änderungen gemacht hast und sie behalten willst, führe aus:

git checkout -b <new-branch-name>Bereitgestellt von

Damit legst du deine Arbeit auf einen neuen Branch und sicherst sie.

Wenn du bereits committed hast und die Änderungen später auf einen anderen Branch verschieben willst, mache Folgendes:

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branchBereitgestellt von

Wenn du keine Änderungen gemacht hast und nur aus dem Detached-HEAD raus willst, führe aus:

git checkout <branch-name> Bereitgestellt von

Fertig. Dein HEAD ist wieder verbunden und alles ist normal.

Berechtigungs- oder Statusfehler

Manchmal löscht Git eine Datei nicht – häufig unter Windows. Das kann passieren, wenn:

• Die Datei in einem anderen Programm geöffnet ist
• Git keine Berechtigung zur Änderung hat

So behebst du das:

• Schließe alle Apps, die die Datei verwenden
• Starte dein Terminal als Administrator (unter Windows)

Merge- oder Rebase-Probleme

Wenn du Fehlermeldungen siehst wie:

• you are not currently on a branch
• merge conflict

Bist du vermutlich mitten in einem Merge oder Rebase.

Um ein Rebase nach dem Lösen von Konflikten fortzusetzen:

git rebase --continueBereitgestellt von

Um Rebase oder Merge komplett abzubrechen:

git reset --mergeBereitgestellt von

Damit stellst du dein Repo auf den Zustand vor dem Merge zurück.

Willst du alle lokalen Änderungen verwerfen und dein Working Directory zurücksetzen? 

Probiere das:

git restore .Bereitgestellt von

Damit setzt du alle Dateien auf den letzten Commit zurück.

Fazit 

Beim Entfernen von Dateien in Git ist ein Fehler schnell passiert. Eine kleine Unachtsamkeit kann größere Probleme auslösen: kaputter Code, verlorene Arbeit oder Verwirrung im Team. Nimm dir daher einen Moment für einen Doppelcheck.

Nutze je nach Situation den passenden Befehl. Wenn du unsicher bist, probiere erst einen Dry-Run. Und wenn du im Team arbeitest, sorge dafür, dass alle auf dem gleichen Stand sind.

Git kann weit mehr, als Dateien zu löschen. Du kannst Branches löschen,  Fehler mit reset und revert rückgängig machen oder mit git diff genau sehen, was sich geändert hat. Je mehr du lernst, desto reibungsloser wird dein Workflow.

Geh Schritt für Schritt vor. So wirst du in dem Thema richtig gut.