Zoeken…
Samenvoegingen ongedaan maken
Een samenvoeging ongedaan maken die nog niet naar een afstandsbediening is gepusht
Als je je merge nog niet naar de externe repository hebt gepusht, kun je dezelfde procedure volgen als bij het ongedaan maken van de commit, hoewel er enkele subtiele verschillen zijn.
Een reset is de eenvoudigste optie omdat het zowel de merge commit als alle commits die vanuit de branch zijn toegevoegd ongedaan zal maken. Je moet echter weten naar welke SHA je terug moet gaan, dit kan lastig zijn omdat je git log nu commits van beide filialen zal tonen. Als je reset naar de verkeerde commit (bijv. De ene op de andere branch) kan het gecommitteerd werk vernietigen.
> git reset --hard <last commit from the branch you are on>
Of, ervan uitgaande dat de samenvoeging je meest recente commit was.
> git reset HEAD~
Een terugdraaiing is veiliger, omdat het toegewijd werk niet zal vernietigen, maar meer werk vereist omdat je de terugdraaiing moet terugdraaien voordat je de branch weer kunt samenvoegen (zie de volgende sectie).
Een samenvoeging ongedaan maken die naar een afstandsbediening is gepusht
Stel dat u een nieuwe functie samenvoegt (add-gremlins)
> git merge feature/add-gremlins
...
#Resolve any merge conflicts
> git commit #commit the merge
...
> git push
...
501b75d..17a51fd master -> master
Nadien ontdek je dat de functie die je zojuist hebt samengevoegd het systeem voor andere ontwikkelaars heeft verbroken, het moet meteen worden ongedaan gemaakt en het repareren van de functie zelf zal te lang duren, dus je wilt gewoon de samenvoeging ongedaan maken.
> git revert -m 1 17a51fd
...
> git push
...
17a51fd..e443799 master -> master
Op dit moment zijn de gremlins uit het systeem en zijn je mede-ontwikkelaars gestopt met schreeuwen tegen je. We zijn echter nog niet klaar. Nadat u het probleem met de functie add-gremlins hebt opgelost, moet u dit ongedaan maken ongedaan maken voordat u weer kunt samenvoegen.
> git checkout feature/add-gremlins
...
#Various commits to fix the bug.
> git checkout master
...
> git revert e443799
...
> git merge feature/add-gremlins
...
#Fix any merge conflicts introduced by the bug fix
> git commit #commit the merge
...
> git push
Op dit punt is uw functie nu succesvol toegevoegd. Aangezien bugs van dit type echter vaak worden geïntroduceerd door samenvoegconflicten, is een iets andere workflow soms nuttiger omdat u hiermee het samenvoegconflict in uw branche kunt oplossen.
> git checkout feature/add-gremlins
...
#Merge in master and revert the revert right away. This puts your branch in
#the same broken state that master was in before.
> git merge master
...
> git revert e443799
...
#Now go ahead and fix the bug (various commits go here)
> git checkout master
...
#Don't need to revert the revert at this point since it was done earlier
> git merge feature/add-gremlins
...
#Fix any merge conflicts introduced by the bug fix
> git commit #commit the merge
...
> git push
Reflog gebruiken
Als je een rebase verprutst, is een optie om opnieuw te beginnen terug te gaan naar de commit (pre rebase). U kunt dit doen met behulp van reflog (dat de geschiedenis heeft van alles wat u de afgelopen 90 dagen hebt gedaan - dit kan worden geconfigureerd):
$ git reflog
4a5cbb3 HEAD@{0}: rebase finished: returning to refs/heads/foo
4a5cbb3 HEAD@{1}: rebase: fixed such and such
904f7f0 HEAD@{2}: rebase: checkout upstream/master
3cbe20a HEAD@{3}: commit: fixed such and such
...
Je kunt de commit zien voordat de rebase HEAD@{3} (je kunt ook de hash uitchecken):
git checkout HEAD@{3}
Nu maak je een nieuwe branch / verwijder je de oude / probeer je de rebase opnieuw.
Je kunt ook direct teruggaan naar een punt in je reflog , maar doe dit alleen als je 100% zeker weet dat dit is wat je wilt doen:
git reset --hard HEAD@{3}
Dit zal ervoor zorgen dat je huidige git tree overeenkomt met hoe het op dat moment was (zie Wijzigingen ongedaan maken).
Dit kan worden gebruikt als u tijdelijk ziet hoe goed een branch werkt wanneer deze op een andere branch wordt rebased, maar u wilt de resultaten niet behouden.
Ga terug naar een vorige commit
Om terug te gaan naar een vorige commit, zoek je eerst de hash van de commit met behulp van git log .
Om tijdelijk terug te gaan naar die commit, maak je je hoofd los met:
git checkout 789abcd
Dit plaatst je op commit 789abcd . Je kunt nu nieuwe commits maken bovenop deze oude commit zonder de branch te beïnvloeden waar je hoofd op staat. Wijzigingen kunnen worden aangebracht in een juiste vertakking met behulp van branch of checkout -b .
Terugdraaien naar een vorige commit met behoud van de wijzigingen:
git reset --soft 789abcd
Om de laatste commit terug te draaien:
git reset --soft HEAD~
Om permanent wijzigingen te verwijderen die zijn aangebracht na een specifieke commit, gebruik je:
git reset --hard 789abcd
Om wijzigingen die zijn aangebracht na de laatste commit permanent te negeren:
git reset --hard HEAD~
Let op: hoewel je de weggegooide commits kunt herstellen met reflog en reset , kunnen niet-vastgelegde wijzigingen niet worden hersteld. Gebruik git stash; git reset plaats van git reset --hard om veilig te zijn.
Wijzigingen ongedaan maken
Wijzigingen in een bestand of map in de werkkopie ongedaan maken.
git checkout -- file.txt
Gebruikt over alle bestandspaden, recursief vanuit de huidige map, zal het alle wijzigingen in de werkkopie ongedaan maken.
git checkout -- .
Gebruik --patch om alleen delen van de wijzigingen --patch . U wordt voor elke wijziging gevraagd of deze ongedaan moet worden gemaakt of niet.
git checkout --patch -- dir
Wijzigingen ongedaan maken die aan de index zijn toegevoegd.
git reset --hard
Zonder de --hard vlag zal dit een zachte reset uitvoeren.
Met lokale commits die u nog naar een afstandsbediening moet pushen, kunt u ook een zachte reset uitvoeren. Je kunt dus de bestanden en vervolgens de commits herwerken.
git reset HEAD~2
In het bovenstaande voorbeeld worden uw laatste twee commits ongedaan gemaakt en worden de bestanden teruggezet naar uw werkkopie. Je zou dan verdere wijzigingen en nieuwe commits kunnen aanbrengen.
Let op: al deze bewerkingen, behalve zachte resets, zullen uw wijzigingen permanent verwijderen. Gebruik voor een veiligere optie respectievelijk git stash -p of git stash . Je kunt later ongedaan maken met stash pop of voor altijd verwijderen met stash drop .
Zet enkele bestaande commits terug
Gebruik git revert om bestaande commits terug te zetten, vooral wanneer die commits naar een externe repository zijn gepusht. Het neemt enkele nieuwe commits op om het effect van sommige eerdere commits om te keren, die je veilig kunt pushen zonder de geschiedenis te herschrijven.
Gebruik geen git push --force tenzij je de opprobrium van alle andere gebruikers van die repository wilt verlagen. Herschrijf nooit de openbare geschiedenis.
Als je bijvoorbeeld net een commit hebt gepusht die een bug bevat en je moet er een back-up van maken, doe dan het volgende:
git revert HEAD~1
git push
Nu bent u vrij om de herstelcommando lokaal terug te zetten, uw code te repareren en de goede code te pushen:
git revert HEAD~1
work .. work .. work ..
git add -A .
git commit -m "Update error code"
git push
Als de commit die je wilt terugzetten al verder terug in de geschiedenis is, kun je gewoon de commit hash doorgeven. Git maakt een tegen-commit die je oorspronkelijke commit ongedaan maakt, die je veilig naar je afstandsbediening kunt pushen.
git revert 912aaf0228338d0c8fb8cca0a064b0161a451fdc
git push
Een reeks commits ongedaan maken / opnieuw uitvoeren
Stel dat je een tiental commits ongedaan wilt maken en dat je er maar een paar wilt.
git rebase -i <earlier SHA>
-i zet rebase in "interactieve modus". Het begint zoals de rebase die hierboven is besproken, maar voordat je commits opnieuw afspeelt, pauzeert het en kun je elke commit zachtjes aanpassen terwijl deze opnieuw wordt afgespeeld. rebase -i wordt geopend in uw standaardteksteditor, met een lijst met commits die als volgt worden toegepast: 
Om een commit te laten vallen, verwijder je gewoon die regel in je editor. Als je niet langer de slechte commits in je project wilt, kun je regel 1 en 3-4 hierboven verwijderen. Als je twee commits wilt combineren, kun je de squash of fixup opdrachten gebruiken 