如何撤消 Git 中最近的本地提交？
[英]How do I undo the most recent local commits in Git?
102 個解決方案
解決方案1
26731 已采納
撤消提交並重做
$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~ # (1)
[ edit files as necessary ] # (2)
$ git add . # (3)
$ git commit -c ORIG_HEAD # (4)
-
git reset是負責撤消的命令。 它將撤消您的最后一次提交，同時保持您的工作樹（磁盤上文件的狀態）不變。 您需要再次添加它們，然后才能再次提交它們）。 - 更正工作樹文件。
-
git add任何你想包含在你的新提交中的東西。 - 提交更改，重用舊的提交消息。
reset將舊頭復制到.git/ORIG_HEAD； 使用-c ORIG_HEADcommit將打開一個編輯器，該編輯器最初包含來自舊提交的日志消息，並允許您對其進行編輯。 如果您不需要編輯消息，則可以使用-C選項。
或者，要編輯先前的提交（或只是其提交消息） ， commit --amend會將當前索引中的更改添加到先前的提交。
要刪除（不恢復）已推送到服務器的提交，需要使用git push origin main --force[-with-lease]重寫歷史記錄。 使用--force幾乎總是一個壞主意； 更喜歡--force-with-lease代替，並且如git 手冊中所述：
如果您 [rewrite history] 已經出版，您應該了解重寫歷史的含義。
延伸閱讀
您可以使用git reflog來確定您希望恢復到的提交的 SHA-1 。 獲得此值后，請使用上述命令序列。
HEAD~與HEAD~1相同。 文章什么是 git 中的 HEAD？ 如果您想取消提交多個提交，這很有幫助。
解決方案2
11984 2011-07-28 22:22:20
如果您不知道它是如何工作的，那么撤消提交有點可怕。 但是，如果您確實了解，這實際上非常容易。 我將向您展示撤消提交的 4 種不同方式。
假設你有這個，其中 C 是你的 HEAD 並且 (F) 是你的文件的狀態。
(F)
A-B-C
↑
master
選項 1： git reset --hard
您想銷毀提交 C 並丟棄任何未提交的更改。 你來做這件事：
git reset --hard HEAD~1
結果是：
(F)
A-B
↑
master
現在 B 是 HEAD。 因為您使用了--hard ，所以您的文件在提交 B 時被重置為它們的狀態。
選項 2： git reset
也許提交 C 不是一場災難，但只是有點偏離。 您想撤消提交，但在進行更好的提交之前保留您的更改以進行一些編輯。 從這里重新開始，以 C 作為你的 HEAD：
(F)
A-B-C
↑
master
這樣做，離開--hard ：
git reset HEAD~1
在這種情況下，結果是：
(F)
A-B-C
↑
master
在這兩種情況下， HEAD 只是指向最新提交的指針。 當您執行git reset HEAD~1時，您告訴 Git 將 HEAD 指針移回一次提交。 但是（除非你使用--hard ）你讓你的文件保持原樣。 所以現在git status顯示了你檢查到 C 中的更改。你沒有丟失任何東西！
選項 3： git reset --soft
為了最輕松的接觸，您甚至可以撤消您的提交，但保留您的文件和索引：
git reset --soft HEAD~1
這不僅會留下您的文件，甚至會留下您的索引。 當您執行git status時，您會看到索引中的文件與以前相同。 事實上，在這個命令之后，您可以執行git commit並且您將重做您剛剛的相同提交。
選項 4：您執行了git reset --hard並且需要取回該代碼
還有一件事：假設您像第一個示例一樣銷毀了一個提交，但后來發現您畢竟需要它？ 運氣不好，對吧？
不行，還是有辦法找回來的。 輸入這個
git reflog
你會看到一個你已經移動的（部分）提交shas （即哈希）列表。找到你銷毀的提交，然后這樣做：
git checkout -b someNewBranchName shaYouDestroyed
您現在已經恢復了該提交。 提交實際上不會在 Git 中被銷毀大約 90 天，因此您通常可以返回並拯救一個您不想擺脫的提交。
解決方案3
2530 2011-06-16 17:27:23
有兩種方法可以“撤消”您的最后一次提交，具體取決於您是否已經公開提交（推送到遠程存儲庫）：
如何撤消本地提交
假設我在本地提交，但現在我想刪除該提交。
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.
要將所有內容恢復到上次提交之前的狀態，我們需要reset為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
現在git log將顯示我們的最后一次提交已被刪除。
如何撤消公共提交
如果您已經公開了您的提交，您將需要創建一個新的提交，它將“還原”您在之前的提交（當前的 HEAD）中所做的更改。
git revert HEAD
您的更改現在將被還原並准備好提交：
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
有關更多信息，請查看Git 基礎知識 - 撤消操作。
解決方案4
1883 2009-05-29 18:16:26
添加/刪除文件以按照您想要的方式獲取內容：
git rm classdir
git add sourcedir
然后修改提交：
git commit --amend
先前的錯誤提交將被編輯以反映新的索引狀態 - 換句話說，就像您從一開始就沒有犯過錯誤一樣。
請注意，只有在尚未推送時才應該這樣做。 如果您已推送，那么您只需正常提交修復即可。
解決方案5
1204 2009-05-29 18:13:07
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"
或者
git reset --hard HEAD~1
警告：上述命令將永久刪除對您想要提交的.java文件（和任何其他文件）的修改。
對HEAD-1的hard reset會將您的工作副本設置為錯誤提交之前的提交狀態。
解決方案6
901 2010-07-31 09:39:13
更改最后一次提交
替換索引中的文件：
git rm --cached *.class
git add *.java
然后，如果它是私有分支，請修改提交：
git commit --amend
或者，如果它是共享分支，則進行新的提交：
git commit -m 'Replace .class files with .java files'
（要更改以前的提交，請使用很棒的交互式變基。）
ProTip™：將*.class添加到gitignore以阻止這種情況再次發生。
恢復提交
如果您需要更改最后一次提交，修改提交是理想的解決方案，但更通用的解決方案是reset 。
您可以使用以下命令將 Git 重置為任何提交：
git reset @~N
其中N是HEAD之前的提交次數， @~重置為上一次提交。
您可以使用以下命令，而不是修改提交：
git reset @~
git add *.java
git commit -m "Add .java files"
查看git help reset ，特別是關於--soft --mixed和--hard的部分，以便更好地理解它的作用。
重新登錄
如果你搞砸了，你總是可以使用 reflog 來查找丟棄的提交：
$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started
解決方案7
794 2012-05-25 16:04:29
使用git revert <commit-id> 。
要獲取提交 ID，只需使用git log 。
解決方案8
649 2013-01-31 07:06:10
如果您打算完全撤消本地提交，無論您在提交上做了什么更改，如果您對此不擔心，只需執行以下命令。
git reset --hard HEAD^1
（此命令將忽略您的整個提交，並且您的更改將從您的本地工作樹中完全丟失）。 如果您想撤消您的提交，但您希望在暫存區域中進行更改（在提交之前，就像在git add之后一樣），請執行以下命令。
git reset --soft HEAD^1
現在您提交的文件進入暫存區。 假設如果你想升級文件，因為你需要編輯一些錯誤的內容，那么執行以下命令
git reset HEAD
現在提交的文件從暫存區進入非暫存區。 現在文件已准備好編輯，所以無論您更改什么，您都想編輯並添加它並進行全新/新提交。
解決方案9
588 2011-12-13 10:18:31
如果你安裝了Git Extras ，你可以運行git undo來撤銷最新的提交。 git undo 3將撤消最后三個提交。
解決方案10
548 2012-04-06 13:58:52
我想撤消我們共享存儲庫中最近的五個提交。 我查找了要回滾到的修訂 ID。 然后我輸入了以下內容。
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 git@bitbucket.org:thecompany/prometheus.git
+ 09a6480...5a74047 master -> master (forced update)
prompt>
解決方案11
522 2012-10-25 03:41:20
我更喜歡使用git rebase -i來完成這項工作，因為會彈出一個不錯的列表，我可以在其中選擇要擺脫的提交。 它可能不像這里的其他一些答案那么直接，但感覺是對的。
選擇要列出的提交數量，然后像這樣調用（爭取最后三個）
git rebase -i HEAD~3
樣品清單
pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support
然后 Git 將刪除您刪除的任何行的提交。
解決方案12
491
如何修復之前的本地提交
使用 git-gui （或類似的）執行git commit --amend 。 在 GUI 中，您可以在提交中添加或刪除單個文件。 您還可以修改提交消息。
如何撤消先前的本地提交
只需將您的分支重置到以前的位置（例如，使用gitk或git rebase ）。 然后從保存的副本重新應用您的更改。 在本地存儲庫中進行垃圾收集后，就像從未發生過不需要的提交一樣。 要在單個命令中完成所有這些操作，請使用git reset HEAD~1 。
警告語：粗心使用git reset是讓工作副本陷入混亂狀態的好方法。 我建議 Git 新手盡可能避免這種情況。
如何撤消公共提交
執行反向櫻桃選擇（ git-revert ）以撤消更改。
如果您還沒有將其他更改拉到您的分支上，您可以簡單地...
git revert --no-edit HEAD
然后將更新后的分支推送到共享存儲庫。
提交歷史將分別顯示這兩個提交。
高級：更正公共存儲庫中的私有分支
這可能很危險——請確保您有要重新推送的分支的本地副本。
另請注意：如果其他人可能在分支上工作，您不希望這樣做。
git push --delete (branch_name) ## remove public version of branch
在本地清理您的分支，然后重新推送...
git push origin (branch_name)
在正常情況下，您可能不必擔心您的私有分支提交歷史是原始的。 只需推送后續提交（請參閱上面的“如何撤消公共提交”），然后執行squash-merge以隱藏歷史記錄。
解決方案13
402
如果您想永久撤消它並且您已經克隆了一些存儲庫。
提交 ID 可以通過以下方式查看：
git log
然后你可以這樣做：
git reset --hard <commit_id>
git push origin <branch_name> -f
解決方案14
397
如果你犯了垃圾但沒有被推送，
git reset --soft HEAD~1
HEAD~1是 head 之前提交的簡寫。 或者，如果您想重置為，您可以參考哈希的SHA-1 。 --soft選項將刪除提交，但它將保留所有更改的文件“要提交的更改”，就像 git status 所說的那樣。
如果您想擺脫自 head 之前的提交以來對工作樹中跟蹤文件的任何更改，請改用“ --hard ”。
或者
如果你已經推了有人拉了，這通常是我的情況，你不能使用git reset 。 但是，您可以執行git revert ，
git revert HEAD
這將創建一個新的提交，它會反轉由意外提交引入的所有內容。
解決方案15
338
在SourceTree （GitHub 的 GUI）上，您可以右鍵單擊提交並執行“反向提交”。 這應該撤消您的更改。
在終端上：
您也可以使用：
git revert
或者：
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.
解決方案16
312
一個命令：
git reset --soft 'HEAD^'
撤消最后一次本地提交非常有用！
解決方案17
294
只需使用git執行以下命令即可重置它：
git reset --soft HEAD~1
說明： git reset的作用，它基本上reset為您想返回的任何提交，然后如果將其與--soft鍵結合使用，它將返回，但將更改保留在文件中，所以你回到剛剛添加文件的階段， HEAD是分支的頭，如果你結合~1 （在這種情況下你也使用HEAD^ ），它只會返回一個你想要的提交。 ..
我為您更詳細地創建了下圖中的步驟，包括在實際情況中可能發生的所有步驟並提交代碼：
解決方案18
280
“將工作樹重置為最后一次提交”
git reset --hard HEAD^
“從工作樹中清除未知文件”
git clean
請參閱 - Git 快速參考
注意：此命令將刪除您之前的提交，因此請謹慎使用！ git reset --hard更安全。
解決方案19
271
如何撤消最后一次 Git 提交？
要將所有內容恢復到上次提交之前的狀態，我們需要重置為 HEAD 之前的提交。
如果您不想保留所做的更改：
git reset --hard HEAD^如果您想保留更改：
git reset --soft HEAD^
現在檢查你的 git 日志。 它將顯示我們的最后一次提交已被刪除。
解決方案20
218
使用 reflog 找到正確的狀態
git reflog
重置前重新記錄
選擇正確的 reflog（在我的例子中是 f3cb6e2）並輸入
git reset --hard f3cb6e2
之后，repo HEAD 將重置為該 HEADid 復位后記錄
最后 reflog 如下圖所示
重新記錄決賽
解決方案21
192
第一次運行：
git reflog
它將顯示您對存儲庫執行的所有可能操作，例如，提交、合並、拉取等。
然后做：
git reset --hard ActionIdFromRefLog
解決方案22
180
撤消上次提交：
git reset --soft HEAD^或git reset --soft HEAD~
這將撤消最后一次提交。
這里--soft表示重置為暫存。
HEAD~或HEAD^表示在 HEAD 之前移動到提交。
將上次提交替換為新提交：
git commit --amend -m "message"
它將用新的提交替換最后一次提交。
解決方案23
177
另一種方式：
簽出您要恢復的分支，然后將您的本地工作副本重置回您希望成為遠程服務器上最新版本的提交（之后的一切都會再見）。 為此，在 SourceTree 中，我右鍵單擊並選擇“將 BRANCHNAME 重置為此提交”。
然后導航到存儲庫的本地目錄並運行以下命令：
git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
這將刪除本地存儲庫中當前提交之后的所有提交，但僅針對那個分支。
解決方案24
166
輸入git log並找到最后一次提交的哈希碼，然后輸入：
git reset <the previous co>
解決方案25
161
就我而言，我不小心提交了一些我不想提交的文件。 所以我做了以下事情，它奏效了：
git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD
使用 gitk 或 git log --stat 驗證結果
解決方案26
155
很簡單，在命令行中運行它：
git reset --soft HEAD~
解決方案27
145
主要有兩種情況
你還沒有推送提交
如果問題是您提交的額外文件（並且您不希望這些文件在存儲庫中），您可以使用git rm刪除它們，然后使用--amend
git rm <pathToFile>
您還可以使用-r刪除整個目錄，甚至可以與其他Bash命令結合使用
git rm -r <pathToDirectory>
git rm $(find -name '*.class')
刪除文件后，您可以使用--amend選項提交
git commit --amend -C HEAD # the -C option is to use the same commit message
這將重寫您最近的本地提交，刪除額外的文件，因此，這些文件將永遠不會在推送時發送，並且也會被 GC 從您的本地 .git 存儲庫中刪除。
你已經推送了提交
您可以應用與其他方案相同的解決方案，然后使用-f選項執行git push ，但不建議這樣做，因為它會用不同的更改覆蓋遠程歷史記錄（它可能會弄亂您的存儲庫）。
相反，您必須在沒有--amend的情況下進行提交（請記住關於 -amend 的這一點：該選項會重寫上次提交的歷史記錄）。
解決方案28
142
對於本地提交
git reset --soft HEAD~1
或者如果你不記得它是在哪個提交中，你可以使用
git rm --cached <file>
對於推送的提交
從存儲庫歷史記錄中刪除文件的正確方法是使用git filter-branch 。 那是，
git filter-branch --index-filter 'git rm --cached <file>' HEAD
但我建議您謹慎使用此命令。 在git-filter-branch(1) 手冊頁上閱讀更多內容。
解決方案29
142
使用什么， reset --soft或reset --hard ？
我只是為@Kyralessa 的回答加兩分錢：
如果您不確定要使用什么，請使用--soft （我使用此約定來記住它——為了安全起見） 。
為什么？
如果您錯誤地選擇了--hard ，您將丟失以前沒有的更改。 如果您錯誤地選擇--soft ，您可以通過應用附加命令來獲得與--hard相同的結果
git reset HEAD file.html
git checkout -- file.html
完整示例
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
致謝@Kyralessa。
解決方案30
140
要重置到以前的版本，永久刪除所有未提交的更改：
git reset --hard HEAD~1
解決方案31
140
有很多方法可以做到：
Git命令撤消最后一次提交/以前的提交：
警告：如果您不知道自己在做什么，請不要使用 --hard。 --hard 太危險了，它可能會刪除你的文件。
在 Git 中恢復提交的基本命令是：
$ git reset --hard <COMMIT -ID>
或者
$ git reset --hard HEAD~<n>
COMMIT-ID : 提交的 ID
n：是您要恢復的最后提交的數量
您可以獲取提交 id，如下所示：
$ **git log --oneline**
d81d3f1 function to subtract two numbers
be20eb8 function to add two numbers
bedgfgg function to mulitply two numbers
其中d81d3f1和be20eb8是提交 ID。
現在讓我們看一些案例：
假設您想恢復最后一次提交“d81d3f1”。 這里有兩個選項：
$ git reset --hard d81d3f1
或者
$ git reset --hard HEAD~1
假設您要恢復提交“be20eb8”：
$ git reset --hard be20eb8
有關更多詳細信息，您可以參考並嘗試一些其他命令來將 head 重置為指定狀態：
$ git reset --help
解決方案32
131
使用SourceTree （Git 的圖形工具）查看您的提交和樹。 您可以通過右鍵單擊它直接手動重置它。
解決方案33
98
認為我們有code.txt文件。 我們對其進行了一些更改並提交。 我們可以通過三種方式撤消此提交，但首先您應該知道暫存文件是什么...暫存文件是准備好提交的文件，如果您運行git status該文件將顯示為綠色，如果這是not staged for commit 將顯示為紅色：
這意味着如果您提交更改，則不會保存您對此文件的更改。 您可以使用git add code.txt在您的階段添加此文件，然后提交您的更改：
撤消上次提交：
現在，如果我們只想撤消提交而不進行任何其他更改，我們可以使用
git reset --soft HEAD^如果我們想撤消提交及其更改（這很危險，因為您的更改將丟失），我們可以使用
git reset --hard HEAD^如果我們想撤消提交並從階段刪除更改，我們可以使用
git reset --mixed HEAD^或簡稱git reset HEAD^
解決方案34
85
通常，您想要撤消提交，因為您犯了一個錯誤並且您想要修復它 - 本質上是 OP 在他提出問題時所做的。 真的，你真的想重做一個提交。
這里的大多數答案都集中在命令行上。 雖然命令行是在您熟悉 Git 時使用它的最佳方式，但對於那些從其他版本控制系統到 Git 的人來說，它可能有點陌生。
以下是使用 GUI 執行此操作的方法。 如果您安裝了 Git，那么您已經擁有了遵循這些說明所需的一切。
注意：我在這里假設您在推送之前意識到提交是錯誤的。 如果你不知道推動是什么意思，那么你可能還沒有推動。 繼續按照說明進行。 如果你推送了錯誤的提交，風險最小的方法就是用一個新的提交來修復錯誤的提交，就像你在不允許你重寫歷史的版本控制系統中那樣。
也就是說，這里是如何使用 GUI 修復最近的錯誤提交：
- 在命令行上導航到您的存儲庫並使用
git gui啟動 GUI - 選擇“修改上次提交”。 你會看到你最后的提交信息，你暫存的文件和你沒有暫存的文件。
- 現在將內容更改為您希望它們的外觀，然后單擊提交。
解決方案35
80
您可以使用：
git reset HEAD@{1}
此命令將在沒有 Git 日志的情況下刪除您的錯誤提交。
解決方案36
79
如果您想恢復最后一次提交，但仍想在本地保留在提交中所做的更改，請使用以下命令：
git reset HEAD~1 --mixed
解決方案37
75
撤消最后一次提交
在很多情況下，您真的想撤消對代碼的最后一次提交。 例如，因為您想對其進行廣泛的重組——甚至完全放棄它！
在這些情況下，“reset”命令是你最好的朋友：
$ git reset --soft HEAD~1
上面的命令（reset）會將你當前的 HEAD 分支倒回到指定的版本。 在上面的示例中，我們希望返回到當前版本之前的版本——有效地使我們的最后一次提交撤消。
請注意--soft標志：這可確保保留未完成的修訂中的更改。 運行命令后，您會在工作副本中發現更改為未提交的本地修改。
如果您不想保留這些更改，只需使用--hard標志。 確保僅在確定不再需要這些更改時才執行此操作。
$ git reset --hard HEAD~1
解決方案38
69
只需撤消最后一次提交：
git reset --soft HEAD~
或者撤銷上次提交前的時間：
git reset --soft HEAD~2
或撤消任何先前的提交：
git reset --soft <commitID>
（您可以使用git reflog獲取 commitID）
當您撤消先前的提交時，請記住使用
git clean
更多細節可以在文檔中找到： git-reset
解決方案39
68
在回答之前，讓我們添加一些背景知識，解釋一下這個HEAD是什么。
First of all what is HEAD?
HEAD只是對當前分支上當前提交（最新）的引用。
在任何給定時間只能有一個HEAD 。 （不包括git worktree ）
HEAD的內容存儲在.git/HEAD中，它包含當前提交的 40 字節 SHA-1。
detached HEAD
如果您不是最新的提交——這意味着HEAD指向歷史上的先前提交，它稱為detached HEAD 。
在命令行上，它看起來像這樣 - SHA-1 而不是分支名稱，因為HEAD沒有指向當前分支的尖端
關於如何從分離的 HEAD 中恢復的一些選項：
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
這將簽出指向所需提交的新分支。
此命令將檢出給定的提交。
此時，您可以創建一個分支並從這一點開始工作。
# 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
您也可以隨時使用reflog 。
git reflog將顯示更新HEAD的任何更改，並檢查所需的 reflog 條目會將HEAD設置回此提交。
每次修改 HEAD 時， reflog中都會有一個新條目
git reflog
git checkout HEAD@{...}
這將使您回到所需的提交
git reset --hard <commit_id>
將您的 HEAD “移動”回所需的提交。
# 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.
- 注意：（ 從 Git 2.7 開始）
你也可以使用git rebase --no-autostash。
git revert <sha-1>
“撤消”給定的提交或提交范圍。
重置命令將“撤消”在給定提交中所做的任何更改。
將提交帶有撤消補丁的新提交，而原始提交也將保留在歷史記錄中。
# 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>
這個模式說明了哪個命令做什么。
如您所見， reset && checkout修改HEAD 。
解決方案40
65
就我而言，我提交並推送到了錯誤的分支，所以我想要恢復所有更改，以便我可以將它們提交到新的正確分支，所以我這樣做了：
在您提交和推送的同一個分支上，如果您輸入“git status”，您將看不到任何新內容，因為您已提交和推送，現在輸入：
git reset --soft HEAD~1
這將使您的所有更改（文件）回到舞台區域，現在要將它們恢復到工作目錄（unstage）中，您只需鍵入：
git reset FILE
其中“文件”是您要再次提交的文件。 現在，這個 FILE 應該在工作目錄中（未暫存），其中包含您所做的所有更改。 現在您可以更改到您想要的任何分支並在該分支中提交更改。 當然，您提交的初始分支仍然存在所有更改，但在我的情況下沒關系，如果它不適合您 - 您可以尋找在該分支中恢復該提交的方法。
解決方案41
64
撤消最后一次提交：
git reset --soft HEAD^ or git reset --soft HEAD~
這將撤消最后一次提交。
這里--soft表示重置為暫存。
HEAD~ or HEAD^表示在 HEAD 之前移動到提交。
將上次提交替換為新提交：
git commit --amend -m "message"
它將用新的提交替換最后一次提交。
解決方案42
61
如果您正在使用SourceTree ，這將對您有所幫助。
右鍵單擊提交，然后選擇“ Reset (current branch)/master to this commit ”，最后選擇“Soft”reset 。
解決方案43
59
解決方案44
58
假設您在本地進行了錯誤的提交並將其推送到遠程存儲庫。 您可以使用以下兩個命令撤消混亂：
首先，我們需要通過返回到我們想要的提交來更正我們的本地存儲庫：
git reset --hard <previous good commit id where you want the local repository to go>
現在我們使用以下命令將這個好的提交強制推送到遠程存儲庫：
git push --force-with-lease
force 選項的“with-lease”版本將防止意外刪除您不知道的新提交（即，自上次拉取后來自另一個來源）。
解決方案45
52
視覺工作室用戶（2015 年等）
如果您無法在 Visual Studio 中同步，因為您不允許推送到像“開發”這樣的分支，那么正如我所嘗試的那樣，在 Visual Studio 中， REVERT或RESET （硬或軟）都不會起作用。
根據大量投票的答案：
在項目根目錄的命令提示符下使用它來消除任何試圖被推送的東西：
git reset --hard HEAD~1
備份或壓縮文件以防萬一您不希望丟失任何工作等...
解決方案46
52
每個人都以如此復雜的方式發表評論。
如果要從分支中刪除最后一次提交，最簡單的方法是：
git reset --hard HEAD~1
現在要真正推動該更改以擺脫您的最后一次提交，您必須
git push --force
就是這樣。 這將刪除您的最后一次提交。
解決方案47
51
一個典型的 Git 循環
在談到之前答案中與 Git 相關的命令時，我想與所有可能有幫助的讀者分享我的典型 Git 周期。 這是我使用 Git 的方式，
第一次從遠程服務器克隆
git clone $project從遠程拉取（當我沒有待推的本地提交時）
git pull將一個新的本地文件 1 添加到 $to_be_committed_list 中（想象一下 $to_be_committed_list 意味着
staged區）git add $file1從 $to_be_committed_list 中刪除錯誤添加的 file2 （假設 file2 像第 3 步一樣添加，這是我不想要的）
git reset $file2提交 $to_be_committed_list 中的 file1
git commit -m "commit message description"在推送之前將本地提交與遠程存儲庫同步
git pull --rebase解決發生沖突時的先決條件配置合並工具
git mergetool #resolve merging here, also can manually merge添加已解決沖突的文件，例如
file1：git add $file1繼續我之前的變基命令
git rebase --continue推送就緒且已同步的最后一次本地提交
git push origin head:refs/for/$branch # branch = master, dev, etc.
解決方案48
48
在這些情況下，“reset”命令是你最好的朋友：
git reset --soft HEAD~1
重置會將您當前的 HEAD 分支倒回到指定的修訂版。 在上面的示例中，我們希望返回到當前版本之前的版本——有效地使我們的最后一次提交撤消。
請注意 --soft 標志：這可確保保留未完成的修訂中的更改。 運行命令后，您會在工作副本中發現更改為未提交的本地修改。
如果您不想保留這些更改，只需使用 --hard 標志。 確保僅在確定不再需要這些更改時才執行此操作。
git reset --hard HEAD~1
解決方案49
46
刪除已經推送到 Github 的錯誤提交
git push origin +(previous good commit id):(branch name)
請指定您想在 Github 中重置的最后一個良好的提交 ID。
例如。 如果最新的提交 ID 錯誤，則在上面的 git 命令中使用分支名稱指定上一個提交 ID。
您可以使用git log獲取以前的提交 ID
解決方案50
46
為了擺脫（所有更改）最后一次提交、最后 2 次提交和最后 n 次提交：
git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n
而且，要在特定提交后擺脫任何東西：
git reset --hard <commit sha>
例如，
git reset --hard 0d12345
小心使用 hard 選項：它也會刪除你的 repo 中的本地更改並恢復到前面提到的提交。 僅當您確定自己在上次提交中搞砸了並且想及時返回時，才應該運行此命令。
附帶說明一下，提交哈希的大約 7 個字母就足夠了，但在更大的項目中，您可能需要多達 12 個字母才能使其唯一。 如果您願意，也可以使用整個提交 SHA。
上述命令也適用於 Windows 的 GitHub。
解決方案51
41
我從bitbucket獲得了提交 ID，然后做了：
git checkout commitID .
例子：
git checkout 7991072 .
並將其恢復為該提交的工作副本。
解決方案52
40
你需要做的簡單快速
git commit --amend
如果它是私人分支機構或
git commit -m 'Replace .class files with .java files'
如果它是共享或公共分支。
解決方案53
35
執行以下步驟。
步驟1
點擊git log
從日志列表中，找到最后一次提交的哈希碼，然后輸入：
第2步
git reset <hash code>
解決方案54
33
使用此命令
git checkout -b old-state 0d1d7fc32
解決方案55
31
您始終可以執行git checkout <SHA code>的先前版本，然后使用新代碼再次提交。
解決方案56
31
使用這個命令：
git checkout -b old-state number_commit
解決方案57
30
為了從 Git 提交中刪除一些文件，請使用帶有“-soft”選項的“git reset”命令並在 HEAD 之前指定提交。
$ git reset --soft HEAD~1
運行此命令時，您將看到最近提交 (HEAD) 中的文件，您將能夠提交它們。
現在您的文件位於暫存區域，您可以再次使用“git reset”命令刪除它們（或取消暫存）。
$ git reset HEAD <file>
注意：這一次，您正在從 HEAD 重置，因為您只是想從暫存區域中排除文件
如果您對該文件不再感興趣，可以使用“git rm”命令從索引（也稱為暫存區）中刪除該文件。
$ git rm --cached <file>
完成修改后，您只需使用“–amend”選項再次提交更改即可。
$ git commit --amend
要驗證文件是否已從存儲庫中正確刪除，您可以運行“git ls-files”命令並檢查文件是否未出現在文件中（當然，如果它是新文件）
$ git ls-files
<file1>
<file2>
使用 Git 還原從提交中刪除文件
從 Git 2.23 開始，有一種從提交中刪除文件的新方法，但您必須確保您使用的 Git 版本大於或等於 2.23。
$ git --version
Git 版本 2.24.1
注意：Git 2.23 於 2019 年 8 月發布，您的計算機上可能還沒有此版本。
要安裝較新版本的 Git，您可以查看本教程。 要從提交中刪除文件，請使用“git restore”命令，使用“-source”選項指定源以及要從存儲庫中刪除的文件。
例如，為了從 HEAD 中刪除名為“myfile”的文件，您將編寫以下命令
$ git restore --source=HEAD^ --staged -- <file>
例如，假設您在“master”分支上的最新提交中編輯了一個文件。
該文件已正確提交，但您想將其從 Git 存儲庫中刪除。
要從 Git 存儲庫中刪除您的文件，您首先要恢復它。
$ git restore --source=HEAD^ --staged -- newfile
$ git status
在分支“主人”上
您的分支領先於 'origin/master' 1 次提交。 （使用“git push”發布你的本地提交）
要提交的更改：
(use "git restore --staged <file>..." to unstage)
modified: newfile
未為提交暫存的更改：
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: newfile
如您所見，您的文件已回到暫存區。
從那里，您有兩個選擇，您可以選擇編輯您的文件以便再次重新提交它，或者只是從您的 Git 存儲庫中刪除它。
從 Git 存儲庫中刪除文件
在本節中，我們將描述從 Git 存儲庫中刪除文件的步驟。
首先，您需要取消暫存文件，因為如果已暫存，您將無法將其刪除。
要取消暫存文件，請使用“git reset”命令並將 HEAD 指定為源。
$ git reset HEAD newfile
當您的文件正確取消暫存時，使用帶有“–cached”選項的“git rm”命令從 Git 索引中刪除該文件（這不會刪除磁盤上的文件）
$ git rm --cached newfile
rm'新文件'
現在，如果您檢查存儲庫狀態，您將能夠看到 Git 執行了刪除提交。
$ git status
在分支“主人”上
您的分支領先於 'origin/master' 1 次提交。 （使用“git push”發布你的本地提交）
要提交的更改：
(use "git restore --staged <file>..." to unstage)
deleted: newfile
現在您的文件已暫存，只需使用“git commit”和“–amend”選項即可修改存儲庫中的最新提交。
`$ git commit --amend
[master 90f8bb1] Commit from HEAD
Date: Fri Dec 20 03:29:50 2019 -0500
1 file changed, 2 deletions(-)
delete mode 100644 newfile
`如您所見，這不會創建新的提交，但它本質上會修改最近的提交以包含您的更改。
從 Git 提交中刪除特定文件
在某些情況下，您不希望再次暫存所有文件：您只需修改存儲庫中一個非常特定的文件。
為了從 Git 提交中刪除特定文件，請使用帶有“–soft”選項的“git reset”命令，指定 HEAD 之前的提交和要刪除的文件。
$ git reset HEAD^ -- <file>
完成修改后，您的文件將回到暫存區。
首先，您可以選擇使用“git reset”命令從暫存區域中刪除文件，並指定您要從 HEAD 重置。
$ git reset HEAD <file>
注意：這並不意味着您將丟失對該文件的更改，只是該文件將從暫存區中刪除。
如果要從索引中完全刪除文件，則必須使用帶有“–cached”選項的“git rm”命令。
$ git reset HEAD <file>
為了確保您的文件已正確地從暫存區域中刪除，請使用“git ls-files”命令列出屬於索引的文件。
$ git ls-files
當您完全完成修改后，您可以使用帶有“–amend”選項的“git commit”命令來修改您從中刪除文件的提交。
$ git commit --amend
解決方案58
29
您可以通過兩種方式撤消 Git 提交：首先，如果您想保留提交歷史記錄，可以使用git revert ：
git revert HEAD~3
git revert <hashcode of commit>
其次是你可以使用git reset ，它會刪除你所有的提交歷史並把你的頭帶到你想要的地方。
git reset <hashcode of commit>
git reset HEAD~3
如果其中任何一個開始表現不同，您也可以使用--hard關鍵字。 但是，我只會推薦它，直到它非常必要。
解決方案59
29
git reset --soft HEAD~1
重置會將您當前的 HEAD 分支倒回到指定的修訂版。
請注意--soft標志：這可確保保留未完成的修訂中的更改。 運行命令后，您會在工作副本中發現更改為未提交的本地修改。
如果您不想保留這些更改，只需使用--hard標志。 確保僅在確定不再需要這些更改時才執行此操作。
git reset --hard HEAD~1
撤消多個提交
git reset --hard 0ad5a7a6
但是請記住，使用 reset 命令會撤消您返回到的提交之后的所有提交：
解決方案60
27
如果您安裝了 Git 擴展，您可以輕松撤消/恢復任何提交（您可以從此處下載 Git 擴展）。
打開 Git Extensions，右鍵單擊要還原的提交，然后選擇“還原提交”。
將打開一個彈出窗口（請參見下面的屏幕截圖）
如果您想直接提交恢復的更改，或者如果您想手動提交恢復的更改，請選擇“自動創建提交”，保持該框未選中並單擊“恢復此提交”按鈕。
解決方案61
26
我發現這個站點描述了如何撤消您已提交到存儲庫中的內容。
一些命令：
git commit --amend # Change last commit
git reset HEAD~1 --soft # Undo last commit
解決方案62
26
這是網站： Oh shit, git! .
這里有很多關於如何在 Git 中撤消操作的方法。 他們中有一些：
哦，該死，我需要在上次提交時更改消息！
git commit --amend
# follow prompts to change the commit message
哦該死，我不小心提交了一些應該在一個全新分支上的東西！
# 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 :)
解決方案63
26
您可以從本地存儲庫撤消提交。 請遵循以下場景。
在下圖中，我檢查了“測試”分支（使用 Git 命令git checkout -b test ）作為本地分支，並檢查本地分支的狀態（使用 Git 命令git status ）是否有任何內容可提交。
在下一張圖片中，您可以在此處看到我在Filter1.txt中進行了一些更改，並將該文件添加到暫存區域，然后使用一些消息提交了我的更改（使用 Git 命令git commit -m "Doing commit to test revert back" ）。
“-m 用於提交信息”
在下一張圖片中，您可以看到您的提交記錄了您所做的任何提交（使用 Git 命令git log ）。
因此，在上圖中，您可以看到每次提交的提交 id 以及您的提交消息，無論您想恢復什么提交或撤消復制該提交 id 並點擊下面的 Git 命令， git revert {"paste your commit id"} . 例子：
git revert 9ca304ed12b991f8251496b4ea452857b34353e7
我已經恢復了我的最后一次提交。 現在，如果您檢查您的 Git 狀態，您可以看到已修改的文件Filter1.txt尚未提交。
解決方案64
26
git reset --mixed、--soft 和--hard 的區別
先決條件：對存儲庫中的現有文件進行修改時，此更改最初被視為未暫存。 為了提交更改，它需要暫存，這意味着使用
git add將其添加到索引中。 在提交操作期間，暫存的文件被添加到索引中。
舉個例子：
- A - B - C (master)
HEAD指向C並且索引匹配C 。
- 柔軟的
- 當我們執行
git reset --soft B以刪除提交 C並將master/HEAD 指向 B 時。 - master/HEAD 現在將指向 B，但索引仍然從 C 更改。
- 執行
git status時，您可以看到在提交 C中索引的文件為staged 。 - 此時執行
git commit將創建一個新的提交，其更改與 C 相同
--混合
- 執行
git reset --mixed B。 - 在執行時，master/HEAD 將指向 B，並且由於使用了混合標志，索引也被修改以匹配 B。
- 如果我們此時運行 git commit ，則不會發生任何事情，因為索引匹配 HEAD 。
- 我們仍然在工作目錄中有更改，但由於它們不在索引中， git status 將它們顯示為 unstaged 。
- 要提交它們，您將
git add然后像往常一樣提交。
- 難的
- 執行
git reset --hard B - 執行時，master/HEAD 將指向 B並修改您的工作目錄
- 在 C 中添加的更改和所有未提交的更改將被刪除。
- 工作副本中的文件將匹配提交 B，這將導致永久丟失提交 C 中所做的所有更改以及未提交的更改
解決方案65
25
撤消最后一次提交的最簡單方法是
git reset HEAD^
這將在您提交之前帶來項目狀態。
解決方案66
24
為了完整起見，我將給出一個明顯被先前答案忽略的方法。
由於未推送提交，因此遠程未更改，因此：
- 刪除本地存儲庫。
- 克隆遠程存儲庫。
如果你喜歡的 Git 客戶端再見（看着你，egit），這有時是必要的。
不要忘記重新提交自上次推送以來保存的更改。
解決方案67
24
撤消一系列本地提交
OP：如何撤消 Git 中最近的本地提交？ 我不小心提交了錯誤的文件 [作為幾個提交的一部分]。
開始案例
有幾種方法可以“撤消”作為一系列提交，具體取決於您所追求的結果。 考慮到下面的 start case， reset 、 rebase和filter-branch都可以用來重寫你的歷史。
如何撤消C1和C2以從每次提交中刪除tmp.log文件？
在下面的示例中，使用了絕對提交引用，但如果您更習慣於相對引用（即HEAD~2或HEAD@{n} ），它的工作方式相同。
備選方案 1： reset
$ git reset --soft t56pi
使用reset ，可以將分支重置為先前的狀態，並且將任何復合更改還原到暫存區域，然后可以丟棄任何不需要的更改。
注意：由於reset所有先前的更改聚集到Staging Area中，因此單個提交元數據會丟失。 如果這對您不利，那么您可能最好使用rebase或filter-branch代替。
備選方案 2： rebase
$ git rebase --interactive t56pi
使用交互式rebase可以重寫分支中的每個違規提交，從而允許您修改和丟棄不需要的更改。 在上面的信息圖中，右側的源代碼樹說明了狀態 post rebase 。
一步步
- 選擇 rebase 應該基於哪個提交（例如
t56pi） - 通過將
pick替換為edit來選擇您要更改的提交。 保存並關閉。 - Git 現在將在每個選定的提交上停止，允許您重置
HEAD、刪除不需要的文件並創建全新的提交。
注意：與上面的reset選項相比，使用rebase會保留大部分提交元數據。 如果您想保留大部分歷史記錄但只刪除不需要的文件，這很可能是首選選項。
備選方案 3： filter-branch
$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD
上面的命令將從所需范圍t56pi..HEAD內的所有提交中過濾掉文件./tmp.log （假設我們從上面開始的初始情況）。 為清楚起見，請參見下圖。
與rebase類似， filter-branch可用於從分支的子部分中清除不需要的文件。 filter-branch可以自動對每個提交執行所需的操作，而不是通過 rebase 過程手動編輯每個提交。
注意：就像rebase一樣， filter-branch將保留提交元數據的其余部分，只丟棄所需的文件。 請注意C1和C2是如何被重寫的，並且每次提交都丟棄了日志文件。
結論
就像與軟件開發相關的任何事情一樣，有多種方法可以針對給定問題實現相同（或相似）的結果。 您只需要選擇最適合您的特定情況的一種。
最后 - 一個友好的建議
請注意，上述所有三個替代方案都完全重寫了歷史記錄。 除非您確切地知道自己在做什么並且在團隊中進行良好的溝通 - 只重寫尚未遠程發布的提交！
資料來源：以上所有示例均來自此博客。
解決方案68
23
頭：
在重置提交之前，我們應該了解 HEAD... HEAD 只不過是您在工作目錄中的當前狀態。 它由提交號表示。
Git 提交：
在由唯一標記表示的提交下分配的每個更改。 不能刪除提交。 因此，如果您想要最后一次提交，您可以簡單地使用git reset進行深入研究。
您可以使用兩種方法深入了解最后一次提交：
方法1：（如果您不知道提交號，但想移到第一個）
git reset HEAD~1 # It will move your head to last commit
方法 2：（如果您知道提交，則只需將其重置為已知提交）
git reset 0xab3 # 提交號
注意：如果您想知道最近的提交，請嘗試git log -p -1
這是圖形表示：
解決方案69
22
只需使用git reset --hard <last good SHA>重置您的更改並提供新的提交。 你也可以使用git checkout -- <bad filename> 。
解決方案70
22
我驗證了一種有效的方法，這是一個使用它的具體示例：
如果您想永久撤消/取消您的最后一次提交（依此類推，一個一個，任意多個）三個步驟：
1：當然，獲取您想要到達的提交的 id = SHA
$ git log
2：刪除你以前的提交
$ git reset --hard 'your SHA'
3：使用-f選項強制將新的本地歷史記錄到您的源 GitHub 上（最后的提交軌道將從 GitHub 歷史記錄中刪除）
$ git push origin master -f
例子
$ git log
最后一次提交取消
commit e305d21bdcdc51d623faec631ced72645cca9131 (HEAD -> master, origin/master, origin/HEAD)
Author: Christophe <blabla@bla.com>
Date: Thu Jul 30 03:42:26 2020 +0200
U2_30 S45; updating files package.json & yarn.lock for GitHub Web Page from docs/CV_Portfolio...
提交我們現在想要的 HEAD
commit 36212a48b0123456789e01a6c174103be9a11e61
Author: Christophe <blabla@bla.com>
Date: Thu Jul 30 02:38:01 2020 +0200
First commit, new title
通過刪除最后一個到達之前的提交
$ git reset --hard 36212a4
HEAD is now at 36212a4 First commit, new title
檢查沒問題
$ git log
commit 36212a48b0123456789e01a6c174103be9a11e61 (HEAD -> master)
Author: Christophe <blabla@bla.com>
Date: Thu Jul 30 02:38:01 2020 +0200
First commit, new title
$ git status
On branch master
Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
(use "git pull" to update your local branch)
nothing to commit, working tree clean
在 Git(Hub) 上更新您的歷史記錄
$ git push origin master -f
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/ GitUser bla bla/React-Apps.git
+ e305d21...36212a4 master -> master (forced update)
檢查一切正常
$ git status
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean
解決方案71
22
一個簡單的分步指南如下：
- 銷毀提交並丟棄所有未提交的更改
git reset --hard HEAD~1
- 撤消提交但保留更改
git reset HEAD~1
- 保留您的文件，並自動暫存所有更改
git reset --soft HEAD~1
- 復活你摧毀的承諾
git reflog #to find the sh
解決方案72
20
如果您想消除錯誤的文件，您應該這樣做
git reset --soft <your_last_good_commit_hash_here>在這里，如果你執行git status ，你會看到暫存區的文件。 您可以選擇錯誤的文件並將它們從暫存區域中刪除。
像下面這樣。
git reset wrongFile1 wrongFile2 wrongFile3
你現在可以只添加你需要推送的文件，
git add goodFile1 goodFile2
提交他們
git commit -v或git commit -am "Message"
並推
git push origin master
但是，如果您不關心更改的文件，您可以硬重置到以前的良好提交並將所有內容推送到服務器。
經過
git reset --hard <your_last_good_commit_hash_here>
git push origin master
如果您已經將錯誤的文件發布到服務器，您可以使用--force標志推送到服務器並編輯歷史記錄。
git push --force origin master
解決方案73
20
git reset --soft HEAD~1
git status
輸出
在分支主
您的分支領先於 'origin/master' 1 次提交。
（使用“git push”發布你的本地提交）要提交的更改：
（使用“git restore --staged ...”取消暫存）新文件：file1
git log --oneline --graph
輸出
- 90f8bb1 (HEAD -> master) 第二次提交 \
- 7083e29 初始存儲庫提交 \
解決方案74
20
在回答之前，讓我們添加一些背景知識，解釋一下這個HEAD是什么。
First of all what is HEAD?
HEAD只是對當前分支上當前提交（最新）的引用。
在任何給定時間只能有一個HEAD （不包括git worktree ）。
HEAD的內容存儲在.git/HEAD中，它包含當前提交的 40 字節 SHA-1。
detached HEAD
如果您不是最新的提交——這意味着HEAD指向歷史上的先前提交，它被稱為detached HEAD 。
在命令行上，它看起來像這樣 - SHA-1 而不是分支名稱，因為HEAD沒有指向當前分支的尖端：
關於如何從分離的 HEAD 中恢復的一些選項：
git checkout
git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits to go back
這將簽出指向所需提交的新分支。
此命令將檢出給定的提交。
此時，您可以創建一個分支並從這一點開始工作。
# 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
您也可以隨時使用reflog 。
git reflog將顯示更新HEAD的任何更改，並檢查所需的 reflog 條目會將HEAD設置回此提交。
每次修改 HEAD 時， reflog中都會有一個新條目
git reflog
git checkout HEAD@{...}
這將使您回到所需的提交
git reset --hard <commit_id>
將您的 HEAD “移動”回所需的提交。
# 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.
- 注意：（ 從 Git 2.7開始）你也可以使用
git rebase --no-autostash。
git revert <sha-1>
“撤消”給定的提交或提交范圍。
重置命令將“撤消”在給定提交中所做的任何更改。
將提交帶有撤消補丁的新提交，而原始提交也將保留在歷史記錄中。
# Add a new commit with the undo of the original one.
# The <sha-1> can be any commit(s) or commit range
git revert <sha-1>
這個模式說明了哪個命令做什么。
如您所見， reset && checkout修改HEAD 。
解決方案75
18
在 IntelliJ IDEA 中，您只需按Alt + 9打開 Git 存儲庫日志，鼠標右鍵單擊提交列表中的某個標記，然后選擇： “將當前分支重置到此處...” 。
解決方案76
18
當您希望在向公共分支等提出補丁時保持歷史清潔有用時，重新設置和刪除提交是最好的。
如果您必須放棄最頂層的提交，那么以下單行代碼會有所幫助
git rebase --onto HEAD~1 HEAD
但是如果你想放棄你確實說過的許多提交中的 1 個
a -> b -> c -> d -> 主
你想放棄提交'c'
git rebase --onto b c
這將使'b'成為'd'消除'c'的新基礎
解決方案77
17
每次我需要撤消提交/提交時我會做的是：
git reset HEAD~<n>// 我需要撤消的最后一次提交的數量git status// 可選的。 所有文件現在都顯示為紅色（未暫存）。現在，我可以只添加和提交我需要的文件：
-
git add <file names> & git commit -m "message" -m "details"
- 可選：如果需要，我可以通過結帳將其余文件的更改回滾到以前的狀態：
-
git checkout <filename>
- 如果我之前已經將其推送到遠程源：
-
git push origin <branch name> -f// 使用 -f 強制推送。
解決方案78
16
要撤消最后一次本地提交，而不丟棄其更改，我在~/.gitconfig中有這個方便的別名
[alias]
undo = reset --soft HEAD^
然后我簡單地使用git undo ，它超級容易記住。
解決方案79
15
通過查看日志找到最后一次提交的哈希碼：
git log
然后
git reset <the previous co>
解決方案80
14
假設您在 Visual Studio 中工作，如果您進入分支歷史記錄並查看所有提交，只需選擇要撤消的提交之前的事件，右鍵單擊它，然后選擇Revert 。 就這么簡單。
解決方案81
13
替換您的本地版本，包括您對服務器版本所做的更改。 這兩行代碼將強制 Git 拉取並覆蓋本地。
打開命令提示符並導航到 Git 項目根目錄。 如果您使用 Visual Studio，請單擊Team 、 Sync並單擊下面的“打開命令提示符”（見圖）。
進入 Cmd 提示符后，繼續執行以下兩個指令。
git fetch --all
然后你做
git reset --hard origin/master
這將用 Git 服務器上的本地版本覆蓋現有的本地版本。
解決方案82
13
在我自己遇到同樣的問題之后，我在很久以前寫過這個：
基本上你只需要這樣做：
git log ，獲取 SHA 哈希的前七個字符，然后執行git revert <sha> ，然后執行git push --force 。
您也可以使用 Git revert 命令恢復它，如下所示： git revert <sha> -m -1然后git push 。
解決方案83
12
試試這個，硬重置到未添加這些文件的先前提交，然后：
git reset --hard <commit_hash>
確保備份更改以防萬一，因為這是硬重置，這意味着它們會丟失（除非你之前隱藏了）
解決方案84
12
如果您只是想丟棄所有本地更改/提交並使您的本地分支看起來像您開始的原始分支......
git reset --hard origin/branch-name
解決方案85
11
如果您想撤消倉庫中的第一次提交
你會遇到這個問題：
$ 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>...]'
發生錯誤是因為如果最后一次提交是存儲庫的初始提交（或沒有父級），則沒有 HEAD~。
解決方案
如果你想重置“master”分支上的唯一提交
$ git update-ref -d HEAD
$ git rm --cached -r .
解決方案86
10
使用此命令獲取最后一次提交 ID（在頂部的日志中是最新的）：
git log
獲取提交 ID (GUID) 並運行以下命令：
git revert <commit_id>
解決方案87
8
如何編輯較早的提交
一般來說，我不想撤銷一堆提交，而是編輯一個較早的提交，以我希望我首先提交它的方式。
我發現自己經常修復過去的提交，以至於我為它編寫了一個腳本。
這是工作流程：
git commit-edit <commit-hash>這將使您進入要編輯的提交。
提交的更改將取消暫存，准備好按您希望的第一次暫存。
修復並按您希望的方式暫存提交。
（您可能想使用
git stash save --keep-index將您未提交的任何文件隱藏起來）使用
--amend重做提交，例如：git commit --amend完成變基：
git rebase --continue
調用以下git-commit-edit並將其放入您的$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 "$@"; 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
解決方案88
8
您可以使用git revert <commit-id> 。
要獲取提交 ID，只需使用git log 。
解決方案89
8
Visual Studio Code 使這變得非常容易。
解決方案90
8
#1) $ git commit -m "Something terribly misguided"
#2) $ git reset HEAD~
[根據需要編輯文件]
#3) $ git add .
#4) $ git commit -c ORIG_HEAD
解決方案91
7
解決方案92
7
$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend
重要的是要了解，當您修改上一次提交時，與其說是修復它，不如說是用一個新的、改進的提交完全替換它，將舊的提交推到一邊，並把新的提交放在它的位置上。 實際上，就好像以前的提交從未發生過，並且它不會顯示在您的存儲庫歷史記錄中。
修改提交的明顯價值是對您的最后一次提交進行微小的改進，而不會因為“糟糕，忘記添加文件”或“該死，修復最后一次提交中的錯字”等形式的提交消息而弄亂您的存儲庫歷史記錄。
解決方案93
6
我通常首先找到我最近提交的提交哈希：
git log
它看起來像這樣： commit {long_hash}
復制這個long_hash並重置它（返回到相同的文件/狀態，它是在那個提交上）：
git reset --hard {insert long_hash without braces}
解決方案94
6
最簡單的方法是：
$ git reset --soft HEAD~1
根據您需要撤消的次數執行此操作。 提交的更改將在最近的更改中，然后您可以向正確的分支左右進行新的提交。
解決方案95
4
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
解決方案96
4
git reset HEAD@{n}將重置您最近的n 個操作。
對於重置，對於最后一個操作，使用git reset HEAD@{1} 。
解決方案97
4
如果存儲庫已在本地提交且尚未推送到服務器，則另一種粗略/外行的解決方法是：
- Git 將存儲庫克隆到另一個位置。
- 將原始存儲庫中的修改（文件/目錄）復制到這個新存儲庫中。 然后提交並推送新的更改。
- 用這個新的替換舊的存儲庫。
解決方案98
3
首先，運行此命令以重置提交：
git reset --hard HEAD~1
其次，運行這個命令來推送新的提交：
git push upstream head -f
解決方案99
2
您可以對不想暫存的文件使用git reset unwanted_file命令。 通過使用此命令，我們可以將更改的文件從暫存區移動到工作目錄。
解決方案100
2
如果您想恢復到最后一次提交並刪除日志歷史記錄
使用下面的命令，假設您想轉到具有 commitID SHA - 71e2e57458bde883a37b332035f784c6653ec509的上一個提交，您可以指向此提交，在此提交之后它不會顯示任何日志消息，之后所有歷史記錄都將被刪除。
git 推送來源 +71e2e57458bde883a37b332035f784c6653ec509^:master
解決方案101
2
git reset --soft HEAD~1
軟：這將僅從本地刪除提交，並保持文件中的更改原樣。
git reset --hard HEAD~1
git push origin master
硬：這將從本地和遠程刪除該提交並刪除文件中所做的更改。
解決方案102
1
在 Visual Studio 中，只需還原您的提交，然后將其與自動創建的還原提交一起推送。 一切都顯示在下面的屏幕截圖中
解決方案103
0
如果您使用的是GitHub 桌面，則左側藍色Commit to BRANCH_NAME按鈕下方將有一個撤消按鈕
解決方案104
0
如果您想在完成更多工作后保留您的工作並提交，那么您可以使用--amend<\/code>標志覆蓋上次提交。
例子 ：-<\/h3>注意事項：-<\/h3>
-
如果要保留提交消息，請使用--no-edit<\/code>標志而不是-m<\/code><\/li>
如果您已經推送了錯誤的提交，那么您將不得不--force<\/code>推送更正的提交<\/li><\/ol>"
-
如果要保留提交消息，請使用--no-edit<\/code>標志而不是-m<\/code><\/li> 如果您已經推送了錯誤的提交，那么您將不得不--force<\/code>推送更正的提交<\/li><\/ol>"
解決方案105
0
如果你做了你不喜歡的本地提交，並且它們還沒有被推送，你可以將事情重置回之前的良好提交。 就好像錯誤的提交從未發生過一樣。 就是這樣：
在您的終端（終端，Git Bash 或 Windows 命令提示符）中，導航到 Z0BCC50105AD2479506 存儲庫的文件夾。 運行 git status 並確保你有一個干凈的工作樹。 每個提交都有一個唯一的 hash（看起來像 2f5451f）。 您需要找到 hash 以獲得最后一次良好的提交（您想要恢復的那個）。 這里有兩個地方可以看到 hash 提交：在 GitHub 或 Bitbucket 或網站的提交歷史記錄中。 In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log --online Once you know the hash for the last good commit (the one you want to revert back to), run the following command (replacing 2f5451f與您的提交的哈希）：
git reset 2f5451f
git reset --hard 2f5451f
注意：如果您執行 git 重置，提交將被刪除，但更改將顯示為未提交，讓您可以訪問代碼。 這是最安全的選擇，因為也許您想要一些代碼，並且您現在可以進行更改和新的提交。 通常，盡管您希望撤消提交並丟棄代碼，這就是 git reset --hard 所做的。
解決方案106
0
到目前為止，git diff + git apply 一直是我團隊的最佳選擇，它干凈而且超級簡單，不僅是最后一次提交
解決方案107
0
要撤消最近的本地提交，您可以使用 git 重置命令，然后使用提交 hash。這會將當前分支指針移動到之前的提交，從而有效地刪除最近的提交。
例如，如果你想撤銷最后一次提交，你可以使用下面的命令：
git reset HEAD~1 這將撤消最后一次提交以及在該提交中所做的所有更改。 更改仍將存在於您的工作目錄中，因此如果您想保留它們，您將需要再次提交更改。
如果要完全刪除最近提交中所做的更改，可以使用帶有 --hard 標志的 git reset 命令。 這將丟棄最近提交中所做的所有更改，並重置工作目錄中的文件以匹配之前的提交。
例如，要完全刪除最后一次提交：
git reset --hard HEAD~1 這將丟棄上次提交中所做的所有更改，並重置工作目錄中的文件以匹配上次提交。
使用 git 重置命令時要小心，因為如果使用不當，它可能會永久破壞工作。 在使用 git 重置命令之前創建工作備份始終是個好主意。
如何永久撤消git remote的最近提交，但將其保存在本地？
[英]How to permanently undo recent commits from git remote but keep it in my local?
Git：壓縮不是最新提交的連續提交，並且不要從根開始
[英]Git: Squashing consecutive commits that are not the most recent commits, and do not start at the root
如何通過非交互式壓縮除最近的提交之外的所有提交來減少膨脹的Git倉庫的大小？
[英]How do I reduce the size of a bloated Git repo by non-interactively squashing all commits except for the most recent ones?
如何讓git顯示來自所有本地分支的最新n次提交
[英]How to get git to display the most recent n commits from all local branches
聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.