Hoe maak ik ‘git add’ ongedaan voordat ik commit?

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:

  1. cd naar mijn geweldige nieuwe projectdirectory om Git, de nieuwe hotness uit te proberen
  2. git init
  3. git add .
  4. git status

    … veel onzin scrollt door …

    => Verdomme, ik wilde dat allemaal niet toevoegen.

  5. google “git add ongedaan maken”

    => zoek Stack Overflow – yay

  6. 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:

  1. Als <file> niet eerder werd gevolgd, git add voegt het toe aan de cache, met de huidige inhoud.

  2. 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:

git reset HEAD-bestand


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 . of git 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:

  1. een nieuw bestand toevoegen aan het staging-gebied en vervolgens ongedaan maken met git rm --cached file.
  2. 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:

Voer hier de afbeeldingsbeschrijving in

Stel dat ik het bestand per ongeluk toevoeg, git add newFile.txt:

Voer hier de afbeeldingsbeschrijving in

Nu wil ik deze toevoeging ongedaan maken, vóór commit, git reset newFile.txt:

Voer hier de afbeeldingsbeschrijving in


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.

Git-stagingbestanden


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.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes