Wie mache ich "git add" vor dem Festschreiben rückgängig?

Ich habe Git fälschlicherweise mit dem folgenden Befehl Dateien hinzugefügt:

git add myfile.txt

Ich bin noch nicht gelaufen git commit. Gibt es eine Möglichkeit, dies rückgängig zu machen, damit diese Dateien nicht in das Commit aufgenommen werden?

Sie können rückgängig machen, git addbevor Sie mit festschreiben

git reset <file>

Dadurch wird es aus dem aktuellen Index (der Liste "In Kürze festgeschrieben") entfernt, ohne dass etwas anderes geändert wird.

Sie können verwenden

git reset

ohne Dateinamen, um alle fälligen Änderungen aufzuheben. Dies kann nützlich sein, wenn zu viele Dateien vorhanden sind, um in angemessener Zeit einzeln aufgelistet zu werden.

In alten Versionen von Git, sind die oben genannten Befehle gleichwertig git reset HEAD <file>und git reset HEADjeweils und werden scheitern , wenn HEADnicht definiert ist (weil Sie haben noch keine Commits in Ihrem Repository gemacht) oder mehrdeutig (weil Sie einen Zweig namens geschaffen HEAD, die eine dumme Sache ist das solltest du nicht tun). Dies wurde jedoch in Git 1.8.2 geändert , sodass Sie in modernen Versionen von Git die obigen Befehle bereits vor dem ersten Festschreiben verwenden können:

"git reset" (ohne Optionen oder Parameter) wird verwendet, um Fehler zu verursachen, wenn Sie keine Commits in Ihrem Verlauf haben, aber es gibt Ihnen jetzt einen leeren Index (um nicht existierenden Commits zu entsprechen, bei denen Sie noch nicht einmal sind).

Sie wollen:

git rm --cached <added_file_to_undo>

Argumentation:

Als ich neu darin war, habe ich es zuerst versucht

git reset .

(um mein gesamtes anfängliches Hinzufügen rückgängig zu machen), nur um diese (nicht so) hilfreiche Nachricht zu erhalten:

fatal: Failed to resolve 'HEAD' as a valid ref.

Es stellt sich heraus, dass dies daran liegt, dass der HEAD-Verweis (Zweig?) Erst nach dem ersten Festschreiben vorhanden ist. Das heißt, Sie werden auf dasselbe Anfängerproblem stoßen wie ich, wenn Ihr Workflow wie meiner so etwas wie:

1. CD in mein tolles neues Projektverzeichnis, um Git, die neue Hotness, auszuprobieren
2. git init
3. git add .

4. git status

   ... viele Mistrollen von ...

   => Verdammt, ich wollte das alles nicht hinzufügen.

5. google "git add rückgängig machen"

   => Stapelüberlauf finden - yay

6. git reset .

   => fatal: Fehler beim Auflösen von 'HEAD' als gültige Referenz.

Es stellt sich ferner heraus, dass in der Mailingliste ein Fehler protokolliert wurde, der gegen die Nicht-Hilfbarkeit dieses Fehlers protokolliert wurde .

Und dass die richtige Lösung genau dort in der Git-Statusausgabe war (was ich ja als 'Mist' beschönigt habe)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

Und die Lösung ist in der Tat zu verwenden git rm --cached FILE.

Beachten Sie die Warnungen an anderer Stelle hier - git rmlöscht Ihre lokale Arbeitskopie der Datei, jedoch nicht, wenn Sie --cached verwenden . Hier ist das Ergebnis von git help rm:

--cached Verwenden Sie diese Option, um Pfade zu entfernen und nur aus dem Index zu entfernen. Arbeitsbaumdateien, ob geändert oder nicht, bleiben erhalten.

Ich fahre fort zu benutzen

git rm --cached .

alles entfernen und neu starten. Hat aber nicht funktioniert, denn während add .es rekursiv ist, stellt sich heraus , dass es rekursiv sein rmmuss -r. Seufzer.

git rm -r --cached .

Okay, jetzt bin ich wieder da, wo ich angefangen habe. Das nächste Mal werde ich -neinen Probelauf machen und sehen, was hinzugefügt wird:

git add -n .

Ich gezippt alles an einen sicheren Ort, bevor im Vertrauen git help rmüber die --cachednicht zu zerstören alles (und was ist, wenn ich es falsch geschrieben).

Wenn Sie Folgendes eingeben:

git status

Git wird Ihnen sagen, was inszeniert wird usw., einschließlich Anweisungen zum Aufheben der Bühne:

use "git reset HEAD <file>..." to unstage

Ich finde, Git macht einen ziemlich guten Job und stupst mich an, in solchen Situationen das Richtige zu tun.

Hinweis: Neuere Git-Versionen (1.8.4.x) haben diese Meldung geändert:

(use "git rm --cached <file>..." to unstage)

Zur Verdeutlichung: git addVerschiebt Änderungen aus dem aktuellen Arbeitsverzeichnis in den Staging-Bereich (Index).

Dieser Vorgang wird als Staging bezeichnet . Der natürlichste Befehl zum Bereitstellen der Änderungen (geänderte Dateien) ist also der offensichtliche:

git stage

git add ist nur ein einfacher zu tippender Alias ​​für git stage

Schade , es gibt keine git unstagenoch git unaddBefehle. Das relevante ist schwerer zu erraten oder zu merken, aber es ist ziemlich offensichtlich:

git reset HEAD --

Wir können dafür leicht einen Alias ​​erstellen:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

Und schließlich haben wir neue Befehle:

git add file1
git stage file2
git unadd file2
git unstage file1

Persönlich verwende ich noch kürzere Aliase:

git a # For staging
git u # For unstaging

Eine Ergänzung zur akzeptierten Antwort: Wenn Ihre versehentlich hinzugefügte Datei sehr groß war, werden Sie wahrscheinlich feststellen, dass sie auch nach dem Entfernen aus dem Index mit ' git reset' immer noch Speicherplatz im .gitVerzeichnis belegt.

Dies ist kein Grund zur Sorge; Die Datei befindet sich zwar noch im Repository, aber nur als "loses Objekt". Es wird nicht in andere Repositorys kopiert (per Klon, Push), und der Speicherplatz wird schließlich zurückgefordert - wenn auch möglicherweise nicht sehr bald. Wenn Sie Angst haben, können Sie laufen:

git gc --prune=now

Update (was folgt, ist mein Versuch, einige Verwirrungen zu beseitigen, die sich aus den am besten bewerteten Antworten ergeben können):

Also, was ist das wahre Rückgängigmachen von git add?

git reset HEAD <file> ?

oder

git rm --cached <file>?

Genau genommen, und wenn ich mich nicht irre: keine .

git add kann nicht rückgängig gemacht werden - sicher im Allgemeinen.

Erinnern wir uns zuerst daran, was git add <file>tatsächlich tut:

1. Wenn <file>wurde bisher nicht verfolgt , git add fügt sie den Cache , mit seinem aktuellen Inhalt.

2. Wenn <file>wurde bereits verfolgt , git add speichert den aktuellen Inhalt (Snapshot, Version) in den Cache. In Git wird diese Aktion immer noch als Hinzufügen bezeichnet (nicht nur als Aktualisierung ), da zwei verschiedene Versionen (Snapshots) einer Datei als zwei verschiedene Elemente betrachtet werden. Daher fügen wir dem Cache tatsächlich ein neues Element hinzu, um schließlich zu sein später begangen.

Vor diesem Hintergrund ist die Frage etwas mehrdeutig:

Ich habe fälschlicherweise Dateien mit dem Befehl hinzugefügt ...

Das OP-Szenario scheint das erste zu sein (nicht verfolgte Datei). Wir möchten, dass durch "Rückgängig" die Datei (nicht nur der aktuelle Inhalt) aus den verfolgten Elementen entfernt wird. Wenn dies der Fall ist, ist es in Ordnung zu laufen git rm --cached <file>.

Und wir könnten auch rennen git reset HEAD <file>. Dies ist im Allgemeinen vorzuziehen, da es in beiden Szenarien funktioniert: Es wird auch rückgängig gemacht, wenn wir fälschlicherweise eine Version eines bereits verfolgten Elements hinzugefügt haben.

Es gibt jedoch zwei Einschränkungen.

Erstens: Es gibt (wie in der Antwort ausgeführt) nur ein Szenario, in dem git reset HEADdies nicht funktioniert, aber git rm --cachedfunktioniert: ein neues Repository (keine Commits). Aber das ist wirklich ein praktisch irrelevanter Fall.

Zweitens: Beachten Sie, dass git reset HEAD der zuvor zwischengespeicherte Dateiinhalt nicht auf magische Weise wiederhergestellt werden kann, sondern nur vom HEAD neu synchronisiert wird. Wenn unser git addIrrtum eine zuvor bereitgestellte, nicht festgeschriebene Version überschrieben hat, können wir sie nicht wiederherstellen. Genau deshalb können wir [*] nicht rückgängig machen.

Beispiel:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # First add of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # Stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # Oops we didn't mean this
$ git reset HEAD file.txt  # Undo?
$ git diff --cached file.txt  # No dif, of course. stage == HEAD
$ git diff file.txt   # We have irrevocably lost "version 2"
-version 1
+version 3

Dies ist natürlich nicht sehr kritisch, wenn wir nur dem üblichen verzögerten Workflow folgen, bei dem 'git add' nur zum Hinzufügen neuer Dateien ausgeführt wird (Fall 1), und neue Inhalte über den git commit -aBefehl commit, aktualisieren .

^{* (Bearbeiten: Das oben Gesagte ist praktisch korrekt, aber es kann dennoch einige leicht hackige / verschlungene Möglichkeiten geben, Änderungen wiederherzustellen, die inszeniert, aber nicht festgeschrieben und dann überschrieben wurden - siehe die Kommentare von Johannes Matokic und iolsmit).}

Das Rückgängigmachen einer bereits hinzugefügten Datei ist mit Git ganz einfach. myfile.txtVerwenden Sie zum Zurücksetzen , die bereits hinzugefügt wurden, Folgendes:

git reset HEAD myfile.txt

Erläuterung:

Nachdem Sie unerwünschte Dateien bereitgestellt haben, können Sie dies rückgängig machen git reset. Headist der Kopf Ihrer Datei im lokalen und der letzte Parameter ist der Name Ihrer Datei.

Ich habe die Schritte im Bild unten detaillierter für Sie erstellt, einschließlich aller Schritte, die in diesen Fällen auftreten können:

git rm --cached . -r

wird alles, was Sie aus Ihrem aktuellen Verzeichnis hinzugefügt haben, rekursiv "entfernen"

Lauf

git gui

und entfernen Sie alle Dateien manuell oder indem Sie alle auswählen und auf die Schaltfläche "Unstage from Commit" klicken .

Git hat Befehle für jede erdenkliche Aktion, aber es benötigt umfangreiches Wissen, um die Dinge richtig zu machen, und aus diesem Grund ist es bestenfalls kontraintuitiv ...

Was du vorher gemacht hast:

• Eine Datei geändert und verwendet git add ., oder git add <file>.

Was du willst:

• Entfernen Sie die Datei aus dem Index, aber lassen Sie sie versioniert und lassen Sie nicht festgeschriebene Änderungen in der Arbeitskopie:

  git reset head <file>
  

• Setzen Sie die Datei von HEAD auf den letzten Status zurück, machen Sie Änderungen rückgängig und entfernen Sie sie aus dem Index:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>

  Dies ist erforderlich, da git reset --hard HEADes nicht mit einzelnen Dateien funktioniert.

• <file>Aus dem Index und der Versionierung entfernen und die nicht versionierte Datei mit Änderungen in der Arbeitskopie beibehalten:

  git rm --cached <file>
  

• <file>Aus der Arbeitskopie entfernen und vollständig versionieren:

  git rm <file>
  

Die Frage ist nicht klar gestellt. Der Grund ist, dass dies git addzwei Bedeutungen hat:

1. Hinzufügen einer neuen Datei zum Staging-Bereich, dann rückgängig machen mit git rm --cached file.
2. Hinzufügen einer geänderten Datei zum Staging-Bereich, dann rückgängig machen mit git reset HEAD file.

Im Zweifelsfall verwenden

git reset HEAD file

Weil es in beiden Fällen das Erwartete tut.

Warnung: Wenn Sie git rm --cached fileeine Datei bearbeiten, die geändert wurde (eine Datei, die zuvor im Repository vorhanden war), wird die Datei am entfernt git commit! Es ist weiterhin in Ihrem Dateisystem vorhanden, aber wenn jemand anderes Ihr Commit abruft, wird die Datei aus seinem Arbeitsbaum gelöscht.

git statuswird Ihnen sagen, ob die Datei eine neue Datei war oder geändert wurde :

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

Wenn Sie sich in Ihrem ersten Commit befinden und es nicht verwenden können git reset, melden Sie einfach "Git bankrott" und löschen Sie den .gitOrdner und beginnen Sie von vorne

Wie bei vielen anderen Antworten können Sie verwenden git reset

ABER:

Ich habe diesen tollen kleinen Beitrag gefunden, der tatsächlich den Git-Befehl ( naja , einen Alias) hinzufügt für git unadd: siehe git unadd für Details oder ..

Einfach,

git config --global alias.unadd "reset HEAD"

Jetzt kannst du

git unadd foo.txt bar.txt

Verwenden Sie git add -idiese Option , um gerade hinzugefügte Dateien aus Ihrem bevorstehenden Commit zu entfernen. Beispiel:

Hinzufügen der Datei, die Sie nicht wollten:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Gehen Sie zum interaktiven Hinzufügen, um Ihr Hinzufügen rückgängig zu machen (die hier bei git eingegebenen Befehle sind "r" (Zurücksetzen), "1" (erster Eintrag in der Liste "Zurücksetzen zeigt"), "Zurück", um den Wiederherstellungsmodus zu verlassen, und "q". (Verlassen):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

Das ist es! Hier ist Ihr Beweis, der zeigt, dass "foo" wieder auf der nicht verfolgten Liste steht:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

git removeoder git rmkann dafür mit der --cachedFlagge verwendet werden. Versuchen:

git help rm

So vermeiden Sie dieses ärgerliche Problem, wenn Sie ein neues Projekt starten:

• Erstellen Sie das Hauptverzeichnis für Ihr neues Projekt.
• Ausführen git init.
• Erstellen Sie nun eine Gitignore-Datei (auch wenn diese leer ist).
• Übernehmen Sie Ihre .gitignore-Datei.

Git macht es wirklich schwierig, git resetwenn Sie keine Commits haben. Wenn Sie ein winziges anfängliches Commit erstellen, nur um eines zu haben, können Sie danach git add -Aund git resetso oft Sie möchten, um alles richtig zu machen.

Ein weiterer Vorteil dieser Methode besteht darin, dass es einfach ist, wenn Sie später auf Probleme mit dem Zeilenende stoßen und alle Ihre Dateien aktualisieren müssen:

• Überprüfen Sie das anfängliche Commit. Dadurch werden alle Ihre Dateien entfernt.
• Überprüfen Sie dann erneut Ihr letztes Commit. Dadurch werden neue Kopien Ihrer Dateien unter Verwendung Ihrer aktuellen Einstellungen für das Zeilenende abgerufen.

Vielleicht hat sich Git weiterentwickelt, seit Sie Ihre Frage gestellt haben.

$> git --version
git version 1.6.2.1

Jetzt können Sie versuchen:

git reset HEAD .

Dies sollte das sein, wonach Sie suchen.

Beachten Sie, dass Sie ein Trennzeichen einfügen müssen, wenn Sie keine Revision angeben. Beispiel von meiner Konsole:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M    <path_to_file>

(Git Version 1.7.5.4)

So entfernen Sie neue Dateien aus dem Staging-Bereich (und nur im Falle einer neuen Datei), wie oben vorgeschlagen:

git rm --cached FILE

Verwenden Sie rm --cached nur für neue Dateien, die versehentlich hinzugefügt wurden.

Mit dem folgenden Befehl können Sie jede Datei in einem bestimmten Ordner (und seinen Unterordnern) zurücksetzen:

git reset *

Verwenden Sie den *Befehl, um mehrere Dateien gleichzeitig zu verarbeiten:

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

usw.

Geben git resetSie einfach ein, es wird zurückgesetzt und es ist, als hätten Sie git add .seit Ihrem letzten Commit nie mehr getippt . Stellen Sie sicher, dass Sie sich zuvor verpflichtet haben.

Angenommen, ich erstelle eine neue Datei newFile.txt:

Angenommen, ich füge die Datei versehentlich hinzu git add newFile.txt:

Jetzt möchte ich dieses Hinzufügen vor dem Festschreiben rückgängig machen git reset newFile.txt:

Für eine bestimmte Datei:

• git reset my_file.txt
• git checkout my_file.txt

Für alle hinzugefügten Dateien:

• Git zurücksetzen.
• Git Checkout.

Hinweis: Beim Auschecken wird der Code in den Dateien geändert und in den zuletzt aktualisierten (festgeschriebenen) Status versetzt. Durch das Zurücksetzen werden die Codes nicht geändert. es setzt nur den Header zurück.

Mit diesem Befehl werden Ihre Änderungen aufgehoben:

git reset HEAD filename.txt

Sie können auch verwenden

git add -p 

Teile von Dateien hinzufügen.

Es gibt auch einen interaktiven Modus:

git add -i

Wählen Sie Option 3, um das Hinzufügen von Dateien aufzuheben. In meinem Fall möchte ich oft mehr als eine Datei hinzufügen, und im interaktiven Modus können Sie Zahlen wie diese verwenden, um Dateien hinzuzufügen. Dies dauert bis auf 4: 1, 2, 3 und 5

Um eine Sequenz auszuwählen, geben Sie einfach 1-5 ein, um alle von 1 bis 5 zu übernehmen.

Git-Staging-Dateien

git addVerwenden Sie zum Rückgängigmachen :

git reset filename

git reset filename.txt

Entfernt eine Datei mit dem Namen filename.txt aus dem aktuellen Index, dem Bereich "kurz vor dem Festschreiben", ohne dass etwas anderes geändert wird.

git add myfile.txt # Dadurch wird Ihre Datei in die Liste der festzuschreibenden Dateien aufgenommen

Ganz im Gegenteil zu diesem Befehl ist,

git reset HEAD myfile.txt  # This will undo it.

Sie befinden sich also im vorherigen Status. Angegeben wird wieder in der nicht verfolgten Liste (vorheriger Status).

Es wird Ihren Kopf mit der angegebenen Datei zurücksetzen. Wenn Ihr Kopf keine Mittel hat, wird er einfach zurückgesetzt.

In Sourcetree können Sie dies einfach über die GUI tun. Sie können überprüfen, mit welchem ​​Befehl Sourcetree eine Datei entsorgt.

Ich habe eine neue Datei erstellt und sie zu Git hinzugefügt. Dann habe ich es über die Sourcetree-Benutzeroberfläche freigegeben. Das ist das Ergebnis:

Aufheben der Bereitstellung von Dateien [08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = Sourcetree-Reset -q - Pfad / zu / Datei / Dateiname.java

Sourcetree wird verwendet reset, um neue Dateien zu entfernen.

git reset filename.txt  

Entfernt eine Datei mit dem Namen filename.txt aus dem aktuellen Index, dem Bereich "kurz vor dem Festschreiben", ohne dass etwas anderes geändert wird.