Hoe maak ik de meest recente lokale commits in Git ongedaan?

Ik heb per ongeluk de verkeerde bestanden toegezegd aan Git, maar deed het niet push de commit nog niet naar de server.

Hoe kan ik die commits van de lokale repository ongedaan maken?

De enige manier lijkt te zijn om de bewerkingen in een of andere GUI-teksteditor te kopiëren, vervolgens de hele lokale kloon te wissen, vervolgens de repository opnieuw te klonen en vervolgens de bewerkingen opnieuw toe te passen. Echter,

  • Dit kan gegevensverlies veroorzaken.
  • Het is erg moeilijk om dit te doen wanneer alleen een onbedoelde git commit werd uitgevoerd.

Is er een betere manier?


Antwoord 1, autoriteit 100%

Een commit ongedaan maken & opnieuw

$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~                              # (1)
[ edit files as necessary ]                    # (2)
$ git add .                                    # (3)
$ git commit -c ORIG_HEAD                      # (4)
  1. Dit commando is verantwoordelijk voor het ongedaan maken. Het zal je laatste commit ongedaan maken terwijl je werkboom (de staat van je bestanden op schijf) onaangeroerd blijft. Je moet ze opnieuw toevoegen voordat je ze opnieuw kunt committen).

  2. Breng correcties aan in werkboombestanden.

  3. git add alles wat je in je nieuwe commit wilt opnemen.

  4. Voeg de wijzigingen door, waarbij u het oude vastleggingsbericht opnieuw gebruikt. reset kopieerde de oude kop naar .git/ORIG_HEAD; commit met -c ORIG_HEAD zal een editor openen, die in eerste instantie het logbericht van de oude commit bevat en waarmee je het kunt bewerken. Als u het bericht niet hoeft te bewerken, kunt u de optie -C gebruiken.

Als alternatief, om de vorige vastlegging (of alleen het vastleggingsbericht) te bewerken, zal commit --amend wijzigingen in de huidige index toevoegen aan de vorige vastlegging.

Om een ​​commit die naar de server is gepusht te verwijderen (niet terug te zetten), is het noodzakelijk de geschiedenis te herschrijven met git push origin master --force.


Verder lezen

Hoe kan ik HEAD terug verplaatsen naar een vorige locatie? (Vrijstaand hoofd) & Toezeggingen ongedaan maken

Het bovenstaande antwoord laat je git reflog zien, die je kunt gebruiken om de SHA-1 te bepalen voor de commit waarnaar je wilt terugkeren. Zodra je deze waarde hebt, gebruik je de volgorde van commando’s zoals hierboven uitgelegd.


HEAD~ is hetzelfde als HEAD~1. Het artikel Wat is de HEAD in git? is handig als je meerdere commits wilt ongedaan maken.


Antwoord 2, autoriteit 46%

Het ongedaan maken van een commit is een beetje eng als je niet weet hoe het werkt. Maar het is eigenlijk verbazingwekkend eenvoudig als je het begrijpt. Ik laat je de 4 verschillende manieren zien waarop je een commit ongedaan kunt maken.

optie 1: git reset --hard

Stel dat je dit hebt, waarbij C je HOOFD is en (F) de staat van je bestanden is.

   (F)
A-B-C
    ^
  master

Je wilt commit C nuke en het nooit meer zien en alle wijzigingen in lokaal gewijzigde bestanden kwijtraken. Je doet dit:

git reset --hard HEAD~1

Het resultaat is:

 (F)
A-B
  ^
master

Nu is B het HOOFD. Omdat je --hard hebt gebruikt, worden je bestanden teruggezet naar hun staat bij commit B.

optie 2: git reset

Ah, maar stel dat commit C geen ramp was, maar gewoon een beetje verkeerd. Je wilt de commit ongedaan maken maar je wijzigingen behouden voor een beetje bewerking voordat je een betere commit doet. Opnieuw beginnen vanaf hier, met C als je HOOFD:

   (F)
A-B-C
    ^
  master

Je kunt dit doen, zonder de --hard:

git reset HEAD~1

In dit geval is het resultaat:

   (F)
A-B-C
  ^
master

In beide gevallen is HEAD slechts een verwijzing naar de laatste commit. Wanneer je een git reset HEAD~1 doet, vertel je Git om de HEAD-pointer één commit terug te zetten. Maar (tenzij je --hard gebruikt) laat je je bestanden zoals ze waren. Dus nu toont git status de wijzigingen die je had ingecheckt in C. Je bent niets kwijt!

optie 3: git reset --soft

Voor de lichtste aanraking kun je zelfs je commit ongedaan maken, maar je bestanden en je index:

git reset --soft HEAD~1

Dit laat niet alleen uw bestanden met rust, het laat zelfs uw index met rust. Wanneer je git status doet, zul je zien dat dezelfde bestanden in de index staan ​​als voorheen. In feite zou je direct na dit commando git commit kunnen doen en zou je dezelfde commit opnieuw doen die je net had.

optie 4: je deed git reset --hard en moet die code terugkrijgen

Nog één ding: Stel dat je een commit vernietigt zoals in het eerste voorbeeld, maar dan ontdekt dat je het toch nodig had? Pech, toch?

Nee, er is nog een manier om het terug te krijgen. Typ git reflog en je ziet een lijst met (gedeeltelijke) commit shas (dat wil zeggen, hashes) waarin je bent verhuisd. Zoek de commit die je hebt vernietigd en doe dit:

git checkout -b someNewBranchName shaYouDestroyed

Je hebt die commit nu weer tot leven gewekt. Commits worden niet echt vernietigd in Git gedurende ongeveer 90 dagen, dus je kunt meestal teruggaan en er een redden die je niet wilde verwijderen.


Antwoord 3, autoriteit 9%

Er zijn twee manieren om “ongedaan te maken” je laatste commit, afhankelijk van of je je commit al of niet openbaar hebt gemaakt (gepusht naar je externe repository):

Hoe maak je een lokale commit ongedaan

Stel dat ik lokaal een commit heb gedaan, maar nu wil ik die commit verwijderen.

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

Om alles terug te zetten naar hoe het was voor de laatste commit, moeten we reset naar de commit voor HEAD:

git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

Nu zal git log laten zien dat onze laatste commit is verwijderd.

Een openbare commit ongedaan maken

Als je je commits al openbaar hebt gemaakt, wil je een nieuwe commit maken die zal "revert" de wijzigingen die je hebt aangebracht in je vorige commit (huidige HEAD).

git revert HEAD

Uw wijzigingen worden nu teruggedraaid en zijn klaar om door u te worden doorgevoerd:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Voor meer informatie, bekijk Git Basics – Dingen ongedaan maken.


Antwoord 4, autoriteit 7%

Bestanden toevoegen/verwijderen om alles te krijgen zoals u dat wilt:

git rm classdir
git add sourcedir

Pas vervolgens de commit aan:

git commit --amend

De vorige, foutieve commit zal worden bewerkt om de nieuwe indexstatus weer te geven – met andere woorden, het zal zijn alsof je nooit de fout hebt gemaakt.

Houd er rekening mee dat je dit alleen moet doen als je nog niet hebt gepusht. Als je hebt gepusht, moet je normaal een fix uitvoeren.


Antwoord 5, autoriteit 4%

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

of

git reset --hard HEAD~1

Waarschuwing: de bovenstaande opdracht verwijdert permanent de wijzigingen aan de .java-bestanden (en alle andere bestanden) die u wilde vastleggen.

De hard reset naar HEAD-1 stelt je werkkopie in op de staat van de commit voor je verkeerde commit.


Antwoord 6, autoriteit 3%

De laatste commit wijzigen

Vervang de bestanden in de index:

git rm --cached *.class
git add *.java

Vervolgens, als het een private branch is, wijzig de commit:

git commit --amend

Of, als het een gedeelde branch is, maak een nieuwe commit:

git commit -m 'Replace .class files with .java files'

(Om een ​​eerdere commit te wijzigen, gebruik je de geweldige interactieve rebase. )


ProTip : Voeg *.class toe aan een gitignore om te voorkomen dat dit opnieuw gebeurt.


Een commit terugdraaien

Het wijzigen van een commit is de ideale oplossing als je de laatste commit moet wijzigen, maar een meer algemene oplossing is reset.

Je kunt Git resetten naar elke commit met:

git reset @~N

Waarbij N het aantal commits is vóór HEAD, en @~ wordt teruggezet naar de vorige commit.

In plaats van de commit te wijzigen, zou je het volgende kunnen gebruiken:

git reset @~
git add *.java
git commit -m "Add .java files"

Bekijk git help reset, met name de secties over --soft --mixed en --hard, voor een beter begrip van wat dit doet.

Reflog

Als je het verprutst, kun je altijd de reflog gebruiken om verloren commits te vinden:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started


Antwoord 7, autoriteit 3%

Gebruik git revert <commit-id>.

Om de commit ID te krijgen, gebruik je gewoon git log.


Antwoord 8, autoriteit 2%

Als je van plan bent om een ​​lokale commit volledig ongedaan te maken, wat je ook hebt veranderd aan de commit, en als je je daar geen zorgen over maakt, voer dan gewoon het volgende commando uit.

git reset --hard HEAD^1

(Dit commando negeert je hele commit en je wijzigingen gaan volledig verloren van je lokale werkboom). Als je je commit ongedaan wilt maken, maar je wilt je wijzigingen in het staging-gebied (vóór commit net als na git add), voer dan het volgende commando uit.

git reset --soft HEAD^1

Je toegewezen bestanden komen nu in het staging-gebied. Stel dat als u de bestanden wilt upstageren, omdat u een verkeerde inhoud moet bewerken, voer dan de volgende opdracht uit

git reset HEAD

Gecommitteerde bestanden komen nu van het gefaseerde gebied naar het niet-gefaseerde gebied. Nu zijn bestanden klaar om te bewerken, dus wat je ook verandert, je wilt het gaan bewerken en toevoegen en een nieuwe/nieuwe commit maken.

Meer ( link verbroken) (Gearchiveerde versie)


Antwoord 9, autoriteit 2%

Als je Git Extras hebt geïnstalleerd, kun je git undo om de laatste commit ongedaan te maken. git undo 3 maakt de laatste drie commits ongedaan.


Antwoord 10, autoriteit 2%

Ik wilde de laatste vijf commits in onze gedeelde repository ongedaan maken. Ik heb de revisie-ID opgezocht waarnaar ik wilde terugdraaien. Toen typte ik het volgende.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Antwoord 11, autoriteit 2%

Ik gebruik liever git rebase -i voor deze taak, omdat er een mooie lijst verschijnt waar ik de commits kan kiezen die ik wil verwijderen. Het is misschien niet zo direct als sommige andere antwoorden hier, maar het voelt gewoon goed.

Kies hoeveel commits je wilt vermelden en roep dan op deze manier aan (om de laatste drie in te schakelen)

git rebase -i HEAD~3

Voorbeeldlijst

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Vervolgens zal Git commits verwijderen voor elke regel die je verwijdert.


Antwoord 12, autoriteit 2%

Hoe de vorige lokale commit te herstellen

Gebruik git-gui (of iets dergelijks) om een ​​git commit --amend uit te voeren. Vanuit de GUI kun je individuele bestanden toevoegen aan of verwijderen uit de commit. U kunt het commit-bericht ook wijzigen.

Hoe de vorige lokale commit ongedaan maken

Reset gewoon je branch naar de vorige locatie (bijvoorbeeld met behulp van gitk of git rebase). Pas vervolgens uw wijzigingen opnieuw toe vanuit een opgeslagen kopie. Na het verzamelen van afval in je lokale repository, zal het zijn alsof de ongewenste commit nooit heeft plaatsgevonden. Om dat allemaal in een enkele opdracht te doen, gebruik je git reset HEAD~1.

Waarschuwing: Onzorgvuldig gebruik van git reset is een goede manier om je werkkopie in een verwarrende staat te brengen. Ik raad Git-beginners aan dit te vermijden als ze kunnen.

Een openbare commit ongedaan maken

Voer een omgekeerde kersenpluk uit (git-revert) om de wijzigingen ongedaan te maken.

Als u nog geen andere wijzigingen in uw branch heeft doorgevoerd, kunt u dat gewoon doen…

git revert --no-edit HEAD

Push dan je bijgewerkte branch naar de gedeelde repository.

De vastleggingsgeschiedenis toont beide vastleggingen afzonderlijk.


Geavanceerd: correctie van de private-tak in openbare repository

Dit kan gevaarlijk zijn — zorg ervoor dat je een lokale kopie van de vertakking hebt om te weigeren.

Let ook op: u wilt dit niet doen als iemand anders op het filiaal werkt.

git push --delete (branch_name) ## remove public version of branch

Ruim uw filiaal lokaal op en druk vervolgens opnieuw…

git push origin (branch_name)

In het normale geval hoef je je waarschijnlijk geen zorgen te maken dat je privé-tak commit-geschiedenis ongerept is. Druk gewoon op een vervolgcommit (zie ‘Een openbare commit ongedaan maken’ hierboven) en voer later een squash-merge uit om de geschiedenis te verbergen.


Antwoord 13, autoriteit 2%

Als je het permanent ongedaan wilt maken en je hebt een repository gekloond.

De commit-ID kan worden bekeken door:

git log 

Dan kun je het volgende doen:

git reset --hard <commit_id>
git push origin <branch_name> -f

Antwoord 14

Als je rommel hebt gemaakt maar niet hebt gepusht,

git reset --soft HEAD~1

HEAD~1 is een afkorting voor de commit voor head. Als alternatief kunt u de SHA-1 van de hash raadplegen als u wilt resetten. –soft optie zal de commit verwijderen, maar het laat al je gewijzigde bestanden “Changes to be commit”, zoals git status het zou zeggen.

Als je alle wijzigingen in de bijgehouden bestanden in de werkboom wilt verwijderen sinds de commit voor head, gebruik dan in plaats daarvan “–hard“.

OF

Als je al hebt geduwd en iemand heeft getrokken, wat meestal mijn geval is, kun je git reset niet gebruiken. Je kunt echter wel een git revert doen,

git revert HEAD

Hiermee wordt een nieuwe commit gemaakt die alles terugdraait dat is geïntroduceerd door de onbedoelde commit.


Antwoord 15

Op SourceTree (GUI voor GitHub), kunt u met de rechtermuisknop op de commit klikken en een ‘Reverse Commit ‘. Dit zou je wijzigingen ongedaan moeten maken.

Op de terminal:

U kunt ook het volgende gebruiken:

git revert

Of:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Antwoord 16

Een enkele opdracht:

git reset --soft 'HEAD^' 

Het werkt prima om de laatste lokale commit ongedaan te maken!


Antwoord 17

Reset het gewoon door het onderstaande commando te gebruiken met git:

git reset --soft HEAD~1

Leg uit: wat git reset doet, het is in feite reset naar elke commit waar je naar terug wilt gaan, en als je dan combineert het met de --soft toets, het gaat terug, maar behoudt de wijzigingen in uw bestand(en), zodat u teruggaat naar het stadium waarin het bestand zojuist is toegevoegd, HEAD is de head van de branch en als je combineert met ~1 (in dit geval gebruik je ook HEAD^), dan gaat het maar één commit terug, wat je wil…

Ik maak de stappen in de onderstaande afbeelding in meer detail voor je, inclusief alle stappen die in echte situaties kunnen gebeuren en het vastleggen van de code:

Hoe de laatste commits in Git ongedaan maken?


Antwoord 18

Hoe de laatste Git-commit ongedaan maken?

Om alles terug te zetten naar de manier waarop het was voor de laatste commit, moeten we resetten naar de commit voor HEAD.

  1. Als u uw aangebrachte wijzigingen niet wilt behouden:

    git reset --hard HEAD^ 
    
  2. Als u uw wijzigingen wilt behouden:

    git reset --soft HEAD^
    

Controleer nu je git-log. Het zal laten zien dat onze laatste commit is verwijderd.


Antwoord 19

“Reset de werkboom naar de laatste commit”

git reset --hard HEAD^ 

“Schoon onbekende bestanden uit de werkboom”

git clean    

zie – Git Quick Reference

OPMERKING: Dit commando zal je vorige commit verwijderen, dus wees voorzichtig! git reset --hard is veiliger.


Antwoord 20

Gebruik reflog om een ​​juiste staat te vinden

git reflog

reflog voor
REFLOG VOOR RESET

Selecteer de juiste reflog (f3cb6e2 in mijn geval) en typ

git reset --hard f3cb6e2

Daarna wordt de repo HEAD gereset naar die HEADid
reset-effect
LOG NA RESET

Eindelijk ziet de reflog eruit zoals op de onderstaande afbeelding

reflog na
REFLOG FINALE


Antwoord 21

Eerste run:

git reflog

Het laat je alle mogelijke acties zien die je op je repository hebt uitgevoerd, bijvoorbeeld commit, merge, pull, etc.

Doe dan:

git reset --hard ActionIdFromRefLog

Antwoord 22

Laatste vastlegging ongedaan maken:

git reset --soft HEAD^ of git reset --soft HEAD~

Hiermee wordt de laatste vastlegging ongedaan gemaakt.

Hier betekent --soft reset in staging.

HEAD~ of HEAD^ betekent verplaatsen naar commit vóór HEAD.


Laatste commit vervangen door nieuwe commit:

git commit --amend -m "message"

Het zal de laatste commit vervangen door de nieuwe commit.


Antwoord 23

Een andere manier:

Bekijk de branch die je wilt terugzetten, en reset dan je lokale werkkopie terug naar de commit die je als laatste wilt hebben op de remote server (alles daarna gaat tot ziens). Om dit te doen, heb ik in SourceTree met de rechtermuisknop geklikt op de en selecteerde “Reset BRANCHNAME to this commit”.

Navigeer vervolgens naar de lokale map van uw repository en voer deze opdracht uit:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

Hiermee worden alle commits gewist na de huidige in je lokale repository, maar alleen voor die ene branch.


Antwoord 24

Typ git log en zoek de laatste commit-hashcode en voer vervolgens in:

git reset <the previous co>

Antwoord 25

In mijn geval heb ik per ongeluk bestanden vastgelegd die ik niet wilde. Dus ik deed het volgende en het werkte:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verifieer de resultaten met gitk of git log –stat


Antwoord 26

Eenvoudig, voer dit uit in uw opdrachtregel:

git reset --soft HEAD~ 

Antwoord 27

Er zijn twee hoofdscenario’s

Je hebt de commit nog niet gepusht

Als het probleem extra bestanden waren die je hebt gecommit (en je wilt die niet in de repository), kun je ze verwijderen met git rm en vervolgens committen met --amend

git rm <pathToFile>

Je kunt ook hele mappen verwijderen met -r, of zelfs combineren met andere Bash commando’s

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Na het verwijderen van de bestanden, kun je committen, met de –amend optie

git commit --amend -C HEAD # the -C option is to use the same commit message

Hiermee wordt je recente lokale commit herschreven en worden de extra bestanden verwijderd, dus deze bestanden worden nooit bij push verzonden en worden ook door GC uit je lokale .git-repository verwijderd.

Je hebt de commit al gepusht

Je kunt dezelfde oplossing van het andere scenario toepassen en dan git push doen met de optie -f, maar het wordt niet aanbevolen omdat het de externe geschiedenis overschrijft met een afwijkende wijziging (het kan je repository in de war brengen).

In plaats daarvan moet je de commit doen zonder --amend (onthoud dit over -amend`: die optie herschrijft de geschiedenis van de laatste commit).


Antwoord 28

Voor een lokale commit

git reset --soft HEAD~1

of als je niet meer precies weet in welke commit het is, zou je kunnen gebruiken

git rm --cached <file>

Voor een gepushte commit

De juiste manier om bestanden uit de repositorygeschiedenis te verwijderen, is door git filter-branch te gebruiken. Dat wil zeggen,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Maar ik raad je aan om deze opdracht met zorg te gebruiken. Lees meer op git-filter-branch(1) Manual Page .


Antwoord 29

Te resetten naar de vorige revisie, waarbij alle niet-vastgelegde wijzigingen permanent worden verwijderd:

git reset --hard HEAD~1

Antwoord 30

Er zijn veel manieren om dit te doen:

Git-commando om de laatste commit/vorige commits ongedaan te maken:

Waarschuwing: Gebruik –hard niet als u niet weet wat u doet.
–hard is te gevaarlijk en kan je bestanden verwijderen.

Basiscommando om de commit in Git terug te draaien is:

$ git reset --hard <COMMIT -ID>

of

$ git reset --hard HEAD~<n>

COMMIT-ID: ID voor de commit

n: is het aantal laatste commits dat je wilt terugdraaien

Je kunt de commit id krijgen zoals hieronder getoond:

$ **git log --oneline**
d81d3f1 function to subtract two numbers
be20eb8 function to add two numbers
bedgfgg function to mulitply two numbers

waar d81d3f1 en be20eb8 commit-ID zijn.

Laten we nu enkele gevallen bekijken:

Stel dat je de laatste commit ‘d81d3f1’ wilt terugdraaien. Hier zijn twee opties:

$ git reset --hard d81d3f1

of

$ git reset --hard HEAD~1

Stel dat je de commit ‘be20eb8’ wilt terugdraaien:

$ git reset --hard be20eb8

Voor meer gedetailleerde informatie kunt u enkele andere commando’s raadplegen en uitproberen om de kop terug te zetten naar een gespecificeerde staat:

$ git reset --help

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes