Ik heb per ongeluk bestanden aan Git toegevoegd met het commando:
git add myfile.txt
Ik heb git commit
nog niet uitgevoerd. Is er een manier om dit ongedaan te maken, zodat deze bestanden niet worden opgenomen in de vastlegging?
Antwoord 1, autoriteit 100%
Je kunt git add
ongedaan maken voordat je commit met
git reset <file>
die het uit de huidige index zal verwijderen (de lijst met “wordt binnenkort vastgelegd”) zonder iets anders te veranderen.
U kunt gebruiken
git reset
zonder enige bestandsnaam om alle noodzakelijke wijzigingen te unstagen. Dit kan handig zijn als er te veel bestanden zijn om één voor één in een redelijke tijd te worden weergegeven.
In oude versies van Git zijn de bovenstaande commando’s equivalent aan respectievelijk git reset HEAD <file>
en git reset HEAD
, en zullen mislukken als HEAD
is ongedefinieerd (omdat je nog geen commits hebt gemaakt in je repository) of dubbelzinnig (omdat je een branch hebt gemaakt met de naam HEAD
, wat stom is dat je niet zou moeten doen) . Deze is gewijzigd in Git 1.8. 2, dus in moderne versies van Git kun je de bovenstaande commando’s gebruiken zelfs voordat je je eerste commit doet:
"git reset" (zonder opties of parameters) gebruikt om een fout te maken wanneer:
je hebt geen commits in je geschiedenis, maar het geeft je nu
een lege index (om te matchen met niet-bestaande commit waar je niet eens op zit).
Documentatie: git reset
Antwoord 2, autoriteit 19%
Je wilt:
git rm --cached <added_file_to_undo>
Redenen:
Toen ik hier nieuw was, probeerde ik het voor het eerst
git reset .
(om mijn hele initiële toevoeging ongedaan te maken), alleen om dit (niet zo) nuttige bericht te krijgen:
fatal: Failed to resolve 'HEAD' as a valid ref.
Het blijkt dat dit komt omdat de HEAD ref (branch?) pas na de eerste commit bestaat. Dat wil zeggen, je zult hetzelfde beginnersprobleem tegenkomen als ik als je workflow, zoals de mijne, zoiets was als:
- cd naar mijn geweldige nieuwe projectdirectory om Git, de nieuwe hotness uit te proberen
git init
git add .
-
git status
… veel onzin scrollt door …
=> Verdomme, ik wilde dat allemaal niet toevoegen.
-
google “git add ongedaan maken”
=> zoek Stack Overflow – yay
-
git reset .
=> fataal: ‘HEAD’ kan niet worden omgezet als een geldige ref.
Het blijkt verder dat er een bug is geregistreerd tegen het nutteloze hiervan in de mailinglijst.
En dat de juiste oplossing daar stond in de Git-statusoutput (die, ja, ik verdoezelde als ‘crap)
... # Changes to be committed: # (use "git rm --cached <file>..." to unstage) ...
En de oplossing is inderdaad om git rm --cached file
te gebruiken.
Let op de waarschuwingen elders hier – git rm
verwijdert je lokale werkkopie van het bestand, maar niet als je –cached gebruikt. Hier is het resultaat van git help rm
:
–cached
Gebruik deze optie om alleen paden uit de index te unstagen en te verwijderen.
Werkboombestanden, al dan niet gewijzigd, blijven behouden.
Ik ga verder met gebruiken
git rm --cached .
om alles te verwijderen en opnieuw te beginnen. Werkte echter niet, want terwijl add .
recursief is, blijkt rm
-r
nodig te hebben om te recursief. Zucht.
git rm -r --cached .
Ok, nu ben ik terug bij waar ik begon. De volgende keer ga ik -n
gebruiken om een droge run te doen en te kijken wat er zal worden toegevoegd:
git add -n .
Ik heb alles op een veilige plaats gecomprimeerd voordat ik git help rm
vertrouwde dat de --cached
niets vernietigt (en wat als ik het verkeerd gespeld heb).
Antwoord 3, autoriteit 5%
Als je typt:
git status
Git vertelt je wat er is gestaged, enz., inclusief instructies over hoe je de stage kunt ongedaan maken:
use "git reset HEAD <file>..." to unstage
Ik vind dat Git me redelijk goed aanspoort om het juiste te doen in situaties als deze.
Opmerking: recente Git-versies (1.8.4.x) hebben dit bericht gewijzigd:
(use "git rm --cached <file>..." to unstage)
Antwoord 4, autoriteit 2%
Ter verduidelijking: git add
verplaatst wijzigingen van de huidige werkmap naar de staging area (index).
Dit proces wordt staging genoemd. Dus de meest natuurlijke opdracht om de wijzigingen (gewijzigde bestanden) te stagen ligt voor de hand:
git stage
git add
is gewoon een gemakkelijker te typen alias voor git stage
Jammer dat er geen git unstage
of git unadd
commando’s zijn. De relevante is moeilijker te raden of te onthouden, maar het is vrij duidelijk:
git reset HEAD --
We kunnen hier gemakkelijk een alias voor maken:
git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'
En tot slot hebben we nieuwe commando’s:
git add file1
git stage file2
git unadd file2
git unstage file1
Persoonlijk gebruik ik nog kortere aliassen:
git a # For staging
git u # For unstaging
Antwoord 5, autoriteit 2%
Als aanvulling op het geaccepteerde antwoord, als je per ongeluk toegevoegde bestand enorm was, zul je waarschijnlijk merken dat het, zelfs nadat het uit de index is verwijderd met ‘git reset
‘, nog steeds lijkt ruimte innemen in de .git
directory.
Dit is niets om je zorgen over te maken; het bestand staat inderdaad nog in de repository, maar alleen als een “los object”. Het zal niet worden gekopieerd naar andere opslagplaatsen (via kloon, push), en de ruimte zal uiteindelijk worden teruggewonnen – hoewel misschien niet erg snel. Als je angstig bent, kun je rennen:
git gc --prune=now
Update (wat volgt is mijn poging om enige verwarring weg te nemen die kan ontstaan door de meest geüpdatete antwoorden):
Dus, wat is het echte ongedaan maken van git add
?
git reset HEAD <file>
?
of
git rm --cached <file>
?
Strict genomen, en als ik me niet vergis: geen.
git add
kan niet ongedaan worden gemaakt – veilig, in het algemeen.
Laten we ons eerst herinneren wat git add <file>
eigenlijk doet:
-
Als
<file>
niet eerder werd gevolgd,git add
voegt het toe aan de cache, met de huidige inhoud. -
Als
<file>
al werd gevolgd,git add
slaat de huidige inhoud op ( snapshot, versie) naar de cache. In Git heet deze actie nog steeds add, (niet louter update it), omdat twee verschillende versies (snapshots) van een bestand als twee verschillende items worden beschouwd: vandaar, we voegen inderdaad een nieuw item toe aan de cache, om uiteindelijk later te worden vastgelegd.
In het licht hiervan is de vraag enigszins dubbelzinnig:
Ik heb per ongeluk bestanden toegevoegd met het commando…
Het scenario van de OP lijkt het eerste te zijn (niet-getraceerd bestand), we willen dat het “ongedaan maken” het bestand (niet alleen de huidige inhoud) van de bijgehouden items verwijdert. Als dit het geval is, dan is het oké om git rm --cached <file>
uit te voeren.
En we kunnen ook git reset HEAD <file>
uitvoeren. Dit heeft over het algemeen de voorkeur, omdat het in beide scenario’s werkt: het maakt ook ongedaan wanneer we ten onrechte een versie van een reeds bijgehouden item hebben toegevoegd.
Maar er zijn twee kanttekeningen.
Ten eerste: er is (zoals aangegeven in het antwoord) slechts één scenario waarin git reset HEAD
niet werkt, maar git rm --cached
wel: een nieuwe repository (geen commits). Maar eigenlijk is dit een praktisch irrelevante zaak.
Ten tweede: Houd er rekening mee dat git reset HEAD
niet op magische wijze de inhoud van het eerder in de cache opgeslagen bestand kan herstellen, het synchroniseert het gewoon opnieuw vanuit de HEAD. Als onze misleide git add
een eerdere gefaseerde niet-toegewezen versie heeft overschreven, kunnen we deze niet herstellen. Daarom kunnen we [*] strikt genomen niet ongedaan maken.
Voorbeeld:
$ 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
Natuurlijk is dit niet erg kritisch als we gewoon de gebruikelijke luie workflow volgen van het doen van ‘git add’ alleen voor het toevoegen van nieuwe bestanden (geval 1), en we updaten nieuwe inhoud via de commit, git commit -a
commando.
* (Bewerken: het bovenstaande is praktisch correct, maar toch kunnen er enkele enigszins hackachtige / ingewikkelde manieren zijn om wijzigingen te herstellen die in scène zijn gezet, maar niet zijn vastgelegd en vervolgens zijn overschreven – zie de opmerkingen van Johannes Matokic en iolsmit)
Antwoord 6
Ongedaan maken een bestand dat al is toegevoegd, is vrij eenvoudig met Git. Voor het resetten van myfile.txt
, die al zijn toegevoegd, gebruikt u:
git reset HEAD myfile.txt
Uitleg:
Nadat je ongewenste bestand(en) hebt gestaged, om ongedaan te maken, kun je git reset
uitvoeren. Head
is het hoofd van uw bestand in de lokale taal en de laatste parameter is de naam van uw bestand.
Ik heb de stappen in de onderstaande afbeelding in meer detail voor je gemaakt, inclusief alle stappen die in deze gevallen kunnen gebeuren:
Antwoord 7
git rm --cached . -r
zal alles wat u heeft toegevoegd recursief uit uw huidige directory “un-toevoegen”
Antwoord 8
Rennen
git gui
en verwijder alle bestanden handmatig of door ze allemaal te selecteren en op de knop unstage from commit te klikken.
Antwoord 9
Git heeft commando’s voor elke denkbare actie, maar het heeft uitgebreide kennis nodig om dingen goed te krijgen en daarom is het op zijn best contra-intuïtief…
Wat je eerder deed:
- Een bestand gewijzigd en
git add .
ofgit add <file>
gebruikt.
Wat je wilt:
-
Verwijder het bestand uit de index, maar bewaar het met versiebeheer en laat niet-vastgelegde wijzigingen in de werkkopie achter:
git reset HEAD <file>
-
Stel het bestand terug naar de laatste staat vanuit HEAD, maak wijzigingen ongedaan en verwijder ze uit de 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>
Dit is nodig omdat
git reset --hard HEAD
niet werkt met afzonderlijke bestanden. -
Verwijder
<file>
uit index en versiebeheer, waarbij het bestand zonder versienummer behouden blijft met wijzigingen in de werkkopie:git rm --cached <file>
-
Verwijder
<file>
volledig uit werkkopie en versiebeheer:git rm <file>
Antwoord 10
De vraag is niet duidelijk gesteld. De reden is dat git add
twee betekenissen heeft:
- een nieuw bestand toevoegen aan het staging-gebied en vervolgens ongedaan maken met
git rm --cached file
. - voeg een aangepast bestand toe aan het staging-gebied en maak vervolgens ongedaan met
git reset HEAD file
.
Gebruik bij twijfel
git reset HEAD file
Omdat het in beide gevallen het verwachte doet.
Waarschuwing: als u git rm --cached file
doet op een bestand dat aangepast is (een bestand dat eerder in de repository bestond ), dan wordt het bestand verwijderd op git commit
! Het zal nog steeds bestaan in je bestandssysteem, maar als iemand anders je commit trekt, zal het bestand uit hun werkboom worden verwijderd.
git status
zal je vertellen of het bestand een nieuw bestand of aangepast was:
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
Antwoord 11
Als je je eerste commit hebt en je kunt git reset
niet gebruiken, verklaar dan gewoon “Git faillissement” en verwijder de map .git
en begin opnieuw
Antwoord 12
Zoals bij veel van de andere antwoorden, kun je git reset
. gebruiken
MAAR:
Ik vond dit geweldige kleine bericht dat eigenlijk het Git-commando (nou ja, een alias) voor git unadd
toevoegt: zie git unadd voor details of..
Gewoon,
git config --global alias.unadd "reset HEAD"
Nu kunt u
git unadd foo.txt bar.txt
Alternatief / rechtstreeks:
git reset HEAD foo.txt bar.txt
Antwoord 13
Gebruik git add -i
om zojuist toegevoegde bestanden uit je aanstaande commit te verwijderen. Voorbeeld:
Het bestand toevoegen dat u niet wilde:
$ 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)
# [...]#
Interactieve toevoeging openen om uw toevoeging ongedaan te maken (de commando’s die hier bij git worden getypt zijn “r” (revert), “1” (eerste invoer in de lijst revert shows), ‘return’ om de terugzetmodus te verlaten, en “q” (stoppen):
$ 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.
$
Dat is het! Hier is je bewijs, waaruit blijkt dat “foo” weer op de niet-gevolgde lijst staat:
$ 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)
$
Antwoord 14
Hiervoor kunnen
git remove
of git rm
worden gebruikt, met de vlag --cached
. Probeer:
git help rm
Antwoord 15
Hier is een manier om dit vervelende probleem te vermijden wanneer u een nieuw project start:
- Maak de hoofdmap voor uw nieuwe project.
- Voer
git init
uit. - Maak nu een .gitignore-bestand (zelfs als het leeg is).
- Maak uw .gitignore-bestand vast.
Git maakt het erg moeilijk om git reset
uit te voeren als je geen commits hebt. Als je een kleine initiële commit maakt om er een te hebben, kun je daarna git add -A
en git reset
zo vaak als je wilt om alles goed.
Een ander voordeel van deze methode is dat als u later problemen ondervindt bij het beëindigen van de regel en u al uw bestanden moet vernieuwen, dit eenvoudig is:
- Bekijk die eerste commit. Hiermee worden al je bestanden verwijderd.
- Bekijk dan je meest recente commit opnieuw. Hiermee worden nieuwe kopieën van uw bestanden opgehaald met uw huidige instellingen voor het beëindigen van de regel.
Antwoord 16
Houd er rekening mee dat als u geen revisie opgeeft, u een scheidingsteken moet opnemen. Voorbeeld van mijn console:
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-versie 1.7.5.4)
Antwoord 17
Misschien is Git geëvolueerd sinds je je vraag hebt gepost.
$> git --version
git version 1.6.2.1
Nu kun je proberen:
git reset HEAD .
Dit zou moeten zijn wat u zoekt.
Antwoord 18
Om nieuwe bestanden uit het verzamelgebied te verwijderen (en alleen in het geval van een nieuw bestand), zoals hierboven voorgesteld:
git rm --cached FILE
Gebruik rm –cached alleen voor nieuwe bestanden die per ongeluk zijn toegevoegd.
Antwoord 19
Om elk bestand in een bepaalde map (en zijn submappen) opnieuw in te stellen, kunt u de volgende opdracht gebruiken:
git reset *
Antwoord 20
Gebruik de opdracht *
om meerdere bestanden tegelijk te verwerken:
git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*
enz.
Antwoord 21
Typ gewoon git reset
het zal terugkeren en het is alsof je nooit git add .
hebt getypt sinds je laatste commit. Zorg ervoor dat je eerder hebt toegezegd.
Antwoord 22
Stel dat ik een nieuw bestand maak, newFile.txt
:
Stel dat ik het bestand per ongeluk toevoeg, git add newFile.txt
:
Nu wil ik deze toevoeging ongedaan maken, vóór commit, git reset newFile.txt
:
Antwoord 23
Voor een specifiek bestand:
- git reset my_file.txt
- git checkout my_file.txt
Voor alle toegevoegde bestanden:
- git reset .
- git afrekenen .
Opmerking: afrekenen verandert de code in de bestanden en gaat naar de laatst bijgewerkte (toegewezen) status. reset verandert de codes niet; het reset gewoon de koptekst.
Antwoord 24
2019-update
Zoals aangegeven door anderen in gerelateerde vragen (zie hier, hier, hier, hier, hier, hier en hier), kunt u nu een enkel bestand unstagen met:
git restore --staged <file>
en unstage alle bestanden (van de hoofdmap van de repo) met:
git restore --staged .
Opmerkingen
git restore
is geïntroduceerd in juli 2019 en uitgebracht in versie 2.23.
Met de vlag --staged
wordt de inhoud van de index hersteld (wat hier wordt gevraagd).
Bij het uitvoeren van git status
met gestaged niet-toegewezen bestand(en), is dit nu wat Git voorstelt te gebruiken om bestand(en) te unstageren (in plaats van git reset HEAD <file>
zoals het was vóór v2.23).
Antwoord 25
Om git add
ongedaan te maken, gebruik je:
git reset filename
Antwoord 26
Er is ook een interactieve modus:
git add -i
Kies optie 3 om het toevoegen van bestanden ongedaan te maken. In mijn geval wil ik vaak meer dan één bestand toevoegen, en in de interactieve modus kun je dit soort nummers gebruiken om bestanden toe te voegen. Dit duurt alles behalve 4: 1, 2, 3 en 5
Als u een reeks wilt kiezen, typt u 1-5 om alles van 1 tot 5 te nemen.
Antwoord 27
Met deze opdracht worden uw wijzigingen ongedaan gemaakt:
git reset HEAD filename.txt
U kunt ook
. gebruiken
git add -p
om delen van bestanden toe te voegen.
Antwoord 28
git add myfile.txt
# Dit zal je bestand toevoegen aan de lijst die nog moet worden vastgelegd
Het tegenovergestelde van dit commando is,
git reset HEAD myfile.txt # This will undo it.
dus u bevindt zich in de vorige staat. Opgegeven staat weer in de niet-gevolgde lijst (vorige staat).
Het zal je hoofd resetten met dat gespecificeerde bestand. dus als je hoofd het niet heeft, zal het het gewoon resetten.
Antwoord 29
git reset filename.txt
Zal een bestand met de naam bestandsnaam.txt verwijderen uit de huidige index, het gebied “op het punt te worden vastgelegd”, zonder iets anders te veranderen.
Antwoord 30
git reset filename.txt
Zal een bestand met de naam bestandsnaam.txt verwijderen uit de huidige index, het gebied “op het punt te worden vastgelegd”, zonder iets anders te veranderen.