Ik heb een project in een externe repository, gesynchroniseerd met een lokale repository (ontwikkeling) en de server (prod). Ik heb een aantal gecommitteerde wijzigingen aangebracht die al naar remote zijn gepusht en van de server zijn gehaald. Nu wil ik die wijzigingen ongedaan maken. Dus ik kan gewoon git checkout naar de commit voor de wijzigingen en de nieuwe wijzigingen vastleggen, maar ik vermoed dat er problemen zullen zijn om ze opnieuw naar remote te pushen. Enige suggestie over hoe ik verder moet?
Antwoord 1, autoriteit 100%
Je kunt individuele toezeggingen terugdraaien met:
git revert <commit_hash>
Dit zal een nieuwe commit creëren die de wijzigingen van de door jou gespecificeerde commit ongedaan maakt. Merk op dat het alleen die specifieke commit terugdraait, en geen commits die daarna komen. Als je een reeks commits wilt terugdraaien, kun je dat als volgt doen:
git revert <oldest_commit_hash>..<latest_commit_hash>
Het zet de commits terug tussen en inclusief de gespecificeerde commits.
Om de hash van de commit(s) te weten kun je git log
gebruiken
Bekijk de git-revert man-pagina voor meer informatie over de git revert commando. Bekijk ook dit antwoord voor meer informatie over het terugdraaien van commits.
Antwoord 2, autoriteit 45%
Een oplossing die geen sporen achterlaat van het “ongedaan maken”.
OPMERKING: doe dit niet als iemand je wisselgeld al heeft ingetrokken
(Ik zou dit alleen op mijn persoonlijke repo gebruiken)
doen:
git reset <previous label or sha1>
dit zal alle updates lokaal opnieuw uitchecken (dus git status zal alle bijgewerkte bestanden weergeven)
vervolgens “doe je je werk” en voer je de wijzigingen opnieuw door (Opmerking: deze stap is optioneel)
git commit -am "blabla"
Op dit moment verschilt uw lokale boom van de externe
git push -f <remote-name> <branch-name>
zal pushen en remote forceren om deze push te overwegen en de vorige verwijderen (het specificeren van remote-name en branch-name is niet verplicht maar wordt aangeraden om te voorkomen dat alle branches worden bijgewerkt met een update-vlag).
!! let op sommige tags kunnen nog wijzen op verwijderde commit !! hoe-verwijderen -a-remote-tag
Antwoord 3, autoriteit 28%
Wat ik in deze gevallen doe is:
-
Verplaats de cursor in de server terug naar de laatst bekende goede commit:
git push -f origin <last_known_good_commit>:<branch_name> -
Lokaal, doe hetzelfde:
git reset --hard <last_known_good_commit> # ^^^^^^ # optional
Bekijk een volledig voorbeeld van een branch my_new_branch die ik voor dit doel heb gemaakt:
$ git branch
my_new_branch
Dit is de recente geschiedenis na het toevoegen van wat dingen aan myfile.py:
$ git log
commit 80143bcaaca77963a47c211a9cbe664d5448d546
Author: me
Date: Wed Mar 23 12:48:03 2016 +0100
Adding new stuff in myfile.py
commit b4zad078237fa48746a4feb6517fa409f6bf238e
Author: me
Date: Tue Mar 18 12:46:59 2016 +0100
Initial commit
Ik wil van de laatste commit af, die al gepusht was, dus ik voer:
$ git push -f origin b4zad078237fa48746a4feb6517fa409f6bf238e:my_new_branch
Total 0 (delta 0), reused 0 (delta 0)
To [email protected]:me/myrepo.git
+ 80143bc...b4zad07 b4zad078237fa48746a4feb6517fa409f6bf238e -> my_new_branch (forced update)
Leuk! Nu zie ik dat het bestand dat op die commit is gewijzigd (myfile.py) wordt weergegeven in “not staged for commit”:
$ git status
On branch my_new_branch
Your branch is up-to-date with 'origin/my_new_branch'.
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: myfile.py
no changes added to commit (use "git add" and/or "git commit -a")
Omdat ik deze wijzigingen niet wil, verplaats ik de cursor ook lokaal terug:
$ git reset --hard b4zad078237fa48746a4feb6517fa409f6bf238e
HEAD is now at b4zad07 Initial commit
Dus nu zit HEAD in de vorige commit, zowel lokaal als op afstand:
$ git log
commit b4zad078237fa48746a4feb6517fa409f6bf238e
Author: me
Date: Tue Mar 18 12:46:59 2016 +0100
Initial commit
Antwoord 4, autoriteit 13%
Hiermee worden je gepushte commits verwijderd
git reset --hard 'xxxxx'
git clean -f -d
git push -f
Antwoord 5, autoriteit 9%
Je kunt de Git Commit ZOWEL Lokaal en Extern REVERT (of je kunt het ook DELETE noemen) als je de onderstaande stappen volgt via de git-opdrachtregel.
Voer het volgende commando uit om de commit-ID te zien die je wilt terugzetten
git log --oneline --decorate --graph
Je krijgt als volgt een screenshot
Als u ook afstandsbediening (via webinterface) aanvinkt, kunt u zien dat dit hetzelfde zou zijn als hieronder weergegeven
Volgens screenshot zit je momenteel op commit id e110322 maar je wilt teruggaan naar 030bbf6 ZOWEL LOKAAL ALS OP AFSTAND.
Voer de volgende stappen uit om toezeggingen lokaal en op afstand te VERWIJDEREN/TERUG TE STELLEN
Eerst lokaal terugkerend naar commit id 030bbf6
git reset --hard 030bbf6
gevolgd door
git clean -f -d
Deze twee commando’s clean force reset om stage 030bbf6 te committen zoals hieronder getoond in snapshot
nu als je rent
git status dan zul je zien dat je TWEE Commits ACHTER bent van de remote branch zoals hieronder getoond
Voer het volgende uit om uw indexen bij te werken (als er updates zijn). Het wordt aanbevolen dat je alle ontwikkelaars vraagt om geen pull-verzoeken op de externe hoofdvertakking te accepteren.
git fetch --all
Als je er klaar mee bent, moet je Push deze commit krachtig door het + symbool voor de branch te gebruiken, zoals getoond onderstaand. Ik heb hier gebruikt als master branch, je kunt het vervangen door elke
Code
git push -u origin +master
Als je nu de webinterface van remote ziet, moet de commit ook worden teruggedraaid.
Antwoord 6, autoriteit 4%
2020 Eenvoudige manier:
git reset <commit_hash>
(De hash van de laatste commit die je wilt behouden).
U bewaart de nu niet-vastgelegde wijzigingen lokaal.
Als je opnieuw wilt pushen, moet je het volgende doen:
git push -f
Antwoord 7, autoriteit 3%
Laten we zeggen dat 61234 het sha-nummer is van de laatste goede commit die je wilt behouden.
git reset --hard 61234
git push -f origin master
?
zal volledig alle verkeerde commits verwijderen zonder enig spoor.
Opmerking: voorbeeld aangenomen master branch op ‘origin’ remote.
Antwoord 8, autoriteit 2%
git revert HEAD -m 1
In de bovenstaande coderegel. “Laatste argument staat voor”
-
1 – zet één commit terug.
-
2 – zet de laatste twee commits terug.
-
n – keert laatste n . terug
verbindt.
Je moet op deze opdracht drukken om het effect op de afstandsbediening te krijgen. Je hebt andere opties, zoals het specificeren van het bereik van commits om terug te keren. Dit is een van de opties.
Gebruik later git commit -am "COMMIT_MESSAGE"
dan git push of git push -f
Antwoord 9
De reset werkte hard voor mij:
Bedankt @Mo D Genensis en @vibs2006
git reset --hard 'your last working commit hash'
git clean -f -d
git push -f
Antwoord 10
Dit is mijn manier:
Laten we zeggen dat de naam van het filiaal develop is.
# Checkout a new temp branch based on one history commit
git checkout <last_known_good_commit_hash>
# Delete the original develop branch
git branch -D develop
# Create a new develop branch based on the temp branch
git checkout -b develop
# Force update this new branch
git push -f origin develop
Antwoord 11
Je kunt zoiets doen
git push origin +<short_commit_sha>^:<branch_name>
Antwoord 12
Een andere manier om dit te doen zonder terug te keren (sporen van ongedaan maken):
Doe het niet als iemand anders andere commits heeft gepusht
Maak een back-up van uw filiaal, in uw filiaal my-branch. Dus in het geval dat er iets misgaat, kunt u het proces opnieuw starten zonder enig werk te verliezen.
git checkout -b my-branch-temp
Ga terug naar je filiaal.
git checkout my-branch
Reset, om je laatste commit te verwijderen (om het ongedaan te maken):
git reset --hard HEAD^
Verwijder de vertakking op remote (bijv. origin remote).
git push origin :my-branch
Repush je branch (zonder de ongewenste commit) naar de remote.
git push origin my-branch
Klaar!
Ik hoop dat dat helpt! 😉
Antwoord 13
Om het netjes te doen:
git rebase -i <hash of last good commit, 9 chars is enough>
Nu krijg je een lijst van de commits van de laatste goede commit naar de HEAD met opties wat te doen met elke commit. DROP zal die commit weggooien. Sla het bestand op.
Nu de stroomopwaartse reparatie uitvoeren:
git push --force-with-lease
( Met lease zodat u niet per ongeluk problemen veroorzaakt voor iemand anders die aan uw gepushte update werkt)
Dit houdt het logboek schoon door de verkeerde commit te verwijderen in plaats van nieuwe commits te introduceren die eerdere foutieve commits repareren.