Wie Rückgängig ‚git add‘ vor begehen?

https://stackoverflow.com/questions/348170

20-08-2019
|

Frage

ich versehentlich Dateien hinzugefügt mit dem Befehl git:

git add myfile.txt

Ich habe noch nicht git commit laufen. Gibt es eine Möglichkeit, dies rückgängig zu machen, so dass diese Dateien nicht in der Commit aufgenommen werden?

Lösung

Sie können git add rückgängig machen, bevor begehen mit

git reset <file>

, die es aus dem aktuellen Index entfernen wird (die „begangen werden soll“ -Liste) ohne sonst etwas zu ändern.

Sie können mit

git reset

ohne Dateinamen alle fälligen Änderungen unstage. Dies kann nützlich sein, wenn es zu viele Dateien sind eins nach dem anderen in einer angemessenen Höhe der Zeit aufgeführt werden.

In alten Versionen von Git, sind die oben genannten Befehle äquivalent zu git reset HEAD <file> und git reset HEAD ist, und werden scheitern, wenn HEAD nicht definiert ist (weil Sie haben noch keine Commits in Ihrem Repo gemacht) oder mehrdeutig (weil Sie einen Zweig erstellt genannt HEAD, die eine dumme Sache, die Sie nicht tun sollten). Diese wurde in Git 1.8 geändert. 2 , obwohl, so in modernen Versionen von Git Sie die Befehle oben sogar, bevor können Sie Ihre erste commit:

„git reset“ (ohne Optionen oder Parameter) verwendet, um Fehler aus, wenn Sie haben noch keine Commits in Ihrer Geschichte, aber es Ihnen jetzt gibt ein leerer Index (entspricht nicht existent begehen Sie sind nicht einmal auf).

Andere Tipps

Sie mögen:

git rm --cached <added_file_to_undo>

Begründung:

Als ich neu in dieser war, versuchte ich zuerst

git reset .

(meine gesamte anfängliche Add rückgängig zu machen), nur diese zu erhalten (nicht so) hilfreich Nachricht:

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

Es stellt sich heraus, dass dies, weil der Kopf ref (Zweig?), Bis nicht vorhanden ist, nachdem die erste begehen. Das heißt, Sie werden in den gleichen Anfänger Problem wie ich laufen, wenn Sie Ihren Workflow, wie meine, war so etwas wie:

cd zu meinem großen neuen Projektverzeichnis ausprobieren Git, das neue Hotness
git init
git add .
git status

... viel Mist blättert durch ...

=> Verdammt, ich wollte nicht, dass all das hinzuzufügen.
Google "rückgängig machen git add"

=> Stack-Überlauf finden - yay
git reset .

=> fatal. Fehlgeschlagen 'HEAD' als gültige ref zu lösen

Es stellt sich ferner heraus, dass es ein Fehler protokolliert gegen die unhelpfulness dies in der Mailing-Liste.

Und dass die richtige Lösung war direkt in dem Git Statusausgang (die, ja, ich als ‚Mist beschönigte)

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

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

die Warnungen Hinweis an anderer Stelle hier - git rm löscht Ihre lokale Arbeitskopie der Datei, aber nicht , wenn Sie mit - Im Cache . Hier ist das Ergebnis von git help rm:

- cached Mit dieser Option kann unstage und entfernen Pfade nur aus dem Index. Arbeitsbaumdateien, ob verändert oder nicht, wird gelassen werden.

Ich gehe zu verwenden

git rm --cached .

alles entfernen und wieder starten. obwohl nicht funktioniert, weil während add . rekursiv ist, stellt sich heraus, rm muss -r recurse. Seufz.

git rm -r --cached .

Okay, jetzt bin ich wieder da, wo ich angefangen habe. Beim nächsten Mal wird mich -n verwenden, um einen Trockenlauf zu tun und sehen, was hinzugefügt werden:

git add -n .

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

Wenn Sie ein:

git status

git werden Ihnen sagen, was ist inszeniert, usw., einschließlich Anweisungen zum unstage:

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

Ich finde git hat einen ziemlich guten Job mich über stupste das Richtige in Situationen wie diese zu tun.

Hinweis: Bei neueren Versionen git (1.8.4.x) hat diese Nachricht geändert:

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

Zur Klarstellung: git add bewegt sich Änderungen aus dem aktuellen Arbeitsverzeichnis in den Staging-Bereich (Index).

Dieser Prozess genannt wird Staging . So ist die natürlichste Befehl Bühne die Änderungen (geänderte Dateien) ist die offensichtlichste:

git stage

git add ist nur ein einfacher Typ alias für git stage

Schade, es gibt keine git unstage noch git unadd Befehle. Der relevante ein schwerer zu erraten oder denken Sie daran, aber ist ziemlich offensichtlich:

git reset HEAD --

Wir können leicht einen Aliasnamen für diese 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

Ich persönlich verwende noch kürzere Aliase:

git a #for staging
git u #for unstaging

Eine Ergänzung zu der Antwort akzeptiert, wenn Ihre irrtümlich hinzugefügte Datei riesig ist, werden Sie wahrscheinlich feststellen, dass, auch nachdem ihn aus dem Index mit ‚git reset‘ zu entfernen, so scheint es immer noch Platz im .git Verzeichnis zu besetzen. Das ist nichts über Sorgen zu machen, wird die Datei im Repository zwar noch, aber nur als „loose-Objekt“, wird es nicht zu anderen Repositories (via Klon, push) kopiert werden, und der Raum wird schließlich zurückgewonnen werden - obwohl vielleicht nicht sehr bald. Wenn Sie besorgt sind, können Sie ausführen:

git gc --prune=now

Update (was folgt, ist mein Versuch, einige Verwirrung zu löschen, die von den meisten up-gestimmt Antworten entstehen können):

So, das die reale ist Undo 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

Lassen Sie uns daran erinnern, was zuerst git add <file> tatsächlich tut:

Wenn <file> war bisher nicht verfolgt , git add fügt sie den Cache , mit seinem aktuellen Inhalt.
Wenn <file> war bereits aufgespürt , git add speichert den aktuellen Inhalt (Snapshot, Version) in den Cache. In GIT wird diese Aktion noch hinzufügen , (nicht nur update es) genannt, weil zwei verschiedene Versionen (Snapshots) eine Datei als zwei verschiedene Elemente betrachtet werden: also, fügen wir in der Tat ein neues Element in den Cache, um schließlich später begangen werden.

Vor diesem Hintergrund stellt sich die Frage etwas zweideutig:

ich irrtümlicherweise hinzugefügten Dateien mit dem Befehl ...

Das Szenario des OP scheint die erste (untracked-Datei) zu sein, wir die „rückgängig machen“ wollen die Datei (nicht nur die aktuellen Inhalte) von den verfolgten Elementen zu entfernen. Wenn dies der Fall ist, dann ist es ok git rm --cached <file> laufen.

Und wir könnten auch git reset HEAD <file> laufen. Dies ist im Allgemeinen bevorzugt, da es in beiden Szenarien funktioniert. Es tut auch die Undo, wenn wir fälschlicherweise eine Version eines bereits vorselektierten Elements hinzugefügt

Aber es gibt zwei Vorbehalte.

Erstens: Es gibt nur ein Szenario (wie in der Antwort darauf hingewiesen), in denen git reset HEAD nicht funktioniert, aber git rm --cached tut: ein neues Repository (keine Commits). Aber wirklich, das ist ein praktisch irrelevant Fall.

Zweitens: Beachten Sie, dass git reset HEAD nicht auf magische Weise die bereits im Cache-Datei Inhalte wiederherstellen, es Resyncs es nur aus dem Kopf. Wenn unsere fehlgeleiteten git add eine frühere Szene gesetzt ungebundenen Version überschrieben, können wir es nicht mehr erholen. Deshalb, streng genommen, 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 lost irrevocably "version 2"
-version 1
+version 3

Natürlich ist dies nicht sehr kritisch, wenn wir nur das übliche faul Workflow zu tun ‚git add‘ folgen nur für das Hinzufügen neue Dateien (Fall 1), und wir neue Inhalte über das Commit aktualisieren, git commit -a Befehl.

^{* (Edit: die oben ist praktisch richtig, aber noch kann es einige leicht hackish / verschlungene Wege zur Wiedergewinnung von Veränderungen, die aber nicht festgeschrieben und dann überschrieben Szene gesetzt wurden - siehe die Kommentare von Johannes Matokic und iolsmit)}

git rm --cached . -r

wird „un-add“ alles, was Sie von Ihrem aktuellen Verzeichnis hinzugefügt haben rekursiv

Rückgängig eine Datei, die bereits hinzugefügt ist ganz einfach mit git , für myfile.txt Zurücksetzen, die bereits hinzugefügt, zu verwenden:

git reset HEAD myfile.txt

Erklären Sie:

Nach dem inszenierten unerwünschter Datei (en), rückgängig zu machen, können Sie git reset tun können, Head ist Leiter der Datei in der lokalen und dem letzten Parameter ist der Name der Datei.

Ich schaffe die Schritte im Bild unten in mehr Details für Sie, einschließlich aller Schritte, die in diesen Fällen passieren kann:

Ausführen

git gui

und entfernen Sie alle Dateien manuell oder durch alle von ihnen auswählen und auf die Schaltfläche unstage von commit Taste.

Git hat Befehle für jede Aktion vorstellen kann, aber braucht umfangreiches Wissen wegen Dinge richtig und zu erhalten, dass es kontraintuitiv besten ...

Was du getan hast vor:

Changed eine Datei und verwendet git add . oder git add <file>.

Was Sie wollen:

Entfernen Sie die Datei aus dem Index, aber halten Sie es mit unbestätigten Änderungen in der Arbeitskopie versioniert und links:
```
git reset head <file>
```
Setzen Sie die Datei in den letzten Zustand von HEAD, Änderungen rückgängig machen und sie aus dem Index zu entfernen:
```
# Think `svn revert <file>` IIRC.
git reset HEAD <file>
git checkout <file>

# If you have a `<branch>` named like `<file>`, use:
git checkout -- <file>
```
Das ist erforderlich, da git reset --hard HEAD nicht mit einzelnen Dateien arbeiten.
Entfernen <file> aus dem Index und Versionierung, die un-versioniert Datei mit Änderungen in der Arbeitskopie zu halten:
```
git rm --cached <file>
```
Entfernen <file> von Arbeitskopie und Versionierung vollständig:
```
git rm <file>
```

Die Frage ist nicht eindeutig gestellt. Der Grund dafür ist, dass git add hat zwei Bedeutungen:

neue Datei in den Staging-Bereich hinzufügen, dann rückgängig gemacht werden mit git rm --cached file.
Hinzufügen einer geändert Datei in den Staging-Bereich, rückgängig machen dann mit git reset HEAD file.

im Zweifelsfall verwenden

git reset HEAD file

Weil es tut die erwartete Sache in beiden Fällen.

Achtung: , wenn Sie git rm --cached file auf eine Datei zu tun, das war geändert (eine Datei, die zuvor im Repository vorhanden), dann wird die Datei auf git commit entfernt werden! Es wird nach wie vor in Ihrem Dateisystem vorhanden ist, aber wenn jemand anderes Ihrer begehen zieht, wird die Datei aus ihrer Arbeit Baum gelöscht werden.

git status werden Ihnen sagen, wenn die Datei eine neue Datei ist oder geändert :

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 auf Ihrem ersten sind zu begehen und Sie können nicht git reset bedienen, einfach erklären „Git Konkurs“ und löschen Sie den Ordner .git und von vorn beginnen

Wie pro viele der anderen Antworten Sie git reset verwenden

ABER:

ich diesen großen kleinen Beitrag gefunden, der die Git-Befehl tatsächlich fügt hinzu (auch ein Alias) für git unadd: siehe git unadd für Details oder ..

Einfach

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

Jetzt können Sie

git unadd foo.txt bar.txt

git remove oder git rm kann dies mit der --cached Flagge verwendet werden. Versuchen Sie:

git help rm

Verwenden git add -i entfernen nur schöpf Dateien von Ihrem nächsten zu begehen. Beispiel:

Das Hinzufügen der Datei, die Sie nicht wollen:

$ 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)
# [...]#

Going in interaktive Add Ihr Add rückgängig zu machen (die bei git eingegeben Befehle hier sind „r“ (zurückgesetzt), „1“ (erster Eintrag in der Liste zurückzukehren zeigt), ‚Rückkehr‘ aus revert Modus zu fallen, und "q" (quit):

$ 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 der Beweis, die zeigen, dass „foo“ ist zurück auf der untracked Liste:

$ 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)
$

Hier ist ein Weg, um dieses lästige Problem zu vermeiden, wenn Sie ein neues Projekt zu starten:

Erstellen Sie das Hauptverzeichnis für Ihr neues Projekt.
Ausführen git init.
Geben Sie nun eine .gitignore-Datei erstellen (auch wenn es leer ist).
Commit Ihre .gitignore Datei.

Git macht es wirklich schwer git reset zu tun, wenn Sie noch keine Commits haben. Wenn Sie erstellen eine kleine anfängliche begehen, nur um einen zu haben, nach, dass Sie oft git add -A und git reset wie können, wie Sie wollen, um alles richtig zu machen.

Ein weiterer Vorteil dieser Methode ist, dass, wenn Sie laufen in Zeilenende Probleme später und müssen alle Ihre Dateien aktualisieren, ist es einfach:

Überprüfen Sie heraus, dass die ersten begehen. Damit entfernen Sie alle Ihre Dateien.
Überprüfen Sie dann wieder Ihre letzte Commit aus. Dies wird abrufen frische Kopien Ihrer Dateien, Ihre aktuellen Zeilenende-Einstellungen.

Vielleicht hat Git entwickelt, da Sie Ihre Frage gestellt.

$> git --version
git version 1.6.2.1

Jetzt können Sie versuchen:

git reset HEAD .

Dies sollte das sein, was Sie suchen.

Beachten Sie, dass wenn Sie nicht eine Revision angeben, dann müssen Sie ein Trennzeichen enthalten. Beispiel aus 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)

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

git rm --cached FILE

Verwenden rm --cached nur für neue Dateien versehentlich hinzugefügt.

jede Datei in einem bestimmten Ordner zurücksetzen (und dessen Unterordner) können Sie den folgenden Befehl verwenden:

git reset *

Mit den * Befehl mehrere Dateien gleichzeitig verarbeiten

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

etc

Geben Sie einfach git reset es wieder zufällt, und es ist, wie Sie nie git add . getippt Ihre letzte seit begehen. Stellen Sie sicher, dass Sie vor begangen haben.

Angenommen, ich eine neue Datei newFile.txt erstellen.

Angenommen ich die Datei versehentlich hinzufügen, git add newFile.txt

Jetzt möchte ich dieses Add rückgängig zu machen, bevor begehen, git reset newFile.txt

Für eine bestimmte Datei:

git reset my_file.txt

git Kasse my_file.txt

Für alle hinzugefügten Dateien:

git reset.

git checkout.

Hinweis: Kasse ändert den Code in den Dateien und bewegt sich in die letzte Aktualisierung (stationär) Zustand. Zurücksetzen nicht die Codes ändern; es setzt nur den Header.

Mit diesem Befehl wird unstash Ihre Änderungen:

git reset HEAD filename.txt

Sie können auch verwenden

git add -p

hinzuzufügen Teile von Dateien.

Ich bin überrascht, dass niemand den interaktiven Modus zu geben:

git add -i

Wählen Sie die Option 3 zu un-Dateien hinzufügen. In meinem Fall möchte ich oft mehr als eine Datei hinzufügen, mit interaktiven Modus Sie Zahlen wie diese verwenden können, um Dateien hinzuzufügen. Dies wird alle aber 4: 1,2,3,5

Um eine Sequenz zu wählen nur 1-5 gibt alle von 1 bis 5 zu nehmen.

Git Staging-Dateien

rückgängig zu machen git Add

git reset filename

git reset filename.txt

Wird eine Datei filename.txt aus dem aktuellen Index, der den Namen entfernen „begangen werden soll“ Bereich, ohne sonst etwas zu ändern.

git add myfile.txt # dies wird fügen Sie Ihre Datei in begangen Liste werden

Ganz entgegengesetzt zu diesem Befehl ist,

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

ja, werden Sie in den vorherigen Zustand sein. in untracked Liste (vorherigen Zustand) wird wieder angegeben.

es wird zurückgesetzt, den Kopf mit der angegebenen Datei. so, wenn Sie den Kopf nicht über das bedeutet, es wird einfach zurücksetzen

In SourceTree können Sie dies über die gui leicht tun. Sie können prüfen, welcher Befehl sourcetree verwendet eine Datei unstage.

Ich habe eine neue Datei und fügte hinzu, es zu git. Dann unstaged ich es die SourceTree GUI. Dies ist das Ergebnis:

Unstaging Dateien [08/12/15 10.43]
git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree zurückgesetzt -q - path / to / file / filename.java

SourceTree verwendet reset neue Dateien unstage.

Eine der intuitiven Lösungen verwendet SourceTree .

Sie können einfach per Drag & Drop von Dateien aus inszenierten und unstaged

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow