Sök…
Ångra fusioner
Ångra en sammanslagning som ännu inte skjutits till en fjärrkontroll
Om du ännu inte har drivit din sammanslagning till fjärrlagret kan du följa samma procedur som vid ångra åtagandet, även om det finns några subtila skillnader.
En återställning är det enklaste alternativet eftersom det kommer att ångra både fusionsåtagandet och alla åtaganden som läggs till från grenen. Du måste dock veta vad SHA ska återställa tillbaka till, det kan vara svårt eftersom din git log nu visar åtaganden från båda grenarna. Om du återställer fel fel (t.ex. en på den andra grenen) kan det förstöra engagerat arbete.
> git reset --hard <last commit from the branch you are on>
Eller, förutsatt att sammanslagningen var ditt senaste åtagande.
> git reset HEAD~
En återställning är säkrare eftersom den inte kommer att förstöra engagerat arbete utan innebär mer arbete eftersom du måste återställa omvändningen innan du kan slå tillbaka grenen igen (se nästa avsnitt).
Ångra en sammanslagning som drivs till en fjärrkontroll
Anta att du går samman i en ny funktion (add-gremlins)
> git merge feature/add-gremlins
...
#Resolve any merge conflicts
> git commit #commit the merge
...
> git push
...
501b75d..17a51fd master -> master
Efteråt upptäcker du att funktionen du just har sammanfogat bröt systemet för andra utvecklare, den måste ångras direkt, och att fixa själva funktionen kommer att ta för lång tid så att du helt enkelt vill ångra sammanslagningen.
> git revert -m 1 17a51fd
...
> git push
...
17a51fd..e443799 master -> master
Vid denna tidpunkt är gremlinsna ur systemet och dina kolleger utvecklare har slutat skrika på dig. Vi är dock inte färdiga ännu. När du har fixat problemet med add-gremlins-funktionen måste du ångra detta återställning innan du kan smälta in igen.
> 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
Vid denna tidpunkt läggs din funktion nu till. Men med tanke på att buggar av den här typen ofta införs genom sammanslagningskonflikter är ett lite annat arbetsflöde ibland mer användbart eftersom det låter dig fixa sammanslagningskonflikten på din gren.
> 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
Med hjälp av reflog
Om du skruvar upp en omfasning är ett alternativ att starta om igen att gå tillbaka till åtagandet (före omfasning). Du kan göra detta med reflog (som har historiken över allt du har gjort under de senaste 90 dagarna - det kan konfigureras):
$ 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
...
Du kan se åtagandet innan rebasen var HEAD@{3} (du kan också kassera hash):
git checkout HEAD@{3}
Nu skapar du en ny gren / raderar den gamla / försöker omfasen igen.
Du kan också återställa direkt till en punkt i din reflog , men bara göra detta om du är 100% säker på att det är vad du vill göra:
git reset --hard HEAD@{3}
Detta kommer att ställa in ditt nuvarande gitträd så att det matchar hur det var vid den punkten (Se Ångra ändringar).
Detta kan användas om du tillfälligt ser hur bra en filial fungerar när du ombaseras på en annan gren, men du inte vill behålla resultaten.
Återgå till ett tidigare åtagande
För att hoppa tillbaka till ett tidigare engagemang, hittar du först åtagarens hash med git log .
För att tillfälligt hoppa tillbaka till det åtagandet, koppla loss huvudet med:
git checkout 789abcd
Detta placerar dig vid åtagande 789abcd . Du kan nu göra nya åtaganden ovanpå detta gamla engagemang utan att påverka grenen ditt huvud är på. Eventuella ändringar kan göras till en riktig gren med antingen branch eller checkout -b .
Så här rullar du tillbaka till ett tidigare åtagande medan du behåller ändringarna:
git reset --soft 789abcd
Så här rullar du tillbaka det senaste åtagandet:
git reset --soft HEAD~
För att permanent kassera alla ändringar som gjorts efter ett specifikt åtagande, använd:
git reset --hard 789abcd
För att permanent kassera alla ändringar som gjorts efter det senaste åtagandet:
git reset --hard HEAD~
Akta dig: Även om du kan återställa de kasserade åtagandena med hjälp av reflog och reset , kan inte tillåtna ändringar återställas. Använd git stash; git reset istället för git reset --hard att vara säker.
Ångra ändringar
Ångra ändringar i en fil eller katalog i arbetskopian .
git checkout -- file.txt
Används över alla filvägar, rekursivt från den aktuella katalogen, kommer det att ångra alla ändringar i arbetskopian.
git checkout -- .
För att bara ångra delar av ändringarna använder du --patch . Du kommer att frågas för varje ändring om den ska ångras eller inte.
git checkout --patch -- dir
Ångra ändringar som läggs till i indexet .
git reset --hard
Utan flaggan --hard kommer detta att göra en mjuk återställning.
Med lokala åtaganden som du ännu inte trycker på en fjärrkontroll kan du också göra en mjuk återställning. Du kan alltså omarbeta filerna och sedan åtagandena.
git reset HEAD~2
Exemplet ovan skulle lossa dina två sista åtaganden och returnera filerna till din arbetskopia. Du kan sedan göra ytterligare ändringar och nya åtaganden.
Akta dig: Alla dessa åtgärder, bortsett från mjuka återställningar, kommer att radera dina ändringar permanent. För ett säkrare alternativ, använd git stash -p respektive git stash . Du kan senare ångra med stash pop eller radera för alltid med stash drop .
Återställ vissa befintliga åtaganden
Använd git revert för att återställa befintliga åtaganden, särskilt när dessa åtaganden har skjutits till ett fjärrlager. Den registrerar några nya åtaganden för att vända effekten av några tidigare åtaganden, som du kan trycka säkert utan att skriva om historiken.
Använd inte git push --force om du inte vill minska motståndet för alla andra användare av det förvaret. Skriv aldrig om den offentliga historien.
Om du till exempel just har drivit upp en engagemang som innehåller ett fel och du måste säkerhetskopiera det gör du följande:
git revert HEAD~1
git push
Nu står du fritt att återställa återställningsåtgärder lokalt, fixa din kod och trycka på den goda koden:
git revert HEAD~1
work .. work .. work ..
git add -A .
git commit -m "Update error code"
git push
Om åtagandet du vill återvända redan är längre bak i historien kan du helt enkelt skicka åtagandets hash. Git skapar en motåtgärd som ångrar ditt ursprungliga åtagande, som du kan trycka till din fjärrkontroll på ett säkert sätt.
git revert 912aaf0228338d0c8fb8cca0a064b0161a451fdc
git push
Ångra / Gör om en serie åtaganden
Anta att du vill ångra ett dussin åtaganden och att du bara vill ha några av dem.
git rebase -i <earlier SHA>
-Jag sätter återfas i "interaktivt läge". Det börjar som omfasningen som diskuterats ovan, men innan du spelar upp några åtaganden pausar den och låter dig försiktigt ändra varje åtkomst när det spelas om. rebase -i öppnas i din standardtextredigerare, med en lista över åtaganden som tillämpas, så här: 
Om du vill släppa ett åtagande raderar du bara den raden i din redigerare. Om du inte längre vill ha de dåliga åtagandena i ditt projekt kan du radera raderna 1 och 3-4 ovan. Om du vill kombinera två kommit tillsammans kan du använda kommandona squash eller fixup 