Als gevolg van een slechte selectie van de kers op de taart, is mijn lokale Git-repository momenteel vijf commits voor op de oorsprong, en niet in een goede staat. Ik wil van al deze verplichtingen af en opnieuw beginnen.

Natuurlijk zou het verwijderen van mijn werkdirectory en opnieuw klonen voldoende zijn, maar alles opnieuw downloaden van GitHub lijkt overdreven en geen goede besteding van mijn tijd.

Misschien is git revertwat ik nodig heb, maar ik wil niet eindigen met 10commits voor de oorsprong (of zelfs zes), zelfs als dat zo is de code zelf weer in de juiste staat krijgen. Ik wil gewoon doen alsof het laatste half uur nooit is gebeurd.

Is er een eenvoudig commando om dit te doen? Het lijkt een voor de hand liggende use case, maar ik kan er geen voorbeelden van vinden.

Merk op dat deze vraag specifiek gaat over toezeggingen, nietover:

niet-getrackte bestanden
niet-gefaseerde wijzigingen
gefaseerde, maar niet-vastgelegde wijzigingen

Antwoord 1, autoriteit 100%

Als je overtollige toezeggingen alleen voor jou zichtbaar zijn, kun je dat gewoon doen
git reset --hard origin/<branch_name>
om terug te gaan naar waar de oorsprong is. Dit zal de staat van de repository resetten naar de vorige commit, en het zal alle lokale veranderingen negeren.

Het doen van een git revertmaakt nieuwecommits om oudecommits te verwijderen op een manier die ieders geschiedenis helder houdt.

Antwoord 2, autoriteit 11%

Verwijder eenvoudig je lokale master branch en maak het als volgt opnieuw aan:

git branch -D master
git checkout origin/master -b master

Antwoord 3, autoriteit 8%

Probeer:

git reset --hard <the sha1 hash>

om je hoofd te resetten naar waar je maar wilt. Gebruik gitk om te zien bij welke commit je wilt zijn. Je kunt ook resetten binnen gitk.

Antwoord 4, autoriteit 7%

Verwijder de meest recente vastlegging:

git reset --hard HEAD~1

Verwijder de meest recente commit, zonder het werk dat je hebt gedaan te vernietigen:

git reset --soft HEAD~1

Antwoord 5, autoriteit 2%

Bij uw filiaalpoging:

git reset --hard origin/<branch_name>

Valideer de omkering (naar de staat, zonder lokale commits), met behulp van “git log” of “git status” vandaar.

Antwoord 6, autoriteit 2%

Als u de app Atlassian SourceTreegebruikt, kunt u de reset-optie in het contextmenu gebruiken.

Antwoord 7

Eenvoudige oplossing is om de lokale master branch HEAD te matchen met origin/master branch HEAD

git reset --hard origin/master

PS: origin/master – is een remote pointer naar de master branch.
U kunt de master vervangen door elke vertakkingsnaam

Antwoord 8

git reset --hard @{u}* verwijdert al je lokale wijzigingen in de huidige branch, inclusief commits. Het verbaast me dat nog niemand dit heeft gepost, aangezien je niet hoeft op te zoeken naar welke commit je moet terugkeren of met branches hoeft te spelen.

_{* Dat wil zeggen, reset naar de huidige branch op @{upstream}—meestal origin/<branchname>, maar niet altijd}

Antwoord 9

Laten we, voordat we antwoorden, wat achtergrond toevoegen en uitleggen wat dit HEADis. aangezien sommige van de onderstaande opties resulteren in een losstaand hoofd

`First of all what is HEAD?`

HEADis gewoon een verwijzing naar de huidige commit (laatste) op de huidige branch.
Er kan slechts één HEADtegelijk zijn. (exclusief git worktree)

De inhoud van HEADwordt opgeslagen in .git/HEADen bevat de 40 bytes SHA-1 van de huidige commit.

`detached HEAD`

Als je niet op de laatste commit zit – wat betekent dat HEADverwijst naar een eerdere commit in de geschiedenis, wordt dit detached HEAD.

Op de opdrachtregel ziet het er als volgt uit: SHA-1 in plaats van de naam van de vertakking, aangezien de HEADniet 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 checkt uit naar een bepaalde commit.
Op dit punt kun je een branch 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 refloggebruiken.
git reflogzal elke wijziging weergeven die de HEADheeft bijgewerkt en het uitchecken van de gewenste reflog-invoer zal de HEADterugzetten 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 --hard <commit_id>`

Beweeg je HEAD 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.

`git revert <sha-1>`

Maak het opgegeven commit- of commit-bereik ongedaan.
Het reset-commando zal alle wijzigingen die in de gegeven commit zijn gemaakt “ongedaan maken”.
Een nieuwe commit met de undo-patch zal worden vastgelegd terwijl de originele commit ook in de geschiedenis blijft.

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

Dit schema laat zien welke opdracht wat doet.
Zoals je kunt zien daar reset && checkoutpas de HEADaan.

Antwoord 10

Om de SHA-1 id van de commit te zien/krijgen waar je ook op terug wilt komen

gitk --all

Teruggaan naar die toezegging

git reset --hard sha1_id

!Opmerking. Alle commits die na die commit zijn gemaakt, worden verwijderd (en al je wijzigingen aan het project). Dus eerst het project beter klonen naar een andere branch of naar een andere directory kopiëren.

Antwoord 11

Ik had een situatie waarin ik een commit wilde verwijderen die niet was gepusht, maar de commit was voor een andere. Om dit te doen, heb ik de volgende opdracht gebruikt

git rebase -i HEAD~2-> het zal de laatste twee commits rebasen

En ik gebruikte ‘drop’ voor de commit-handtekening die ik wilde verwijderen.

Antwoord 12

Verwijder niet-bijgehouden bestanden (niet-vastgelegde lokale wijzigingen)

git clean -df

Alle lokale commits permanent verwijderen en de nieuwste externe commit ophalen

git reset --hard origin/<branch_name>

13

Als
Uw tak staat voor ‘origin/XXX‘ door 5 Commits.

U kunt afgeven:

git reset --hard HEAD~5

en het zou de laatste 5 commits moeten verwijderen.

14

Gebruik een willekeurig aantal keren, om terug te keren naar de laatste commit zonder alle bestanden te verwijderen die u recent hebt gemaakt.

git reset --soft HEAD~1

Gebruik vervolgens

git reset HEAD <name-of-file/files*>

naar unstage of untrack.

15

Voor lokale commits die niet worden geduwd, kunt u ook git rebase -igebruiken om een commit te verwijderen of te pletten.

16

Als u gewoon de lokale commits wilt weggooien en de wijzigingen in bestanden hebt gedaan, doen dan
Git Reset @ ~
Andere antwoorden behandelden de harde reset

17

Zoek de SHA1 voor de commit die u wilt terugkeren naar:

za$ git reflog
... snip ...
cf42fa2... HEAD@{0}: commit: fixed misc bugs
~
~
cf42fa2... HEAD@{84}: commit: fixed params for .....
73b9363... HEAD@{85}: commit: Don't symlink to themes on deployment.
547cc1b... HEAD@{86}: commit: Deploy to effectif.com web server.
1dc3298... HEAD@{87}: commit: Updated the theme.
18c3f51... HEAD@{88}: commit: Verify with Google webmaster tools.
26fbb9c... HEAD@{89}: checkout: moving to effectif

En gebruik dan –mixed flag zodat je “HEAD en index reset”:

za$ git reset --mixed cf42fa2

Beschikbare vlaggen:

za$ git reset -h
-q, --quiet           be quiet, only report errors
--mixed               reset HEAD and index
--soft                reset only HEAD
--hard                reset HEAD, index and working tree
--merge               reset HEAD, index and working tree
--keep                reset HEAD but keep local changes
--recurse-submodules[=<reset>]
                      control recursive updating of submodules
-p, --patch           select hunks interactively
-N, --intent-to-add

Antwoord 18

git reset --hard <SHA-Code>

Dit is handig als je fouten hebt gemaakt in je lokale kopie waarvan je wilt voorkomen dat ze per ongeluk naar je remote branch worden gepusht.

De SHA-code kan worden verkregen door naar de webversie van je git-dashboard te kijken voor de laatste commit op de branch.

Op deze manier kun je synchroniseren met de laatste commit op de branch.

Je kunt git pulldoen nadat je de harde reset met succes hebt voltooid om niets nieuws voor syn te bevestigen, d.w.z. je krijgt het bericht te zien.

Uw filiaal is up-to-date met Origin/<Branch Name>

Antwoord 19

Als je je lokale repo in een complete puinhoop brengt, dan is een betrouwbare manier om lokale commits in Git weg te gooien om…

Gebruik “git config –get remote.origin.url” om de URL van de externe oorsprong te krijgen
Hernoem de lokale git-map naar “my_broken_local_repo”
Gebruik “git-kloon <url_from_1>” om een verse lokale kopie van de externe git-repository te krijgen

Mijn ervaring is dat Eclipse goed omgaat met de veranderende wereld eromheen. Het is echter mogelijk dat u de betrokken projecten in Eclipse moet selecteren en opschonen om Eclipse te dwingen ze opnieuw op te bouwen. Ik denk dat andere IDE’s ook een gedwongen herbouw nodig hebben.

Een bijkomend voordeel van de bovenstaande procedure is dat je zult ontdekken of je project afhankelijk is van lokale bestanden die niet in git zijn geplaatst. Als je merkt dat je bestanden mist, kun je ze kopiëren vanuit “my_broken_local_repo” en ze toevoegen aan git. Zodra u er zeker van bent dat uw nieuwe lokale opslagplaats alles heeft wat u nodig heeft, kunt u “my_broken_local_repo” verwijderen.

Gooi lokale commits weg in Git