Hoe keer ik terug van mijn huidige staat naar een snapshot gemaakt op een bepaalde commit?
Als ik git log doe, krijg ik de volgende uitvoer:
$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date: Thu Nov 4 18:59:41 2010 -0400
blah blah blah...
commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date: Thu Nov 4 05:13:39 2010 -0400
more blah blah blah...
commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date: Thu Nov 4 00:55:06 2010 -0400
And yet more blah blah...
commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date: Wed Nov 3 23:56:08 2010 -0400
Yep, more blah blah.
Hoe keer ik terug naar de commit van 3 november, d.w.z. commit 0d1d7fc?
Antwoord 1, autoriteit 100%
Dit hangt sterk af van wat je bedoelt met "terugzetten".
Tijdelijk overschakelen naar een andere commit
Als je er tijdelijk naar terug wilt, wat gek, en dan terug naar waar je bent, hoef je alleen maar de gewenste commit te bekijken:
# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32
Of als je commits wilt maken terwijl je daar bent, ga je gang en maak een nieuwe branch terwijl je toch bezig bent:
git checkout -b old-state 0d1d7fc32
Om terug te gaan naar waar je was, kijk je naar het filiaal waar je was. (Als je wijzigingen hebt aangebracht, zoals altijd bij het wisselen van branches, zul je daar op de juiste manier mee om moeten gaan. Je zou kunnen resetten om ze weg te gooien; je zou kunnen stash, check-out, stash pop om ze mee te nemen; je zou kunnen committen ze naar een filiaal daar als je daar een filiaal wilt.)
Hard verwijderen van niet-gepubliceerde commits
Als je daarentegen echt alles kwijt wilt wat je sindsdien hebt gedaan, zijn er twee mogelijkheden. Ten eerste, als je geen van deze commits hebt gepubliceerd, reset je gewoon:
# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32
# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.
Als je het verknoeit, heb je je lokale wijzigingen al weggegooid, maar je kunt in ieder geval terugkeren naar waar je was door opnieuw te resetten.
Gepubliceerde commits ongedaan maken met nieuwe commits
Aan de andere kant, als je het werk hebt gepubliceerd, wil je de branch waarschijnlijk niet resetten, aangezien dat in feite de geschiedenis herschrijft. In dat geval zou je inderdaad de commits kunnen terugdraaien. Met Git heeft revert een heel specifieke betekenis: maak een commit met de reverse patch om het te annuleren. Op deze manier herschrijft u geen geschiedenis.
# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053
# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD
#Similarly, you can revert a range of commits using commit hashes (non inclusive of first hash):
git revert 0d1d7fc..a867b4a
# Reverting a merge commit
git revert -m 1 <merge_commit_sha>
# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .
# Then commit. Be sure and write a good message describing what you just did
git commit
De git-revert manpage dekt eigenlijk veel hiervan in de beschrijving. Een andere handige link is deze git-scm.com sectie die git bespreekt -terug.
Als u besluit dat u toch niet wilt terugdraaien, kunt u het terugzetten ongedaan maken (zoals hier beschreven) of teruggaan naar vóór het terugzetten (zie het vorige gedeelte).
Misschien vindt u dit antwoord ook nuttig in dit geval:
Hoe kan ik HEAD terugzetten naar een vorige locatie ? (Vrijstaand hoofd) & Toezeggingen ongedaan maken
Antwoord 2, autoriteit 23%
Veel ingewikkelde en gevaarlijke antwoorden hier, maar het is eigenlijk eenvoudig:
git revert --no-commit 0766c053..HEAD
git commit
Dit zal alles van de HEAD terugzetten naar de commit-hash, wat betekent dat het die commit-status in de werkboom opnieuw zal creëren alsof elke commit nadat 0766c053 is gelopen rug. Je kunt dan de huidige tree commit, en het zal een geheel nieuwe commit creëren die in wezen gelijk is aan de commit waarnaar je bent “teruggekeerd”.
(De --no-commit vlag laat git alle commits in één keer terugdraaien – anders wordt je gevraagd om een bericht voor elke commit in het bereik, waardoor je geschiedenis bezaaid wordt met onnodige nieuwe commits .)
Dit is een veilige en gemakkelijke manier om terug te gaan naar een vorige staat. Er wordt geen geschiedenis vernietigd, dus het kan worden gebruikt voor commits die al openbaar zijn gemaakt.
Antwoord 3, autoriteit 16%
Rogue Coder?
Werkt u alleen en wilt u dat het werkt? Volg deze instructies hieronder, ze werken al jaren betrouwbaar voor mij en vele anderen.
Werken met anderen? Git is ingewikkeld. Lees de opmerkingen onder dit antwoord voordat je iets overhaast doet.
Werkkopie terugzetten naar meest recente vastlegging
Om terug te keren naar een eerdere vastlegging en eventuele wijzigingen te negeren:
git reset --hard HEAD
waar HEAD de laatste commit is in je huidige branch
De werkkopie terugzetten naar een oudere commit
Om terug te keren naar een commit die ouder is dan de meest recente commit:
# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced
# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}
git commit -m "Revert to 56e05fced"
# Updates working copy to reflect the new commit
git reset --hard
Credits gaan naar een vergelijkbare Stack Overflow-vraag, Terugzetten naar een commit door een SHA-hash in Git?.
Antwoord 4, autoriteit 2%
De beste optie voor mij en waarschijnlijk anderen is de Git reset-optie:
git reset --hard <commidId> && git clean -f
Dit was de beste optie voor mij! Het is eenvoudig, snel en effectief!
** Opmerking:** Zoals vermeld in opmerkingen, doe dit niet als je je branch deelt met andere mensen die kopieën hebben van de oude commits
Ook uit de opmerkingen, als je een minder ‘ballzy’-methode wilt, kun je
. gebruiken
git clean -i
Antwoord 5, autoriteit 2%
Laten we, voordat we antwoorden, wat achtergrond toevoegen en uitleggen wat deze HEAD is.
First of all what is HEAD?
HEAD is gewoon een verwijzing naar de huidige commit (laatste) op de huidige branch. Er kan slechts één HEAD tegelijk zijn (exclusief git worktree).
De inhoud van HEAD wordt opgeslagen in .git/HEAD en bevat de 40 bytes SHA-1 van de huidige commit.
detached HEAD
Als je niet op de laatste commit zit – wat betekent dat HEAD verwijst naar een eerdere commit in de geschiedenis, wordt het detached HEAD.
Op de opdrachtregel ziet het er als volgt uit – SHA-1 in plaats van de naam van de vertakking aangezien de HEAD niet naar de punt van de huidige vertakking wijst:
Een paar opties om te herstellen van een losgekoppeld HOOFD:
git checkout
git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back
Hiermee wordt een nieuwe branch uitgecheckt die naar de gewenste commit wijst. Dit commando rekent af met een bepaalde commit.
Op dit punt kunt u een vertakking maken en vanaf dit punt beginnen te werken:
# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>
# Create a new branch forked to the given commit
git checkout -b <branch name>
git reflog
Je kunt ook altijd de reflog gebruiken. git reflog zal elke wijziging weergeven die de HEAD heeft bijgewerkt en het uitchecken van de gewenste reflog-invoer zal de HEAD terugzetten naar deze vastlegging.
Elke keer dat de HEAD wordt gewijzigd, komt er een nieuwe vermelding in de reflog
git reflog
git checkout HEAD@{...}
Hiermee kom je terug bij je gewenste commit
git reset HEAD --hard <commit_id>
"Verplaatsen" je hoofd terug naar de gewenste commit.
# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32
# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.
- Opmerking: (Sinds Git 2.7 ) je kunt ook de
git rebase --no-autostashgebruiken.
Dit schema laat zien welk commando wat doet. Zoals je kunt zien daar reset && checkout pas de HEAD aan.
Antwoord 6, autoriteit 2%
Als je wilt “uncommit”, het laatste commit-bericht wissen en de gewijzigde bestanden weer in staging plaatsen, zou je het commando gebruiken:
git reset --soft HEAD~1
--softgeeft aan dat de niet-vastgelegde bestanden moeten worden bewaard als werkbestanden, in tegenstelling tot--harddie ze zouden verwijderen.HEAD~1is de laatste commit. Als je 3 commits wilt terugdraaien, kun jeHEAD~3gebruiken. Als je terug wilt naar een specifiek revisienummer, kun je dat ook doen met de SHA-hash.
Dit is een uiterst nuttig commando in situaties waarin je het verkeerde hebt gepleegd en je die laatste commit ongedaan wilt maken.
Bron: http://nakkaya.com/2009/09/24/git- delete-last-commit/
Antwoord 7, autoriteit 2%
U kunt dit doen met de volgende twee opdrachten:
git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f
Het zal je vorige Git-commit verwijderen.
Als u uw wijzigingen wilt behouden, kunt u ook het volgende gebruiken:
git reset --soft [previous Commit SHA id here]
Vervolgens slaat het uw wijzigingen op.
Antwoord 8
Ik heb veel manieren geprobeerd om lokale wijzigingen in Git terug te draaien, en het lijkt erop dat dit het beste werkt als je gewoon wilt terugkeren naar de laatste commit-status.
git add . && git checkout master -f
Korte beschrijving:
- Het zal GEEN commits maken zoals
git revertdoet. - Het zal je HEAD NIET losmaken zoals
git checkout <commithashcode>doet. - Het ZAL al je lokale wijzigingen overschrijven en alle toegevoegde bestanden VERWIJDEREN sinds de laatste commit in de branch.
- Het werkt alleen met namen van branches, dus je kunt op deze manier alleen terugkeren naar de laatste commit in de branch.
Ik heb een veel handigere en eenvoudigere manier gevonden om de bovenstaande resultaten te bereiken:
git add . && git reset --hard HEAD
waar HEAD verwijst naar de laatste commit in je huidige branch.
Het is dezelfde code als boulder_ruby suggereerde, maar ik heb git add . toegevoegd vóór git reset --hard HEAD om alle nieuwe bestanden te wissen die sinds de laatste commit omdat dit is wat de meeste mensen verwachten als ik terugga naar de laatste commit.
Antwoord 9
De beste manier is:
git reset --hard <commidId> && git push --force
Dit zal de branch resetten naar de specifieke commit en dan zal de remote server uploaden met dezelfde commits als in local.
Wees voorzichtig met de vlag --force aangezien deze alle volgende commits verwijdert na de geselecteerde commit zonder de optie om ze te herstellen.
Antwoord 10
OK, teruggaan naar een eerdere commit in Git is vrij eenvoudig…
Terug terugzetten zonder de wijzigingen te bewaren:
git reset --hard <commit>
Terug met behoud de wijzigingen:
git reset --soft <commit>
Uitleg: door git reset te gebruiken, kun je resetten naar een specifieke status. Het is gebruikelijk om het te gebruiken met een commit-hash zoals je hierboven ziet.
Maar zoals je ziet is het verschil het gebruik van de twee vlaggen --soft en --hard, standaard git reset met --soft vlag, maar het is een goede gewoonte om altijd de vlag te gebruiken, ik leg elke vlag uit:
–zacht
De standaardvlag, zoals uitgelegd, hoeft deze niet te verstrekken, verandert de werkboom niet, maar voegt alle gewijzigde bestanden toe die klaar zijn om vast te leggen, dus je gaat terug naar de vastleggingsstatus waardoor wijzigingen aan bestanden niet meer gestaged worden.
–moeilijk
Wees voorzichtig met deze vlag. Het reset de werkboom en alle wijzigingen in bijgehouden bestanden en alles is verdwenen!
Ik heb ook de onderstaande afbeelding gemaakt die in het echte leven met Git kan gebeuren:
Antwoord 11
Ervan uitgaande dat je het hebt over master en over die respectievelijke branch (dat gezegd hebbende, dit kan elke werkende branch zijn waar je je zorgen over maakt):
# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
# Reset remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master
Ik heb het antwoord gevonden in een blogpost (bestaat nu niet meer)
Merk op dat dit Resetten en forceren van de wijziging naar de afstandsbediening is, zodat als anderen in je team al git Pulled hebben, je problemen voor hen zult veroorzaken. Je vernietigt de wijzigingsgeschiedenis, wat een belangrijke reden is waarom mensen git in de eerste plaats gebruiken.
Het is beter om terugzetten te gebruiken (zie andere antwoorden) dan opnieuw in te stellen.
Als je een eenmansteam bent, maakt het waarschijnlijk niet uit.
Antwoord 12
Stel dat je de volgende commits hebt in een tekstbestand met de naam ~/commits-to-revert.txt (ik gebruikte git log --pretty=oneline om ze te krijgen )
fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca
Maak een Bash-shellscript om ze allemaal terug te zetten:
#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
git revert $i --no-commit
done
Dit zet alles terug naar de vorige staat, inclusief bestands- en directory-creaties en verwijderingen, commit het aan je branch en je behoudt de geschiedenis, maar je hebt het teruggezet naar dezelfde bestandsstructuur. Waarom Git geen git revert --to <hash> heeft, is mij een raadsel.
Antwoord 13
Extra alternatieven voor Jefromi’s oplossingen
Jefromi’s oplossingen zijn absoluut de beste, en je moet ze zeker gebruiken. Voor de volledigheid wilde ik echter ook deze andere alternatieve oplossingen laten zien die ook kunnen worden gebruikt om een commit terug te draaien (in de zin dat je een nieuwe commit maakt die wijzigingen in de vorige commit ongedaan maakt, net zoals wat git revert doet).
Voor alle duidelijkheid, deze alternatieven zijn niet de beste manier om commits terug te draaien, Jefromi’s oplossingen zijn, maar ik wil er alleen op wijzen dat je deze andere methoden ook kunt gebruiken om hetzelfde te bereiken als git revert.
Alternatief 1: harde en zachte reset
Dit is een zeer licht gewijzigde versie van de oplossing van Charles Bailey voor Terugkeren naar een commit door een SHA-hash in Git?:
# Reset the index to the desired commit
git reset --hard <commit>
# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}
# Commit the changes
git commit -m "Revert to <commit>"
Dit werkt in principe door gebruik te maken van het feit dat zachte resets de status van de vorige vastlegging in het index/staging-gebied laten staan, die u vervolgens kunt vastleggen.
Alternatief 2: verwijder de huidige structuur en vervang deze door de nieuwe
Deze oplossing komt van de oplossing van svick tot Oude commit afrekenen en een nieuwe commit maken:
git rm -r .
git checkout <commit> .
git commit
Net als bij alternatief #1, reproduceert dit de toestand van <commit> in de huidige werkkopie. Het is noodzakelijk om eerst git rm te doen omdat git checkout geen bestanden zal verwijderen die zijn toegevoegd sinds <commit>.
Antwoord 14
Hier is een veel eenvoudigere manier om terug te gaan naar een eerdere commit (en deze in een niet-gecommitteerde staat te houden, om ermee te doen wat je maar wilt):
git reset HEAD~1
Dus geen commit-ID’s en dergelijke meer nodig 🙂
Antwoord 15
Na alle wijzigingen, als je al deze commando’s pusht, moet je misschien het volgende gebruiken:
git push -f ...
En niet alleen git push.
Antwoord 16
Er is een commando (geen onderdeel van core Git, maar het zit in het git-extras pakket) specifiek voor het terugzetten en ensceneren van oude commits:
git back
Volgens de man-pagina kan het ook als zodanig worden gebruikt:
# Remove the latest three commits
git back 3
Antwoord 17
Let op! Dit commando kan ertoe leiden dat de commit-geschiedenis verloren gaat, als de gebruiker per ongeluk de verkeerde commit heeft ingevoerd. Altijd een extra back-up van je git some
waar anders voor het geval je fouten maakt, dan ben je een beetje veiliger.
🙂
Ik heb een soortgelijk probleem gehad en wilde teruggaan naar een eerdere commit. In mijn geval was ik niet geïnteresseerd om de nieuwere commit te behouden, daarom gebruikte ik Hard.
Dit is hoe ik het deed:
git reset --hard CommitId && git clean -f
Dit zal terugkeren naar de lokale repository, en hier na het gebruik van git push -f zal de remote repository worden bijgewerkt.
git push -f
Als je bijvoorbeeld de commit met de naam enforce non-group manage policies vanaf de volgende afbeelding volledig wilt negeren
je zou rennen
git reset --hard dd52eb9 && git clean -f
gevolgd door
git push -f
Daarna zie je die commit (enforce non-group manage policies) daar niet
Antwoord 18
Je kunt al deze eerste stappen zelf voltooien en teruggaan naar de Git-repository.
-
Haal de nieuwste versie van uw repository uit Bitbucket met behulp van de opdracht
git pull --all. -
Voer het Git log commando uit met
-n 4vanaf je terminal. Het getal na de-nbepaalt het aantal commits in het log vanaf de meest recente commit in je lokale geschiedenis.$ git log -n 4 -
Reset de kop van de geschiedenis van je repository met behulp van de
git reset --hard HEAD~Nwaarbij N het aantal commits is dat je de kop terug wilt nemen. In het volgende voorbeeld zou de head één commit worden teruggezet, naar de laatste commit in de repositorygeschiedenis: -
Push de wijziging naar de Git-repository met
git push --forceom de wijziging te forceren.
Als je de Git-repository naar een eerdere commit wilt:
git pull --all
git reset --hard HEAD~1
git push --force
Antwoord 19
Keer terug naar meest recente commit en negeer alle lokale wijzigingen:
git reset --hard HEAD
Antwoord 20
Selecteer uw vereiste commit en controleer deze door
git show HEAD
git show HEAD~1
git show HEAD~2
totdat je de vereiste commit krijgt. Om de HEAD daarop te laten wijzen, doe je
git reset --hard HEAD~1
of git reset --hard HEAD~2 of wat dan ook.
Antwoord 21
Als de situatie dringend is, en u wilt gewoon doen wat de vraagsteller op een snelle en vuile manier heeft gevraagd, ervan uitgaande dat uw project zich in een map bevindt met de naam , bijvoorbeeld “mijn project”:
QUICK AND DIRTY: afhankelijk van de omstandigheden kan snel en vies in feite heel GOED zijn. Wat mijn oplossing hier doet, is NIET de bestanden die je in je werkmap hebt onomkeerbaar vervangen door bestanden die zijn opgehaald/geëxtraheerd uit de diepten van de git-repository die zich onder je .git/-map op de loer ligt met behulp van duivels slim en duivels krachtig git-commando’s, waarvan er veel zijn. JE HOEFT DERGELIJKE DIEPZEE DUIKEN NIET TE DOEN OM TE HERSTELLEN wat een rampzalige situatie lijkt te zijn, en een poging om dit te doen zonder voldoende expertise kan fataal zijn.
-
Kopieer de hele map en noem het iets anders, zoals “mijn project – kopiëren”. Ervan uitgaande dat je git-repository (“repo”)-bestanden zich in de “my project”-directory bevinden (de standaardplaats voor hen, onder een directory genaamd “.git”), heb je nu zowel je werkbestanden als je repo-bestanden gekopieerd.
-
Doe dit in de map “mijn project”:
.../my project $ git reset --hard [first-4-letters&numbers-of-commit's-SHA]
Dit zal de staat van de repo onder “mijn project” terugbrengen naar wat het was toen je die commit maakte (een “commit” betekent een momentopname van je werkbestanden). Alle commits sindsdien zullen voor altijd verloren gaan onder “mijn project”, MAAR… ze zullen nog steeds aanwezig zijn in de repo onder “mijn project – kopie” sinds je alles die bestanden – inclusief die onder …/.git/.
Je hebt dan twee versies op je systeem… je kunt interessante bestanden, of wat dan ook, van de vorige commit bekijken, kopiëren of wijzigen. Je kunt de bestanden onder “mijn project – kopie” volledig weggooien, als je hebt besloten dat het nieuwe werk, aangezien de herstelde commit nergens toe leidde…
Het ligt voor de hand als je door wilt gaan met de status van het project zonder het werk daadwerkelijk weg te gooien, aangezien deze opgehaalde commit je directory opnieuw moet hernoemen: verwijder het project dat de opgehaalde commit bevat (of geef het een tijdelijke naam) en hernoem je “mijn project – kopieer” map terug naar “mijn project”. Probeer dan misschien enkele van de andere antwoorden hier te begrijpen, en doe waarschijnlijk vrij snel nog een commit.
Git is een briljante creatie, maar absoluut niemand is in staat om het “on the fly op te pakken”: ook mensen die het veel te vaak proberen uit te leggen, veronderstellen voorkennis van andere VCS [ Version Control Systems] en veel te snel veel te diep graven, en andere misdaden begaan, zoals het gebruik van verwisselbare termen voor “uitchecken” – op manieren die soms bijna berekend lijken om een beginner te verwarren.
Leer van mijn littekens om jezelf veel stress te besparen. Je moet zo’n beetje een boek over Git lezen – ik zou “Versiebeheer met Git aanraden “. Doe het eerder vroeger dan later. Als je dat doet, houd er dan rekening mee dat veel van de complexiteit van Git afkomstig is van vertakkingen en vervolgens opnieuw samenvoegen: je kunt die delen in elk boek overslaan. Op basis van je vraag is er geen reden waarom mensen je zouden verblinden met wetenschap.
Vooral als dit bijvoorbeeld een wanhopige situatie is en je een beginner bent met Git!
PS: Nog een andere gedachte: het is (nu) eigenlijk vrij eenvoudig om de Git-repo in een andere directory te bewaren dan die met de werkbestanden. Dit zou betekenen dat je niet de hele Git-repository hoeft te kopiëren met behulp van de bovenstaande snelle & vuile oplossing. Zie het antwoord van Fryer met behulp van --separate-git-dir hier. Wees echter gewaarschuwd: als je een “aparte-directory” repository hebt die je niet kopieert, en je een harde reset uitvoert, zullen alle versies die volgen op de reset-commit voor altijd verloren gaan, tenzij je hebben, zoals u absoluut zou moeten doen, regelmatig een back-up van uw repository gemaakt, bij voorkeur naar de cloud (bijv. Google Drive) onder andere.
Over dit onderwerp van “back-up naar de cloud” is de volgende stap het openen van een account (uiteraard gratis) bij GitHub of (beter in mijn ogen) GitLab. U kunt dan regelmatig een git push commando uitvoeren om uw Cloud repo “goed” up-to-date te maken. Maar nogmaals, hierover praten is misschien te snel.
Antwoord 22
Dit is nog een manier om direct te resetten naar een recente commit
git stash
git stash clear
Het wist direct alle wijzigingen die je hebt aangebracht sinds de laatste vastlegging.
PS: Er is een klein probleempje; het verwijdert ook alle recentelijk opgeslagen stash-wijzigingen. Wat volgens mij in de meeste gevallen niet uitmaakt.
Antwoord 23
Om de directory van een codeerder volledig op te schonen van enkele onbedoelde wijzigingen, gebruikten we:
git add -A .
git reset --hard HEAD
Gewoon git reset --hard HEAD verwijdert wijzigingen, maar “nieuwe” bestanden niet. In hun geval hadden ze per ongeluk een belangrijke map naar een willekeurige plek gesleept, en al die bestanden werden door Git als nieuw behandeld, dus een reset --hard loste het niet op. Door vooraf de git add -A . uit te voeren, volgde het ze allemaal expliciet met git, om te worden weggevaagd door de reset.
Antwoord 24
Ik denk dat sommige mensen op deze vraag komen en willen weten hoe ze vastgelegde wijzigingen die ze in hun master hebben aangebracht, ongedaan kunnen maken – dwz alles weggooien en teruggaan naar de oorsprong/master, in welk geval, doe dit:
git reset --hard origin/master
https://superuser.com/questions/273172/how-to -reset-master-naar-origin-master
Antwoord 25
Om de wijzigingen van de vorige commit naar HEAD te behouden en naar de vorige commit te gaan, doe je:
git reset <SHA>
Als er geen wijzigingen nodig zijn van de vorige commit naar HEAD en alle wijzigingen weggooien, doe dan:
git reset --hard <SHA>
Antwoord 26
Revert is het commando om de commits terug te draaien.
git revert <commit1> <commit2>
Voorbeeld:
git revert 2h3h23233
Het is in staat om afstand te nemen van het HEAD zoals hieronder. Hier zegt 1 "laatste commit terugzetten."
git revert HEAD~1..HEAD
En doe dan:
git push
Antwoord 27
Idee: je wilt in principe de huidige werkboomstatus vervangen door die van een eerdere commit en er vervolgens een commit van maken. Genegeerde bestanden kunnen het beste niet worden gewijzigd. Hier is hoe:
-
Leeg de werkboom *.
git rm -r --cached . && git clean -f -d -
Breng de werkboom in de gewenste staat **.
git checkout 0d1d7fc3 . -
Maak de terugzet-commit.
git add --all && git commit -m "revert to 0d1d7fc3"
Eerst dacht ik dat Yarins-antwoord het beste zou zijn, maar het werkt niet voor merge-commits. Deze oplossing wel.
Bovendien verwijdert het niets (geduwd of gepusht) uit de geschiedenis. Het produceert één schone commit die de staat vertegenwoordigt waarnaar we willen terugkeren.
* door niet-gevolgde maar niet genegeerde bestanden (degene gespecificeerd in .gitignore) uit de werkboom te verwijderen. De werkboom is leeg, behalve de genegeerde bestanden die we wilden behouden (indien niet, specificeer -x optie voor clean)
** Wanneer een pad is opgegeven (hier: .), laat de kassa alleen HEAD achter.
Antwoord 28
Omdat je commits op afstand worden gepusht, moet je ze verwijderen. Laat me aannemen dat uw branch develop is en dat deze over origin wordt gepusht.
U moet eerst develop verwijderen uit oorsprong:
git push origin :develop (note the colon)
Dan moet je de status krijgen die je wilt, laat me aannemen dat de commit-hash EFGHIJK is:
git reset --hard EFGHIJK
Druk tot slot nogmaals op develop:
git push origin develop
Antwoord 29
Probeer te resetten naar de gewenste commit:
git reset <COMMIT_ID>
Om COMMIT_ID te controleren, gebruik:
git log
Hiermee worden alle gewijzigde bestanden teruggezet naar de status niet-toegevoegd.
Nu kunt u alle niet-toegevoegde bestanden checkout door
git checkout .
Gebruik om uw wijzigingen te verifiëren:
git log
UPDATE
Als je één en enige commit in je repo hebt, probeer dan
git update-ref -d HEAD
Antwoord 30
Voor terugdraaien (of terugzetten):
1. git revert --no-commit "commit-code-to-remove" HEAD
(e.g. git revert --no-commit d57a39d HEAD)
2. git commit
3. git push
Probeer de bovenstaande twee stappen, en als je vindt dat dit is wat je wilt, git push.
Als je iets verkeerd vindt, doe dan:
git revert --abort