Hoe kan ik git reset –hard HEAD~1 ongedaan maken?

Is het mogelijk om de wijzigingen die door de volgende opdracht zijn veroorzaakt ongedaan te maken? Zo ja, hoe?

git reset --hard HEAD~1

Antwoord 1, autoriteit 100%

Pat Notz heeft gelijk. Je kunt de commit binnen een paar dagen terugkrijgen. git verzamelt pas afval na ongeveer een maand of zo, tenzij je het expliciet vertelt om nieuwere blobs te verwijderen.

$ git init
Initialized empty Git repository in .git/
$ echo "testing reset" > file1
$ git add file1
$ git commit -m 'added file1'
Created initial commit 1a75c1d: added file1
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 file1
$ echo "added new file" > file2
$ git add file2
$ git commit -m 'added file2'
Created commit f6e5064: added file2
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 file2
$ git reset --hard HEAD^
HEAD is now at 1a75c1d... added file1
$ cat file2
cat: file2: No such file or directory
$ git reflog
1a75c1d... [email protected]{0}: reset --hard HEAD^: updating HEAD
f6e5064... [email protected]{1}: commit: added file2
$ git reset --hard f6e5064
HEAD is now at f6e5064... added file2
$ cat file2
added new file

Je kunt in het voorbeeld zien dat de file2 is verwijderd als gevolg van de harde reset, maar weer op zijn plaats is gezet toen ik reset via de reflog.


Antwoord 2, autoriteit 21%

Wat je wilt doen is de sha1 specificeren van de commit waarnaar je wilt herstellen. Je kunt de sha1 krijgen door de reflog te onderzoeken (git reflog) en dan te doen

git reset --hard <sha1 of desired commit>

Maar wacht niet te lang… na een paar weken zal git die commit uiteindelijk als niet-gerefereerd zien en alle blobs verwijderen.


Antwoord 3, autoriteit 10%

Het antwoord is verborgen in het gedetailleerde antwoord hierboven, u kunt eenvoudig het volgende doen:

$> git reset --hard [email protected]{1}

(Zie de uitvoer van git reflog show)


Antwoord 4, autoriteit 6%

Het is mogelijk om het te herstellen als Git nog geen afval heeft verzameld.

Krijg een overzicht van bungelende commits met fsck:

$ git fsck --lost-found
dangling commit b72e67a9bb3f1fc1b64528bcce031af4f0d6fcbf

Herstel de bungelende commit met rebase:

$ git rebase b72e67a9bb3f1fc1b64528bcce031af4f0d6fcbf

Antwoord 5, autoriteit 4%

voor zover ik weet, zal --hardniet-vastgelegde wijzigingen negeren. Aangezien deze niet worden bijgehouden door git. maar je kunt de discarded commitongedaan maken.

$ git reflog

zal lijsten:

b0d059c [email protected]{0}: reset: moving to HEAD~1
4bac331 [email protected]{1}: commit: added level introduction....
....

waarbij 4bac331de discarded commitis.

Verplaats nu gewoon de kop naar die commit::

$ git reset --hard 4bac331

Antwoord 6, autoriteit 3%

Als je echt geluk hebt, zoals ik, kun je teruggaan naar je teksteditor en op ‘ongedaan maken’ klikken.

Ik weet dat dit niet echt een goed antwoord is, maar het heeft me een halve dag werk bespaard, dus hopelijk doet het hetzelfde voor iemand anders!


7, Autoriteit 2%

Voorbeeld van irl case:

$ git fsck --lost-found

Checking object directories: 100% (256/256), done.
Checking objects: 100% (3/3), done.
dangling blob 025cab9725ccc00fbd7202da543f556c146cb119
dangling blob 84e9af799c2f5f08fb50874e5be7fb5cb7aa7c1b
dangling blob 85f4d1a289e094012819d9732f017c7805ee85b4
dangling blob 8f654d1cd425da7389d12c17dd2d88d318496d98
dangling blob 9183b84bbd292dcc238ca546dab896e073432933
dangling blob 1448ee51d0ea16f259371b32a557b60f908d15ee
dangling blob 95372cef6148d980ab1d7539ee6fbb44f5e87e22
dangling blob 9b3bf9fb1ee82c6d6d5ec9149e38fe53d4151fbd
dangling blob 2b21002ca449a9e30dbb87e535fbd4e65bac18f7
dangling blob 2fff2f8e4ea6408ac84a8560477aa00583002e66
dangling blob 333e76340b59a944456b4befd0e007c2e23ab37b
dangling blob b87163c8def315d40721e592f15c2192a33816bb
dangling blob c22aafb90358f6bf22577d1ae077ad89d9eea0a7
dangling blob c6ef78dd64c886e9c9895e2fc4556e69e4fbb133
dangling blob 4a71f9ff8262701171d42559a283c751fea6a201
dangling blob 6b762d368f44ddd441e5b8eae6a7b611335b49a2
dangling blob 724d23914b48443b19eada79c3eb1813c3c67fed
dangling blob 749ffc9a412e7584245af5106e78167b9480a27b
dangling commit f6ce1a403399772d4146d306d5763f3f5715cb5a    <- it's this one

$ git show f6ce1a403399772d4146d306d5763f3f5715cb5a

commit f6ce1a403399772d4146d306d5763f3f5715cb5a
Author: Stian Gudmundsen Høiland <[email protected]>
Date:   Wed Aug 15 08:41:30 2012 +0200
    *MY COMMIT MESSAGE IS DISPLAYED HERE*
diff --git a/Some.file b/Some.file
new file mode 100644
index 0000000..15baeba
--- /dev/null
+++ b/Some.file
*THE WHOLE COMMIT IS DISPLAYED HERE*

$ git rebase f6ce1a403399772d4146d306d5763f3f5715cb5a

First, rewinding head to replay your work on top of it...
Fast-forwarded master to f6ce1a403399772d4146d306d5763f3f5715cb5a.

Antwoord 8

git reflog

  • Zoek je commit sha in de lijst en kopieer en plak het in dit commando:

git cherry-pick <the sha>


Antwoord 9

Als je je repository nog niet hebt verzameld (bijvoorbeeld met behulp van git repack -dof git gc, maar houd er rekening mee dat het verzamelen van afval ook automatisch kan gebeuren), dan is je commit is er nog – het is alleen niet langer bereikbaar via de HEAD.

Je kunt proberen je commit te vinden door de uitvoer van git fsck --lost-foundte bekijken.

Nieuwere versies van Git hebben iets dat de “reflog” wordt genoemd, wat een log is van alle wijzigingen die zijn aangebracht in de refs (in tegenstelling tot wijzigingen die zijn aangebracht in de inhoud van de repository). Dus, bijvoorbeeld, elke keer dat je van HEAD wisselt (d.w.z. elke keer dat je een git checkoutdoet om van branch te wisselen), wordt dat gelogd. En natuurlijk manipuleerde je git resetook de HEAD, dus het werd ook gelogd. U kunt toegang krijgen tot oudere statussen van uw refs op een vergelijkbare manier als voor oudere statussen van uw repository, door een @-teken te gebruiken in plaats van een ~, zoals git reset [email protected]{1}.

Het duurde even voordat ik begreep wat het verschil is tussen [email protected]{1} en HEAD~1, dus hier is een kleine uitleg:

git init
git commit --allow-empty -mOne
git commit --allow-empty -mTwo
git checkout -b anotherbranch
git commit --allow-empty -mThree
git checkout master # This changes the HEAD, but not the repository contents
git show HEAD~1 # => One
git show [email protected]{1} # => Three
git reflog

Dus HEAD~1betekent “ga naar de commit voor de commit waar HEAD momenteel naar verwijst”, terwijl [email protected]{1}betekent “ga naar de commit waar HEAD naar wees voordat het wees naar waar het momenteel naar wijst”.

Zo kun je gemakkelijk je verloren commit vinden en herstellen.


Antwoord 10

Als u een JetBrains IDE gebruikt (alles wat op IntelliJ is gebaseerd), kunt u zelfs uw niet-vastgelegde wijzigingen herstellen via hun functie “Lokale geschiedenis”.

Klik met de rechtermuisknop op uw map op het hoogste niveau in uw bestandsstructuur, zoek “Lokale geschiedenis” in het contextmenu en kies “Geschiedenis weergeven”. Dit opent een weergave waar uw recente bewerkingen kunnen worden gevonden, en zodra u de revisie heeft gevonden waarnaar u wilt terugkeren, klikt u er met de rechtermuisknop op en klikt u op “Terugzetten”.


Antwoord 11

Laten we, voordat we antwoorden, wat achtergrond toevoegen en uitleggen wat dit HEADis.

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 reflog zal 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 [email protected]{...}

Hiermee kom je terug bij je gewenste commit


git reset HEAD --hard <commit_id>

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


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 illustreert welke opdracht wat doet.
Zoals je kunt zien daar reset && checkoutpas de HEADaan.


Antwoord 12

Ik weet dat dit een oude thread is… maar aangezien veel mensen zoeken naar manieren om dingen in Git ongedaan te maken, denk ik nog steeds dat het een goed idee is om hier tips te blijven geven.

Als je een “git add” doet of iets van linksboven naar linksonder in git gui verplaatst, wordt de inhoud van het bestand opgeslagen in een blob en is het mogelijk om de inhoud van het bestand van die blob te herstellen.

Dus het is mogelijk om een ​​bestand te herstellen, zelfs als het niet is gepleegd, maar het moet zijn toegevoegd.

git init  
echo hello >> test.txt  
git add test.txt  

Nu is de BLOB gemaakt, maar wordt verwezen door de index zodat deze niet wordt vermeld met Git FSCK totdat we worden gereset. Dus we resetten …

git reset --hard  
git fsck  

U krijgt een bungelende BLOB CE013625030BA8DBA906F756967F9E9CA394464A

git show ce01362  

geeft u het bestandsinhoud “Hallo” terug

Om niet-gerepareerde commits te vinden, vond ik een tip ergens suggereert dit.

gitk --all $(git log -g --pretty=format:%h)  

Ik heb het als een hulpmiddel in Git GUI en het is erg handig.


13

maakte een klein script om het iets gemakkelijker te maken om de commit te vinden die je zoekt:

git fsck --lost-found | grep commit | cut -d ' ' -f 3 | xargs -i git show \{\} | egrep '^commit |Date:'

Ja, het kan aanzienlijk mooier worden gemaakt met awk of zoiets, maar het is eenvoudig en ik had het gewoon nodig. Kan iemand anders 30 seconden opslaan.


14

Ik heb net een harde reset gedaan op verkeerd project. Wat mijn leven heeft opgeslagen, was de lokale geschiedenis van Eclipse. Intellij-idee wordt gezegd dat ik er ook een heb, en zo kan je redacteur, het is de moeite waard om te controleren:

  1. eclipse help-onderwerp op de lokale geschiedenis
  2. http://wiki.eclipse.org/faq_where_is_the_workspace_local_history_stured%3f

15

Dit heeft mijn leven opgeslagen:
https://medium.com/@CarrieGuss/how-to-recover-from-a-git-hard-reset-b830b5e3f60c

In principe moet je uitvoeren:

for blob in $(git fsck --lost-found | awk ‘$2 == “blob” { print $3 }’); do git cat-file -p $blob > $blob.txt; done

Vervolgens handmatig door de pijn gaan om uw bestanden te reorganiseren naar de juiste structuur.

Afhaalmaaltijden: gebruik nooit git reset --hardals je niet 100% begrijpt hoe het werkt, gebruik het dan beter niet.


Antwoord 16

git reflogen terug naar de laatste HEAD
6a56624 (HEAD -> master) [email protected]{0}: reset: verplaatsen naar HEAD~3
1a9bf73 [email protected]{1}: commit: wijzigingen in model toevoegen binair genereren


Antwoord 17

Mijn probleem is bijna hetzelfde. Ik heb niet-toegewezen bestanden voordat ik git reset --hardinvoer.

Gelukkig. Ik heb al deze bronnen kunnen overslaan. Nadat ik merkte dat ik het gewoon ongedaan kan maken (ctrl-z). 😊 Ik wil dit gewoon toevoegen aan alle bovenstaande antwoorden.

Opmerking. Het is niet mogelijk om ongeopende bestanden te ctrl-z.


Antwoord 18

git reset –hard – je kunt gebruiken om een pagina terug te zetten en daarna kun je alles weer van de oorsprong opbergen of eruit halen

Other episodes