it-swarm-eu.dev

Jak mohu zrušit poslední potvrzení v programu Git?

Neúmyslně jsem spáchal špatné soubory do Git , ale ještě jsem neposlal příkaz na server.

Jak mohu vrátit tyto potvrzení z lokálního úložiště? 

19077
Hamza Yerlikaya

Vrátit potvrzení a opakovat

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  1. To je to, co chcete vrátit zpět.
  2. Tím zůstane váš pracovní strom (stav souborů na disku) beze změny, ale odvolání se zruší a změny, které jste se dopustili, zůstanou nezměněné (takže se v souboru git status objeví jako „Změny se neuskutečnily“). znovu před spácháním). Pokud chcete pouze chtít přidat více změn do předchozího potvrzení nebo změnit zprávu o potvrzení1můžete místo toho použít git reset --soft HEAD~, což je jako git reset HEAD~ (kde HEAD~ je stejné jako HEAD~1), ale ponechává vaše stávající změny v pořádku.
  3. Proveďte opravy souborů pracovních stromů.
  4. git add cokoliv, co chcete zahrnout do nového odevzdání.
  5. Potvrďte změny a znovu použijte starou zprávu. reset zkopíruje starou hlavu do .git/ORIG_HEAD; commit s -c ORIG_HEAD otevře editor, který zpočátku obsahuje zprávu ze starého potvrzení a umožňuje jej editovat. Pokud zprávu nepotřebujete upravovat, můžete použít volbu -C.

Dejte si však pozor na to, že pokud jste přidali nějaké nové změny do indexu, pomocí commit --amend se přidá do vašeho předchozího potvrzení.

Pokud je kód již odeslán na server a máte oprávnění přepsat historii (rebase), pak:

git Push Origin master --force

Můžete se také podívat na tuto odpověď: 

Jak přesunout HEAD zpět na předchozí místo? (Samostatná hlava)

Výše uvedená odpověď vám ukáže git reflog, který se používá pro zjištění, co je to SHA-1, ke kterému se chcete vrátit. Jakmile najdete bod, ke kterému chcete vrátit zpět, použijte posloupnost příkazů, jak je popsáno výše.


1 Všimněte si však, že nemusíte resetovat dřívější potvrzení, pokud jste právě udělali chybu ve zprávě commit. Jednodušší možností je git reset (upstage všech změn, které jste provedli od té doby) a pak git commit --amend , které otevřou váš výchozí editor zpráv o potvrzení předvyplněných poslední zprávou o potvrzení. 

20714
Esko Luontola

To mi chvíli trvalo, než jsem to zjistil, takže to možná někomu pomůže ...

Poslední vrácení můžete zrušit dvěma způsoby, a to v závislosti na tom, zda jste již vytvořili veřejnou zakázku (či nikoli) (posunutý do vzdáleného úložiště):

Jak vrátit místní potvrzení

Řekněme, že jsem se dopustil místně, ale teď chci odstranit tento závazek.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Chcete-li vše vrátit zpět na způsob, jakým byl před posledním potvrzením, musíme reset do potvrzení před HEAD:

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Nyní git log ukáže, že naše poslední potvrzení bylo odstraněno.

Jak vrátit veřejné potvrzení

Pokud jste již provedli svá provizi veřejně, budete chtít vytvořit nové potvrzení, které "vrátí" změny, které jste provedli ve svém předchozím odevzdání (aktuální HEAD).

git revert HEAD

Vaše změny budou nyní vráceny a připraveny k potvrzení:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Pro více informací, podívejte se Git Základy - Vrátit věci

1909
Andrew

Přidat/odebrat soubory, abyste získali věci tak, jak chcete:

git rm classdir
git add sourcedir

Poté proveďte změnu:

git commit --amend

Předchozí, chybný závazek bude upraven tak, aby odrážel nový indexový stav - jinými slovy, bude to jako byste nikdy neudělali chybu na prvním místě.

Mějte na paměti, že byste to měli udělat pouze v případě, že jste ještě nestiskli. Pokud jste tlačil, pak budete muset spáchat opravu normálně.

1669
bdonlan
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

nebo

git reset --hard HEAD~1

Upozornění: Výše ​​uvedený příkaz trvale odstraní úpravy souborů .Java (a všech dalších souborů), které chcete provést.

hard reset na HEAD-1 nastaví vaši pracovní kopii do stavu potvrzení před nesprávným potvrzením.

933
Lennart Koopmann

Chcete-li změnit poslední potvrzení

Nahradit soubory v indexu:

git rm --cached *.class
git add *.Java

Pokud je to soukromá pobočka, pozměnit prověrku:

git commit --amend

Nebo pokud je to sdílená pobočka, proveďte nové potvrzení:

git commit -m 'Replace .class files with .Java files'


(pro změnu předchozího potvrzení, použijte úžasnou interaktivní rebase )


ProTip ™: Přidání *.class do gitignore aby se to opět stalo.


Chcete-li vrátit potvrzení

Změna odevzdání je ideálním řešením, pokud potřebujete změnit poslední potvrzení, ale obecnější řešení je reset.

Git můžete resetovat na jakékoli potvrzení pomocí:

git reset @~N

Kde N je počet povelů před HEAD a @~ resetuje na předchozí potvrzení.

Namísto změny odevzdání můžete použít:

git reset @~
git add *.Java
git commit -m "Add .Java files"

Podívejte se na git help reset, konkrétně na sekce --soft--mixed a --hard, pro lepší pochopení toho, co to dělá.

Reflog

Pokud se vám to podaří, můžete vždy použít reflog k vyhledání zrušených provizí:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started


712
Zaz

Použít git revert <commit-id>

Chcete-li získat ID potvrzení, použijte pouze git log

594
Jaco Pretorius

Pokud plánujete zcela zrušit lokální potvrzení, cokoliv jste změnili, pak jste udělali následující příkaz.

git reset --hard HEAD^1

(Tento příkaz bude ignorovat celý váš závazek a vaše změny budou zcela ztraceny z místního pracovního stromu). Pokud chcete vrátit zpět svůj závazek, ale chcete, aby vaše změny v pracovní oblasti (před potvrzením, stejně jako po git add), proveďte následující příkaz.

git reset --soft HEAD^1

Nyní se vaše spáchané soubory dostanou do pracovní oblasti. Předpokládejme, že chcete soubory nadstránit, protože je třeba upravit nějaký nesprávný obsah a pak provést následující příkaz

git reset HEAD

Nyní se soubory zavádějí z inscenované oblasti do nestabilní oblasti. Nyní jsou soubory připraveny k úpravě, takže cokoliv změníte, chcete jít upravit a přidat a vytvořit nový/nový záznam.

Více

477
Madhan Ayyasamy

Pokud máte Git Extras nainstalován, můžete spustit git undo vrátit poslední potvrzení. git undo 3 vrátí poslední 3 provize zpět.

456
nickf

Chtěl jsem zrušit posledních 5 provizí v našem sdíleném úložišti. Podíval jsem se na revizní číslo, na které jsem se chtěl vrátit. Pak jsem napsal následující.

Prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
Prompt> git Push Origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>
424
neoneye

Dávám přednost použití git rebase -i pro tuto práci, protože se objeví seznam Nice, kde si mohu vybrat, jak se zbavit. Nemusí to být tak přímé jako některé další odpovědi, ale jen cítí se dobře.

Vyberte, kolik kreditů chcete zobrazit, a pak vyvolejte takovéto kroky (chcete-li zadat poslední tři)

git rebase -i HEAD~3

Seznam vzorků

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Pak Git odstraní potvrzuje všechny řádky, které odstraníte.

401
Steven Penny

Pokud jste se dopustili nevyžádané pošty, ale netlačíte ji,

git reset --soft HEAD~1

HEAD ~ 1 je zkratka pro odevzdání před hlavou. Alternativně můžete odkazovat na SHA-1 hash, pokud chcete obnovit nastavení. --soft volba odstraní potvrzení, ale ponechá všechny vaše změněné soubory "Změny, které mají být spáchány", jak by to stav git dal.

Pokud se chcete zbavit jakýchkoli změn ve sledovaných souborech v pracovním stromu, protože potvrzení před použitím hlavy místo toho použije " --hard ".

OR

Pokud jste již stiskli a někdo vytáhl, což je obvykle můj případ, nemůžete použít git reset. Můžete však použít příkaz git revert,

git revert HEAD

Tím se vytvoří nový odevzdaný příkaz, který převrátí vše, co bylo zaviněno náhodným spácháním.

310
santos_mgr

Pokud ho chcete trvale zrušit a máte klonované nějaké úložiště 

Identifikátor commit může být viděn 

git log 

Pak můžete udělat -

git reset --hard <commit_id>

git Push Origin <branch_name> -f
306
poorva

On SourceTree (GUI pro GitHub), můžete kliknout pravým tlačítkem na potvrzení a provést 'Reverse Commit'. To by mělo vrátit zpět vaše změny.

Na terminálu:

Alternativně můžete použít:

git revert

Nebo:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.
258
Varun Parakh

Jeden příkaz:

git reset --soft 'HEAD^' 

Je skvělé vrátit poslední místní potvrzení!

242

Jednoduše ji resetujte pomocí příkazu git:

git reset --soft HEAD~1

Vysvětlete: co git reset dělá, je to v podstatě reset pro jakýkoli závazek, ke kterému byste se chtěli vrátit, a pokud jej zkombinujete s klíčem --soft, vrátí se zpět, ale ponechá změny ve vašem souboru (souborech), takže se vrátíte zpět do fáze, do které byl soubor právě přidán, HEAD je hlavou větev a pokud se spojíte s ~1 (v tomto případě také použijete HEAD^), vrátí se pouze jeden úkol, který chcete. .

Kroky v níže uvedeném obrázku vytvořím podrobněji pro vás, včetně všech kroků, které mohou nastat v reálných situacích a spáchání kódu:

 How to undo the last commits in Git?

229
Alireza

Jak vrátit poslední Git commit?

Chcete-li vše vrátit zpět do stavu, v jakém byl před posledním potvrzením, musíme resetovat potvrzení před HEAD.

  1. Pokud nechcete provádět změny, které jste provedli:

    git reset --hard HEAD^
    
  2. Pokud chcete své změny zachovat:

    git reset --soft HEAD^
    

Nyní zkontrolujte svůj git log. Ukáže, že naše poslední potvrzení bylo odstraněno.

216

Použijte reflog k nalezení správného stavu

git reflog

reflog before REFLOG PŘED RESETEM

Vyberte správné reflog (f3cb6e2 v mém případě) a typ 

git reset --hard f3cb6e2

Poté bude repo HEAD resetováno na HEADid reset effect LOG PO RESETU

Konečně reflog vypadá jako na obrázku níže

reflog after REFLOG FINAL

174

"Obnovit pracovní strom na poslední potvrzení"

git reset --hard HEAD^ 

"Vyčistit neznámé soubory z pracovního stromu"

git clean    

viz - Git Quick Reference

POZNÁMKA: Tento příkaz smaže předchozí příkaz, takže jej používejte opatrně! git reset --hard je bezpečnější -

169
Ravi_Parmar

První běh: 

git reflog

Zobrazí se vám všechny možné akce, které jste provedli ve svém úložišti, například potvrzení, sloučení, tažení atd.

Pak postupujte takto:

git reset --hard ActionIdFromRefLog
152
U. Ali

Vrátit zpět poslední potvrzení:

git reset --soft HEAD^ nebo git reset --soft HEAD~

Tím se vrátí poslední potvrzení.

Zde --soft znamená reset do stagingu.

HEAD~ nebo HEAD^ znamená přejít k potvrzení před HEAD.


Nahradit poslední potvrzení nového potvrzení:

git commit --amend -m "message"

Nahradí poslední potvrzení novým odevzdáním.

143
akshay_rahar

Jiná cesta:

Pokuste se vrátit pobočku, kterou chcete vrátit, a poté resetujte místní pracovní kopii zpět na potvrzení, že chcete být poslední na vzdáleném serveru (vše poté, co bude spuštěno bye-bye). Chcete-li to provést, v SourceTree jsem klepněte pravým tlačítkem myši na a vybrané "Obnovit BRANCHNAME tohoto potvrzení".

Poté přejděte do místního adresáře úložiště a spusťte tento příkaz:

git -c diff.mnemonicprefix=false -c core.quotepath=false Push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

To vymaže všechny provize po aktuálním ve vašem lokálním úložišti, ale pouze pro jednu pobočku.

138
CommaToast

Zadejte git log a najděte poslední kód hash a poté zadejte:

git reset <the previous co>
129
user853293

V mém případě jsem omylem spáchal některé soubory, které jsem nechtěl. Tak jsem udělal následující a fungoval:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Výsledky ověřte pomocí gitk nebo git log --stat

125
egridasov

Použijte SourceTree (grafický nástroj pro Git) pro zobrazení vašich povelů a stromů. Můžete jej ručně obnovit přímo klepnutím pravým tlačítkem myši.

114
iOS Coder

Jednoduché, spusťte tento příkaz v příkazovém řádku:

git reset --soft HEAD~ 
114
kyo

Chcete-li obnovit předchozí revizi, natrvalo smažte všechny nepotvrzené změny: 

git reset --hard HEAD~1
113
thestar

Existují dva hlavní scénáře

Ještě jste nepotvrdili potvrzení

Pokud se jedná o další soubory, které jste zadali (a nechcete je v repozitáři), můžete je odstranit pomocí příkazu git rm a poté pomocí příkazu --amend.

git rm <pathToFile>

Můžete také odstranit celé adresáře pomocí -r, nebo dokonce kombinovat s jinými Bash příkazy

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

Po odstranění souborů se můžete zavázat pomocí volby --amend

git commit --amend -C HEAD # the -C option is to use the same commit message

To přepíše vaše nedávné místní potvrzení odebrání extra souborů, takže tyto soubory nebudou nikdy odesílány na Push a také budou odstraněny z vašeho lokálního .git repozitáře GC.

Už jste posunuli potvrzení

Můžete použít stejné řešení jiného scénáře a pak provést git Push s volbou -f, ale je to nedoporučuje se, protože přepíše vzdálenou historii divergentní změnou (může to zneužít vaše úložiště).

Místo toho musíte provést potvrzení bez --amend (zapamatujte si o -amend `: Tato volba přepíše historii posledního potvrzení).

113
dseminara

Existuje mnoho způsobů, jak to udělat:

Příkaz Git pro vrácení posledního potvrzení/předchozího potvrzení:

Varování: Nepoužívejte --hard, pokud nevíte, co děláte. - těžké je příliš nebezpečné , a může smazat vaše soubory.

Základní příkaz pro vrácení potvrzení v Gitu je:

$ git reset --hard <COMMIT -ID>

nebo

$ git reset --hard HEAD~<n>

COMMIT-ID : ID pro potvrzení

n: je počet posledních provizí, které chcete vrátit

ID potvrzení můžete získat následujícím způsobem:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

kde d81d3f1 a be20eb8 jsou potvrzeny id.

Nyní se podívejme na některé případy:

Předpokládejme, že chcete vrátit poslední potvrzení 'd81d3f1'. Zde jsou dvě možnosti:

$ git reset --hard d81d3f1

nebo

$ git reset --hard HEAD~1

Předpokládejme, že chcete vrátit potvrzení „be20eb8“:

$ git reset --hard be20eb8

Podrobnější informace můžete také zobrazit a vyzkoušet i jiné příkazy pro resetování hlavy do určeného stavu:

$ git reset --help
113
Upen

Pro místní potvrzení

git reset --soft HEAD~1

nebo pokud si nepamatujete přesně, ve kterém závazku je, můžete použít

git rm --cached <file>

Pro tlačený závazek

Správný způsob odstranění souborů z historie úložiště je pomocí git filter-branch. To znamená,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

Ale doporučuji vám použít tento příkaz opatrně. Přečtěte si více v git-filter-branch (1) Manuální stránka.

112
geoom

CO POUŽÍVAT, reset --soft nebo reset --hard?

Přidávám jen dva centy za odpověď Kyralessa:

Pokud si nejste jisti, co použít, přejděte na --soft (tuto konvenci jsem použil k zapamatování - s oft for safe).

Proč?

Pokud omylem zvolíte --hard, budeteZTRATITvaše změny tak, jak tomu bylo dříve. Pokud omylem zvolíte --soft, můžete dosáhnout stejných výsledků --hard použitím dalších příkazů

git reset HEAD file.html
git checkout -- file.html

Celý příklad

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Kredity jdou na @Kyralessa.

91
amd

Můžeš použít:

git reset [email protected]{1}

Tento příkaz odstraní chybný potvrzení bez protokolu Git.

62
Jade Han

Myslíme si, že máme code.txt soubor. Uděláme v něm nějaké změny a dopustíme se. Můžeme tento závazek vrátit třemi způsoby, ale nejprve byste měli vědět, co je to inscenovaný soubor ... Postupný soubor je soubor, který je připraven ke spáchání, a pokud spustíte soubor git status, tento soubor bude zobrazen se zelenou barvou, a pokud se to nestane pro potvrzení, zobrazeny červenou barvou:

 enter image description here

Znamená to, že pokud provedete změnu, vaše změny v tomto souboru se neuloží. Tento soubor můžete přidat ve své fázi pomocí příkazu git add code.txt a poté provést změnu:

 enter image description here

Vrátit zpět poslední potvrzení:

  1. Teď, když chceme jen vrátit zpět spáchání bez jakýchkoli jiných změn, můžeme použít

    git reset --soft HEAD^ 

     enter image description here

  2. Chceme-li zrušit potvrzení a jeho změny (TOTO IS NEBEZPEČÍ, protože se vaše změna ztratí), můžeme použít

    git reset --hard HEAD^

     enter image description here

  3. A pokud chceme zrušit spáchání změn a odstranit změny od stádia, můžeme použít

    git reset --mixed HEAD^ nebo v krátké formě git reset HEAD^

     enter image description here

60
Ali Motameni

Obvykle chcete vrátit spáchat, protože jste udělali chybu a chcete ji opravit - v podstatě to, co OP udělal, když se ptal na otázku. Takže skutečně chcete redo a commit.

Většina odpovědí se zaměřuje na příkazový řádek. Zatímco příkazový řádek je nejlepší způsob, jak používat Git, když s ním budete spokojeni, je to pravděpodobně trochu cizí těm, kteří přicházejí z jiných systémů pro správu verzí do Gitu. 

Zde je návod, jak to provést pomocí grafického uživatelského rozhraní. Pokud máte nainstalovaný Git, máte již vše, co potřebujete k dodržování těchto pokynů.

POZNÁMKA: Předpokládám, že jste si uvědomili, že spáchání bylo špatné, než jste ho tlačili. Pokud nevíte, co tlačit, pravděpodobně jste netlačili, takže pokračujte s pokyny. Pokud jste stiskli chybný závazek, nejméně riskantním způsobem je pouze následovat chybný příkaz s novým potvrzením, které opravuje věci, způsobem, jakým byste to provedli v systému pro správu verzí, který neumožňuje přepsat historii. 

To znamená, že zde je návod, jak opravit poslední chybu zavinění pomocí grafického uživatelského rozhraní:

  1. Přejděte do svého úložiště na příkazovém řádku a spusťte příkaz gui pomocí git gui
  2. Zvolte "Změnit poslední potvrzení". Uvidíte poslední zprávu o potvrzení, soubory, které jste provedli, a soubory, které jste neprovedli.
  3. Nyní změňte věci podle toho, jak chcete, aby vypadaly a klepněte na tlačítko Potvrdit. 
57
Carl

Stačí vrátit poslední potvrzení: 

git reset --soft HEAD~

Nebo vrátit čas před posledním potvrzením: 

git reset --soft HEAD~2

Nebo můžete zrušit předchozí potvrzení: 

git reset --soft <commitID>

(Commitid můžete získat pomocí git reflog)

Když vrátíte předchozí závazek, nezapomeňte vyčistit pracoviště

git clean

Další podrobnosti naleznete v dokumentech: git-reset

53
steven

Pokud pracujete s SourceTree, pomůže vám to.

Klikněte pravým tlačítkem na potvrzení a poté vyberte vyberte "Obnovit (aktuální větev)/hlavní na tento úkol" a poslední vyberte _ ​​"Soft" reset .

 Enter image description here

53
Alexandr

Vrátit poslední potvrzení

Existují tuny situací, kdy opravdu chcete zrušit poslední potvrzení do svého kódu. Např. protože byste ho chtěli rozsáhle restrukturalizovat - nebo ho dokonce zcela zlikvidovat!

V těchto případech je příkaz "reset" vaším nejlepším přítelem:

$ git reset --soft HEAD~1

Výše uvedený příkaz (reset) převine aktuální větev HEAD na zadanou revizi. Ve výše uvedeném příkladu bychom se rádi vrátili k té, která předcházela aktuální revizi - čímž se náš poslední závazek vrátil zpět.

Poznámka: příznak --soft: To zajistí, že změny v revizích zpět byly zachovány. Po spuštění příkazu najdete změny jako nepotvrzené místní úpravy v pracovní kopii.

Pokud tyto změny nechcete zachovat, použijte příznak --hard. Ujistěte se, že to uděláte pouze tehdy, pokud jste si jisti, že tyto změny již nepotřebujete.

$ git reset --hard HEAD~1

 Enter image description here

51
Mohit

Chcete-li vrátit zpět svůj místní příkaz, použijte git reset <commit>. Také , že tutorial je velmi užitečné ukázat vám, jak to funguje.

Alternativně můžete použít git revert <commit>: reverting by mělo být použito, když chcete přidat další potvrzení, které vrátí změny (ale uchová je v historii projektu).

47
mfathy00

Typický cyklus Git

Když mluvíme o příkazech souvisejících s Gitem v předchozích odpovědích, rád bych se o své typické Gitovy cykly podělil se všemi čtenáři, kteří mohou pomoci. Tady je, jak pracuji s Git,

  1. Klonování poprvé ze vzdáleného serveru

    git clone $project

  2. Vytažení ze vzdáleného (když nemám čekající místní potvrzení pro Push)

    git pull

  3. Přidání nového lokálního souboru1 do $ to_be_committed_list (stačí si představit $ to_be_committed_list znamená staged area)

    git add $file1

  4. Odstranění chybně přidaného souboru2 z $ to_be_committed_list (předpokládejme, že soubor2 je přidán jako krok 3, který jsem nechtěl)

    git reset $file2

  5. Zadávání file1, které je v $ to_be_committed_list

    git commit -m "commit message description"

  6. Synchronizace lokálního potvrzení se vzdáleným úložištěm před stisknutím

    git pull --rebase

  7. Vyřešení, kdy dojde ke konfliktu předpokladu configure mergetool

    git mergetool #resolve merging here, also can manually merge

  8. Přidání souborů vyřešených konfliktem, řekněme file1:

    git add $file1

  9. Pokračování mého předchozího příkazu rebase

    git rebase --continue

  10. Pushing ready a již synchronizované poslední místní potvrzení

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

41

V mém případě jsem se dopustil a tlačil na špatnou větev, takže to, co jsem chtěl, bylo, aby všechny mé změny byly zpět, abych je mohl zavést do nové správné větve, takže jsem to udělal:

Pokud zadáte "git status" ve stejné větvi, kterou jste zavázali a tlačili, nevidíte nic nového, protože jste se dopustili a tlačili, nyní zadejte:

git reset --soft HEAD~1

Tím se všechny vaše změny (soubory) vrátí zpět do oblasti jeviště a nyní je vrátíte zpět do pracovního adresáře, který právě zadáváte:

git reset FILE

Kde "Soubor" je soubor, který chcete znovu potvrdit. Nyní by měl být tento SOUBOR v pracovním adresáři (nestabilní) se všemi změnami, které jste provedli. Nyní se můžete změnit na libovolnou větev, kterou chcete a proveďte změny v této větvi. Doufám, že to pomůže ostatním lidem, kteří udělali stejnou chybu, co jsem udělal. Samozřejmě, že počáteční větev, kterou jste se dopustili, je stále se všemi změnami, ale v mém případě, který byl v pořádku, pokud to není pro vás, můžete hledat způsoby, jak vrátit tento závazek v této větvi.

39
FraK

VISUAL STUDIO UŽIVATELÉ (2015, atd.)

Pokud nemůžete synchronizovat v aplikaci Visual Studio, protože není povoleno Push to do pobočky, jako je "vývoj", pak tolik, jak jsem se snažil, v aplikaci Visual Studio NEJSOU REVERT NOR RESET (tvrdé nebo měkké) bude fungovat.

Za odpověď s TONY HLASŮ:

Použijte tento příkaz v příkazovém řádku kořenového adresáře vašeho projektu, abyste se mohli zbavit čehokoli, co se bude snažit tlačit:

git reset --hard HEAD~1

Zálohování nebo Zip soubory jen v případě, že nechcete ztratit žádnou práci, atd.

38
Tom Stickel

Dostal jsem ID potvrzení z bitbucket a pak jsem udělal:

git checkout commitID .

Příklad:

git checkout 7991072 .

A vrátil se zpět k té pracovní kopii tohoto závazku.

35
ioopl

Předpokládejme, že jste provedli nesprávný příkaz lokálně a posunuli jej do vzdáleného úložiště. Pomocí těchto dvou příkazů můžete tento nepořádek vrátit zpět:

Nejprve musíme opravit náš lokální repozitář tím, že se vrátíme k závazku, který si přejeme:

git reset --hard <previous good commit id where you want the local repository  to go>

Tímto příkazem nyní důrazně stiskneme tento dobrý příkaz na vzdáleném úložišti:

git Push --force-with-lease

Verze s volbou „s nájmem“ zabrání náhodnému smazání nových, o kterých neznáte (tj. Pocházejí z jiného zdroje od posledního tažení).

34
KawaiKx

Vrátit zpět poslední potvrzení:

git reset --soft HEAD^ or git reset --soft HEAD~

Tím zrušíte poslední potvrzení.

Zde --soft znamená reset do stagingu.

HEAD~ or HEAD^ znamená přejít k potvrzení před HEAD.

Nahradit poslední potvrzení nového potvrzení:

git commit --amend -m "message"

Nahradí poslední potvrzení novým odevzdáním.

32
Ankit Patidar

Musíte to udělat snadno a rychle

    git commit --amend

pokud je to soukromá pobočka nebo

    git commit -m 'Replace .class files with .Java files'

pokud je to sdílená nebo veřejná pobočka.

32
Yahs Hef

Máte několik možností, jak vrátit poslední potvrzení. Zde jsou některé z vašich možností shrnout do jediné odpovědi s úryvky kódu

Nejdříve musíte zjistit, které "špatné" provize, které si přejete vyřadit. Použijeme git reflog k nalezení.


git reflog

Můžete také použít reflog.
git reflog zobrazí jakoukoliv změnu, která aktualizovala HEAD a zaškrtnutím požadované položky reflog nastaví HEAD zpět na tento potvrzení. 

Pokaždé, když je změněno HEAD, bude v reflog nová položka.
reflog je podobný příkazu historie unixu a je uložen lokálně na vašem počítači.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Pomocí pokladny se můžete vrátit k libovolnému závazku a můžete vytvořit pobočku nebo jiné možnosti, které vám git checkout umožní.

 enter image description here


git reset HEAD --hard <commit_id>

"Přesuňte" svou hlavu zpět na požadovaný závazek.
Git reset bude kontrolovat požadovaný obsah potvrzení do pracovní oblasti a/nebo do vašeho pracovního adresáře na základě hodnoty --hard/--soft/--mixed, kterou si vyberete. --hard bude aktualizovat jak oblast plochy, tak pracovní adresář s daným obsahem a bude "odpojovat" všechny ostatní provize mimo tento bod ve vaší místní pobočce. 

Pokud tyto provize nejsou součástí žádné jiné pobočky, stanou se "visícími".
Obsah „dangle“ znamená, že ve vašem lokálním úložišti je nedosažitelný obsah, který není součástí žádné jiné pobočky a může být odstraněn nebo odstraněn gc.

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

Toto schéma ilustruje, který příkaz dělá co.
Jak vidíte, reset && checkout upravit HEAD.

 enter image description here

28
CodeWizard

Použijte tento příkaz:

git checkout -b old-state number_commit
27
Fadid

Použijte tento příkaz

git checkout -b old-state 0d1d7fc32
27

Odstranění chybného potvrzení, které je již posunuto do Githubu

git Push Origin +(previous good commit id):(branch name)

Zadejte prosím poslední ID dobrého potvrzení, které chcete obnovit v Githubu.

Například. Pokud je poslední ID chyby chybné, zadejte předchozí ID příkazu commit ve výše uvedeném příkazu git s názvem větve. 

Pomocí příkazu git log můžete získat předchozí id potvrzení

25
V V

Abychom se zbavili (všech změn v) posledního odevzdání, poslední 2 se dopustí a poslední n se dopustí:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

A zbavit se všeho po konkrétním spáchání:

git reset --hard <commit sha>

např., 

git reset --hard 0d12345

PS:
1- Buďte opatrní, protože "tvrdé" volby, smaže lokální změny Ve vašem repo stejně, a vrátí se k předchozímu zmíněnému odevzdání. Měli byste to Spouštět, pokud jste si jisti, že jste se dopustili posledního spáchání (s) A chtěli byste se vrátit v čase. 

2- Obvykle stačí 7 písmen "commit sha", ale ve větších projektech Budete potřebovat až 12 dopisů, které budou garantovány. Můžete také zmínit celých 40 písmen sha.

3 Výše ​​uvedené příkazy pracují také v Githubu pro Windows.

24
Alisa

Vždy můžete udělat git checkout <SHA code> předchozí verze a pak znovu potvrdit nový kód.

24
shreshta bm

Soubory Git můžete vrátit zpět dvěma způsoby: Nejprve můžete použít příkaz git revert, chcete-li zachovat historii potvrzení:

git revert HEAD~3
git revert <hashcode of commit>

Za druhé, můžete použít git reset, který by odstranil všechny vaše spáchané dějiny a přivedl svou hlavu k tomu, aby se tam, kde ji chcete, dopustil.

git reset <hashcode of commit>
git reset HEAD~3

Klíčové slovo --hard můžete také použít, pokud se některý z nich začne chovat jinak. Ale doporučil bych to, dokud to nebude nezbytně nutné.

20
Shwetank

Reference: Jak vrátit poslední potvrzení v Gitu?

Pokud máte nainstalované Git Extensions, můžete snadno vrátit zpět/vrátit jakýkoliv commit (můžete stáhnout git extensions z zde ).

Otevřete Git Extensions, klikněte pravým tlačítkem myši na potvrzení, které chcete vrátit, a vyberte "Vrátit potvrzení". 

 Git Extensions screen shot

Otevře se vyskakovací okno (viz obrázek níže)

 Revert commit popup

Vyberte "Automaticky vytvořit potvrzení", chcete-li přímo potvrdit vrácené změny, nebo chcete-li ručně vrátit provedené změny, ponechte políčko un-selected a klikněte na tlačítko "Vrátit toto potvrzení".

18
Ranadheer Reddy

Použijte git reset --hard <last good SHA> pro resetování změn a přidělení nového potvrzení. Můžete také použít git checkout -- <bad filename>.

16
hubot

Našel jsem this site, který popisuje, jak vrátit věci, které jste zavázali do úložiště.

Některé příkazy:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit
16
Eugen Konkov

Zde je stránka: Oh shit, git! .

Zde je mnoho receptů, jak vrátit věci do Gitu. Někteří z nich:

Do prdele, musím změnit zprávu o mém posledním páchání!

git commit --amend
# follow prompts to change the commit message

Do prdele, omylem jsem se dopustil něčeho, co bych měl zvládnout, což by mělo být na zcela nové pobočce!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)
15
Eugen Konkov

Odvolání můžete vrátit zpět z lokálního úložiště. Postupujte podle níže uvedeného scénáře.

V níže uvedeném obrázku jsem se podívat na větev 'test' (pomocí příkazu Git git checkout -b test) jako místní a zkontrolujte stav (pomocí příkazu Git git status) místní pobočky, že se nic neděje.

 Enter image description here

V následujícím obrázku obrázku můžete vidět, že jsem provedl několik změn v souboru Filter1.txt a přidal tento soubor do pracovní oblasti a poté provedl změny pomocí zprávy Git git commit -m "Doing commit to test revert back".

"-m je pro zprávu odevzdání"

 Enter image description here

V následujícím obrázku vidíte, jak se vaše příkazy zapisují, co jste provedli (pomocí příkazu Git git log).

 Enter image description here

Ve výše uvedeném obrázku tedy můžete vidět id commit s každým odevzdáním as vaší zprávou o odevzdání nyní bez ohledu na to, zda chcete vrátit zpět nebo vrátit kopii tohoto ID potvrzení a stisknout níže uvedený příkaz Git, git revert {"paste your commit id"}. Příklad:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

 Enter image description here

Vrátil jsem se zpět ke svému poslednímu odevzdání. Pokud nyní zkontrolujete stav Git, můžete vidět upravený soubor, který je Filter1.txt a přesto spáchat.

 Enter image description here

14
Raj S. Rusia

Nejjednodušší způsob, jak vrátit poslední potvrzení je

git reset HEAD^

To přinese stav projektu před provedením závazku.

14
Arun Karnawat

V IntelliJ IDEA můžete jednoduše otevřít protokol úložiště Git stisknutím Alt+9, klikněte pravým tlačítkem myši na některou značku ze seznamu provizí a vyberte: "Obnovit aktuální větvu na zde ...".

13

HEAD:

Před resetem bychom měli vědět o HEAD ... HEAD není nic jiného než váš aktuální stav ve vašem pracovním adresáři. Je reprezentován potvrzovacím číslem.

Git commit:

Každá změna přiřazená v rámci příkazu commit, který je reprezentován jedinečnou značkou. Potvrzení nelze odstranit. Pokud tedy chcete svůj poslední závazek, můžete se do něj jednoduše ponořit pomocí git reset.

Do posledního odevzdání se můžete ponořit dvěma způsoby:

Metoda 1: (pokud neznáte číslo potvrzení, ale chcete přejít na první)

git reset HEAD~1  # It will move your head to last commit

Metoda 2: (pokud znáte závazek, který jednoduše obnovíte na známém potvrzení)

git reset 0xab3 # Číslo potvrzení

Poznámka: pokud chcete znát nedávný pokus o potvrzení git log -p -1

Zde je grafické znázornění:

 Enter image description here

13

Rozdíl mezi git reset --mixed, --soft a --hard

Předpoklad: Je-li provedena modifikace existujícího souboru ve vašem úložišti , Je tato změna zpočátku považována za nestabilizovanou. Aby bylo možné změny provést, je třeba provést jejich provedení, což znamená [.____. .] přidání do indexu pomocí git add. Během operace odevzdání se soubory , Které jsou uspořádány, přidají do indexu.

Vezměme si příklad: 

- A - B - C (master)

HEAD body na C a index odpovídá C.

--měkký

  • Když provedeme git reset --soft B s úmyslem odebrat commit C a ukázat master/HEAD na B
  • Master/HEAD bude nyní ukazovat na B, ale index se stále změnil z C
  • Při provádění git status můžete vidět soubory indexované v commit C as staged
  • Provedení git commit v tomto bodě vytvoří nový commit s stejnými změnami jako C

--smíšený

  • Proveďte git reset --mixed B
  • Při provádění bude master/HEAD ukazovat na B a index je také upraven tak, aby odpovídal B z důvodu použitého smíšeného příznaku. 
  • Pokud v tomto okamžiku spustíme git commit, nic se nestane, protože index odpovídá HEAD.
  • Stále máme změny v pracovním adresáři, ale protože nejsou v indexu, stav git je zobrazuje jako nestabilní
  • Chcete-li je zavázat, měli byste git add a pak se zavázat jako obvykle.

--tvrdý

  • Spustit git reset --hard B
  • Při provádění bude master/HEAD ukazovat na B a upraví váš pracovní adresář
  • Změny přidané v C a všechny nepotvrzené změny budou odstraněny.
  • Soubory v pracovní kopii budou odpovídat potvrzení B, což bude mít za následek trvalé ztrátu všech změn, které byly provedeny v potvrzení C plus nezrušené změny

Doufám, že toto porovnání příznaků, které jsou k dispozici s příkazem git reset, pomůže někomu použít je moudře. Pro další podrobnosti viz tyto odkazy link1 & link2

12
Keshan Nageswaran

Rekonstrukce a zrušení provizí je nejlepší, když chcete udržet historii čistou Užitečnou při navrhování oprav do veřejné větve atd.

Pokud budete muset upustit nejvýše spáchaný úkol, pak vám pomůže následující liner

git rebase --onto HEAD~1 HEAD

Ale pokud chcete upustit 1 z mnoha spáchání, řekli jste to

a -> b -> c -> d -> master

a chcete zrušit „c“

git rebase --onto b c

Toto bude dělat 'b' jako nový základ 'd' odstranění 'c'

12
Khem

Nalezení posledního potvrzovacího kódu pomocí záznamu:

git log

Pak

git reset <the previous co>
12
Praveen Singh

Pro úplnost uvedu jednu ohromující metodu, která byla v předchozích odpovědích přehlédnuta.

Vzhledem k tomu, že potvrzení nebylo stisknuto, ovladač nebyl změněn, takže:

  1. Odstranit místní úložiště.
  2. Klonujte vzdálené úložiště.

Někdy je to nutné, pokud váš fantýzový klient GIT jde do bye-bye. (např. chyby non-fast-forward)

Nezapomeňte znovu provést změny uložené od posledního Push.

11
Dominic Cerisano

 enter image description here

Za předpokladu, že pracujete ve Visual Studiu, pokud se vydáte do historie vaší pobočky a podíváte se na všechny vaše závazky, jednoduše vyberte událost před potvrzením, které chcete vrátit zpět, klepněte na něj pravým tlačítkem myši a vyberte Revert. Snadné.

11
Uchiha Itachi

Pokud chcete odstranit nesprávné soubory, které byste měli udělat 

git reset --soft <your_last_good_commit_hash_here> Zde, pokud uděláte git status, uvidíte soubory v pracovní oblasti. Můžete vybrat nesprávné soubory a vybrat je z pracovní oblasti.

Jako následující.

git reset wrongFile1 wrongFile2 wrongFile3

Nyní můžete pouze přidat soubory, které potřebujete, Push,

git add goodFile1 goodFile2

spáchat 

git commit -v nebo git commit -am "Message"

a Push

git Push Origin master

Pokud se však nezměníte o změněné soubory, můžete tvrdý reset obnovit na předchozí dobré potvrzení a vše posunout na server.

podle 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Pokud jste již na server publikovali své nesprávné soubory, můžete použít příznak --force pro Push to server a upravit historii.

git Push --force Origin master

8
nPcomp

Vyzkoušejte to, je těžké obnovit předchozí potvrzení, pokud tyto soubory nebyly přidány, a pak:

git reset --hard <commit_hash>

Ujistěte se, že máte zálohy svých změn jen v případě, že jde o pevný reset, což znamená, že budou ztraceny (pokud jste dříve nesložili)

7
serdarsenay
git reset --soft HEAD~1

Obnovení převine aktuální větu HEAD na zadanou revizi. Poznámka the --soft flag: Tím se zajistí, že změny v revizích zpět budou zachovány. Po spuštění příkazu najdete změny jako nepotvrzené místní úpravy v pracovní kopii.

Pokud nechcete tyto změny zachovat, stačí použít parametr --hard. Ujistěte se, že to uděláte pouze tehdy, pokud jste si jisti, že tyto změny již nepotřebujete.

 git reset --hard HEAD~1

Vrácení více příkazů

git reset --hard 0ad5a7a6

mějte však na paměti, že použitím příkazu reset zrušíte všechny příkazy, které přišly poté, co jste se vrátili na adresu:  enter image description here

6
Abu Bakr

Co mám dělat pokaždé, když musím vrátit potvrzení/potvrzení, jsou:

  1. git reset HEAD~<n> // počet posledních prověrek, které musím vrátit
  2. git status // volitelné. Všechny soubory jsou nyní červené (nestabilní).

  3. Nyní mohu přidat a odevzdat pouze soubory, které potřebuji:

    • git add <file names> & git commit -m "message" -m "details"
  4. Volitelné: Mohu vrátit změny zbytkových souborů, pokud potřebuji, do jejich předchozího stavu, s pokladnou:
    • git checkout <filename>
  5. pokud jsem ji již posunul do odlehlého původu, dříve:
    • git Push Origin <branch name> -f // použijte -f k vynucení Push.
6
Theo Itzaris

Pokud chcete vrátit zpět první provizi ve vašem repo

S tímto problémem se setkáte:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Došlo k chybě, protože pokud je posledním potvrzením počáteční potvrzení (nebo žádné rodiče) úložiště, neexistuje HEAD ~.

Řešení

Pokud chcete resetovat pouze potvrzení na pobočce „master“

$ git update-ref -d HEAD
$ git rm --cached -r .
5
Nicholas

Pomocí tohoto příkazu získáte poslední ID potvrzení (v protokolu nahoře je to poslední):

git log

Získat ID potvrzení (GUID) a spustit tento příkaz:

git revert <commit_id>
3
Nalan Madheswaran

Jak upravit dřívější potvrzení

Obecně nechci vrátit spoustu spáchání, ale spíše upravit dřívější závazek, jak bych si přál, abych to spáchal na prvním místě.

Zjistil jsem, že jsem si dopustil, že jsem dopustil, že jsem napsal scénář.

Zde je pracovní postup:

  1. git commit-edit <commit-hash>
    

    To vás přenese na potvrzení, které chcete upravit.

    Změny odevzdání budou un inscenované, připravené k inscenaci, jak jste si přáli poprvé.

  2. Opravte a proveďte prověrku, jak jste si přáli, aby to bylo na prvním místě.

    (Možná budete chtít použít git stash save --keep-index k odtržení všech souborů, které neprošlete)

  3. Znovu proveďte potvrzení s --amend, např.:

    git commit --amend
    
  4. Dokončete rebase:

    git rebase --continue
    

Volejte toto git-commit-edit a vložte jej do svého $PATH:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo
2
Tom Hale

Pokud chcete jednoduše smazat všechny místní změny/prověří a místní pobočky vypadají jako pobočka Origin, kterou jste začali ...

git reset --hard Origin/branch-name

1
JeremyWeir
git revert commit

To bude generovat opačné změny od potvrzení, které chcete vrátit zpět, a pak stačí provést změny. Myslím, že je to nejjednodušší způsob.

https://git-scm.com/docs/git-revert

1
Gjorgi Gjorgiev

nahraďte místní verzi včetně změn ve verzi serveru, tyto dva řádky kódu vynutí git, aby vytáhl a přepsal místní. Otevřete příkaz Prompt a přejděte do kořenového adresáře projektu git. Pokud používáte VS, klikněte na Team, Synch a klikněte na "Open Command Prompt" (viz obrázek) níže. 

 Visual Studio

Jakmile v Cmd Prompt pokračujte s následujícími dvěma pokyny. 

git fetch --all

pak to uděláš

git reset --hard Origin/master

toto přepíše existující lokální verzi s verzí na serveru git

0
shiraz
git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back
0
Omkaar.K