webdevqa.jp.net

Gitで最近行われたローカルコミットを元に戻すにはどうすればいいですか?

間違ったファイルを Git に誤ってコミットしましたが、まだコミットをサーバーにプッシュしていません。

ローカルリポジトリからコミットを元に戻すにはどうすればいいですか?

19555
Hamza Yerlikaya

コミットを元に戻してやり直す

$ 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. これは元に戻すことです。
  2. これにより作業ツリー(ディスク上のファイルの状態)は変更されずにコミットが元に戻され、コミットした変更はステージングされないままになります(そのため、git statusでは「変更はコミットされませんでした」と表示されます)。コミットする前にそれらをもう一度)。 only にしたい場合 add 前回のコミットをさらに変更する場合、またはコミットメッセージを変更する場合1代わりにgit reset --soft HEAD~を使用することもできます。これはgit reset HEAD~HEAD~HEAD~1と同じです)に似ていますが、既存の変更はステージされたままになります。
  3. 作業ツリーファイルを修正します。
  4. git addあなたが新しいコミットに含めたいものなら何でも。
  5. 古いコミットメッセージを再利用して、変更をコミットします。 resetは古いヘッドを.git/ORIG_HEADにコピーしました。 commit-c ORIG_HEADは、最初に古いコミットからのログメッセージを含み、それを編集できるようにするエディタを開きます。メッセージを編集する必要がない場合は、-Cオプションを使用できます。

ただし、インデックスに新しい変更を追加した場合は、commit --amendを使用すると前のコミットに追加されます。

コードがすでにサーバーにプッシュされていて、履歴を上書きする権限(リベース)がある場合:

git Push Origin master --force

また、この答えを見ることができます。 

HEADを以前の場所に戻す方法(独立した頭)

上記の答えはあなたがgit reflogをあなたに示すでしょう、それはあなたが何に戻したいSHA-1であるかを見つけるのに使用されます。上記のように一連のコマンドを使用して元に戻すポイントを見つけたら。


1 ただし、 commitメッセージ を間違えただけで、以前のコミットにリセットする必要はありません。もっと簡単なオプションはgit reset(それ以降に行った変更をすべてステージアップする)そしてそれから git commit --amend です。これは最後のコミットメッセージが入っているデフォルトのコミットメッセージエディタを開きます。 

20714
Esko Luontola

コミットを取り消すことは、その仕組みがわからない場合は少し怖いです。しかし、実際に理解すれば驚くほど簡単です。

これがあるとします。CはHEADで、(F)はファイルの状態です。

   (F)
A-B-C
    ↑
  master

コミットCを破棄し、二度と見たくない。これをして:

git reset --hard HEAD~1

結果は次のとおりです。

 (F)
A-B
  ↑
master

BがHEADです。 --hardを使用したため、ファイルはコミットBの状態にリセットされます。

ああ、しかし、コミット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ポインターを1コミット分戻すように指示します。ただし(--hardを使用しない限り)、ファイルはそのままにしておきます。これで、git statusには、Cにチェックインした変更が表示されます。紛失していません!

最も軽いタッチのために、コミットを取り消すこともできますが、ファイルと indexを残します:

git reset --soft HEAD~1

これにより、ファイルがそのままになるだけでなく、indexもそのまま残されます。 git statusを実行すると、以前と同じファイルがインデックス内にあることがわかります。実際、このコマンドの直後にgit commitを実行すると、今行ったのと同じコミットをやり直すことになります。

もう1つ:最初の例のように、コミットを破棄すると仮定します?大変な運でしょう?

いいえ、stillそれを取り戻す方法があります。 git reflogと入力すると、移動した(部分)コミット shas (つまり、ハッシュ)のリストが表示されます。破棄したコミットを見つけて、これを実行します。

git checkout -b someNewBranchName shaYouDestroyed

これで、そのコミットが復活しました。 Gitでコミットが約90日間実際に破棄されることはありません。そのため、通常は戻って、削除するつもりがなかったものをレスキューできます。

10367
Ryan Lundy

これは私が把握するのにしばらく時間がかかりました、従って多分これは誰かを助けるでしょう...

最後のコミットを「元に戻す」には、コミットを公開した(リモートリポジトリにプッシュした)かどうかに応じて、2つの方法があります。

ローカルコミットを元に戻す方法

ローカルでコミットしたが、今度はそのコミットを削除したいとしましょう。

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の基本 - 元に戻す - をチェックしてください。

1909
Andrew

ファイルを追加/削除して、必要なものを作成します。

git rm classdir
git add sourcedir

それからコミットを修正します。

git commit --amend

前の、誤ったコミットは新しいインデックスの状態を反映するように編集されます - 言い換えれば、それはあなたが最初に間違えなかったようなものになるでしょう。

まだプッシュしていない場合にのみこれを実行してください。もしあなたがプッシュしたのであれば、あなたはただ普通に修正をコミットしなければならないでしょう。

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

または

git reset --hard HEAD~1

警告:上記のコマンドは、コミットしたい.Javaファイル(およびその他のファイル)に対する変更を永久に削除します。

hard resetからHEAD-1はあなたの作業コピーをあなたの間違ったコミットの前のコミットの状態に設定します。

933

最後のコミットを変更する

インデックス内のファイルを置き換えます。

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

それから、もしそれがプライベートブランチであれば、a =commitを修正してください:

git commit --amend

あるいは、それが共有ブランチの場合は、新しいコミットを行います。

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


前のコミットを変更するには、素晴らしい 対話式リベースを使用する


ProTip™:これが再び起こらないようにするには、 gitignore に​​*.classを追加してください。


コミットを元に戻す

最後のコミットを変更する必要がある場合は、コミットを修正することが理想的な解決策ですが、より一般的な解決策はresetです。

Gitを任意のコミットにリセットすることができます。

git reset @~N

NHEADの前のコミット数で、@~は直前のコミットにリセットします。

そのため、コミットを修正する代わりに、次のようにします。

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

git help reset、特に--soft--mixedおよび--hardのセクションを調べてください。これについての理解を深めるために。

再ログ

めちゃくちゃになった場合は、いつでもreflogを使ってドロップされたコミットを見つけることができます。

$ 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

git revert <commit-id>を使う

コミットIDを取得するには、git logを使います。

594
Jaco Pretorius

ローカルコミットを完全に元に戻すことを計画しているのなら、あなたがコミットに対して行った変更が何であれ、そしてそれについて何も心配していなければ、ただ次のコマンドを実行してください。

git reset --hard HEAD^1

(このコマンドはあなたのコミット全体を無視し、あなたの変更はあなたのローカル作業ツリーから完全に失われます)。コミットを元に戻したいがステージング領域での変更が必要な場合(git addの後と同じようにコミットの前)には、次のコマンドを実行します。

git reset --soft HEAD^1

コミットされたファイルはステージング領域に入ります。誤ったコンテンツを編集する必要があるためにファイルをアップステージする場合は、次のコマンドを実行します。

git reset HEAD

今すぐステージングされた領域からステージングされていない領域に来るようにファイルをコミットしました。これでファイルを編集する準備が整いました。変更したものは何でも編集して追加し、新しい/新しいコミットをしたいのです。

もっと

477
Madhan Ayyasamy

Git Extras がインストールされている場合は、git undoを実行して最新のコミットを取り消すことができます。 git undo 3は最後の3つのコミットを元に戻します。

456
nickf

私たちの共有リポジトリで最新の5つのコミットを元に戻したいと思いました。ロールバックしたいリビジョン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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>
424
neoneye

以前のローカルコミットを修正する方法

git commit --amendを実行するには、git-gui(または同様の)を使用します。 GUIから、コミットから個々のファイルを追加または削除できます。コミットメッセージを変更することもできます。

以前のローカルコミットを元に戻す方法

ブランチを前の場所にリセットするだけです(たとえば、gitkまたはgit rebaseを使用します)。次に、保存したコピーから変更を再適用します。ローカルリポジトリでガベージコレクションを実行すると、不要なコミットが発生しなかったようになります。これらすべてを単一のコマンドで実行するには、git reset HEAD~1を使用します。

警告の言葉_git resetの不注意な使用は、作業コピーを混乱状態にする良い方法です。 Git初心者はできる限りこれを避けることをお勧めします。

公開コミットを取り消す方法

逆チェリーピックgit-revert )を実行して、変更を元に戻します。

ブランチに他の変更をまだ追加していない場合は、単純に実行できます...

git revert --no-edit HEAD

次に、更新されたブランチを共有リポジトリにプッシュします。

コミット履歴には両方のコミットが別々に表示されます


高度:パブリックリポジトリのprivateブランチの修正

これは危険な場合があります-必ず再送信するブランチのローカルコピーがあることを確認してください。

また、他の誰かがブランチで作業している可能性がある場合は、これを行いたくありません。

git Push --delete (branch_name) ## remove public version of branch

ブランチをローカルでクリーンアップしてから再送信してください...

git Push Origin (branch_name)

通常のケースでは、プライベートブランチのコミット履歴が初期状態であることを心配する必要はないでしょう。フォローアップコミットをプッシュし(上記の「パブリックコミットを元に戻す方法」を参照)、後で squash-merge を実行して履歴を非表示にします。

405
nobar

私はこの仕事にgit rebase -iを使用することを好みます、なぜなら私は取り除くためにコミットを選ぶことができるところにNiceリストが現れるからです。ここでの他の答えほど直接的ではないかもしれませんが、 は正しいと感じています

リストしたいコミットの数を選択してから、次のように呼び出します(最後の3つをリストに入れるため)。

git rebase -i HEAD~3

サンプル一覧

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

その後Gitはあなたが削除した行のコミットを削除します。

401
Steven Penny

がらくたをコミットしたがプッシュされていない場合

git reset --soft HEAD~1

HEAD〜1 は先頭へのコミットの省略形です。リセットしたい場合は、代わりにハッシュの SHA-1 を参照できます。 --soft オプションを指定するとコミットは削除されますが、変更されたすべてのファイルは "git status"のように "Commit to be commit"のままになります。

コミット前に作業ツリーで追跡されていたファイルの変更を取り除きたい場合は、代わりに " --hard "を使用してください。

OR

あなたがすでにプッシュして、誰かがプルしているのであれば、通常私の場合は、 git reset は使えません。ただし、 git revert を実行することはできます。

git revert HEAD

これは偶発的なコミットによって導入されたすべてを元に戻す新しいコミットを作成します。

310
santos_mgr

恒久的に元に戻したいが、リポジトリを複製した場合 

コミットIDは次のようになります。 

git log 

それならあなたはできる -

git reset --hard <commit_id>

git Push Origin <branch_name> -f
306
poorva

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.
258
Varun Parakh

単一のコマンド

git reset --soft 'HEAD^' 

最後のローカルコミットを元に戻すと便利です。

242

以下のコマンドでgitを使ってリセットしてください。

git reset --soft HEAD~1

説明: git resetが行うこと、基本的にはやり直したいコミットをresetにして、それを--softキーと組み合わせると元に戻りますが、変更はファイルに残します)HEADはブランチの先頭で、~1と組み合わせると(この場合はHEAD^も使用します)、必要なものだけがコミットされます。 ...

実際の状況で発生する可能性があるすべての手順やコードをコミットするなど、以下の画像の手順をより詳細に説明します。

How to undo the last commits in Git?

229
Alireza

最後のGitコミットを元に戻す方法は?

最後のコミット前の状態にすべて戻すためには、HEADの前にコミットにリセットする必要があります。

  1. 行った変更を保持したくない場合は、

    git reset --hard HEAD^
    
  2. 変更を保存したい場合は、

    git reset --soft HEAD^
    

それではgitのログを確認してください。最後のコミットが削除されたことがわかります。

216

Reflogを使って正しい状態を見つける

git reflog

reflog before リセット前のREFLOG

正しいreflog(私の場合はf3cb6e2)を選択して、 

git reset --hard f3cb6e2

その後、リポジトリHEADはそのHEADid にリセットされますreset effect リセット後のログ

最後に、reflogは以下の図のようになります。

reflog after REFLOG FINAL

174

「作業ツリーを最後のコミットにリセット」

git reset --hard HEAD^ 

"作業ツリーから未知のファイルを削除"

git clean    

参照 - Gitクイックリファレンス

注: このコマンドは前回のコミットを削除するので注意して使用してください。 git reset --hardはより安全です -

169
Ravi_Parmar

ファーストラン: 

git reflog

コミット、マージ、プルなど、リポジトリに対して実行した可能性のあるすべてのアクションが表示されます。

それから:

git reset --hard ActionIdFromRefLog
152
U. Ali

最後のコミットを元に戻す:

git reset --soft HEAD^またはgit reset --soft HEAD~

これは最後のコミットを元に戻します。

ここで--softはステージングへのリセットを意味します。

HEAD~またはHEAD^は、HEADの前にコミットすることを意味します。


最後のコミットを新しいコミットに置き換えます。

git commit --amend -m "message"

最後のコミットを新しいコミットに置き換えます。

143
akshay_rahar

別の方法:

元に戻したいブランチをチェックアウトしてから、ローカルの作業コピーをリモートサーバ上の最新のものにしたいコミットに戻します(それ以降のすべてのステップはバイバイになります)。これを行うには、SourceTreeの中で私は右クリックして "Reset BRANCHNAME to this commit"を選択しました。

次にリポジトリのローカルディレクトリに移動して次のコマンドを実行します。

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

これはあなたのローカルリポジトリの現在のコミットの後の全てのコミットを消去しますが、その一つのブランチだけです。

138
CommaToast

git logと入力して最後のコミットハッシュコードを見つけ、次のように入力します。

git reset <the previous co>
129
user853293

私の場合は、誤っていくつかのファイルをコミットしてしまいました。それで、私は以下をしました、そして、それは働きました:

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で結果を確認してください。

125
egridasov

それを行うには多くの方法があります。

最後のコミット/以前のコミットを取り消す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」を元に戻したいとします。次の2つのオプションがあります:

$ git reset --hard d81d3f1

または

$ git reset --hard HEAD~1

コミット 'be20eb8'を元に戻したい場合:

$ git reset --hard be20eb8

より詳細な情報については、ヘッドを指定された状態にリセットする他のコマンドも参照して試してください。

$ git reset --help
123
Upen

SourceTree (Git用のグラフィカルツール)を使用して、コミットとツリーを確認してください。右クリックして手動で直接リセットできます。

114
iOS Coder

簡単です、あなたのコマンドラインでこれを実行します。

git reset --soft HEAD~ 
114
kyo

以前のリビジョンにリセットして、コミットされていないすべての変更を永久に削除します。 

git reset --hard HEAD~1
113
thestar

主なシナリオは2つあります

まだコミットをプッシュしていない

問題があなたがコミットした余分なファイルであった場合(そしてそれらをリポジトリに入れたくない場合)、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

これは最近のローカルコミットを書き換えて余分なファイルを削除するので、これらのファイルはPushで送信されることはなく、GCによってローカルの.gitリポジトリからも削除されます。

あなたはすでにコミットをプッシュしました

他のシナリオと同じ解決策を適用してからgit Pushオプションを指定して-fを実行することもできますが、リモート履歴が異なる変更で上書きされるため、これは 推奨されません です。

代わりに、あなたは--amendなしでコミットをしなければなりません(-amend`についてこれを覚えていてください:そのオプションは最後のコミットの歴史を書き換えます)。

113
dseminara

ローカルコミット

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)マニュアルページを参照してください。

112
geoom

reset --softreset --hardのどちらを使いますか?

@ Kyralessaの回答に2セント追加しただけです。

何を使うべきかわからない場合は--softを選んでください(安全のためにこの規約を覚えています - s oft)。

どうして ?

誤って--hardを選択した場合は、以前のように _ lose _ /を変更します。誤って--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に行きます。

91
amd

あなたが使用することができます:

git reset [email protected]{1}

このコマンドはGitログなしで間違ったコミットを削除します。

62
Jade Han

code.txtfile。いくつかの変更を加えてコミットします。 このコミットを元に戻すには、3つの方法があります。 しかし、最初にあなたは段階的なファイルが何であるか知っておくべきです... 段階的なファイルはコミットする準備ができているファイルであり、あなたがgit statusを実行するならコミットされたステージは赤い色で表示されます。

enter image description here

変更をコミットしても、このファイルに対する変更は保存されません。 git add code.txtを使用してこのファイルをステージに追加してから、変更をコミットできます。

enter image description here

最後のコミットを元に戻す:

  1. 他に変更を加えずにコミットを元に戻すだけの場合は、次のコマンドを使用できます。

    git reset --soft HEAD^ 

    enter image description here

  2. コミットの取り消しとその変更(THIS IS危険、変更が失われるため)が必要な場合は、

    git reset --hard HEAD^

    enter image description here

  3. コミットを元に戻してステージから変更を削除したい場合は、

    git reset --mixed HEAD^または短縮形でgit reset HEAD^

    enter image description here

60
Ali Motameni

通常、間違いを犯して修正したいので、 undo コミットしたいと思います - 本質的に、OPが質問したときにしたことです。それで、本当に、あなたは redo コミットしたいのです。

ここでの答えのほとんどはコマンドラインに焦点を当てています。コマンドラインは、Gitを使い慣れているときにGitを使用するための最良の方法ですが、他のバージョン管理システムからGitに移行するユーザーにとっては、おそらく少し異質なものです。 

これはGUIを使って行う方法です。 Gitがインストールされていれば、これらの指示に従うために必要なものはすべて揃っています。

注: あなたがコミットする前にコミットが間違っていることに気付いたと思います。何がプッシュされているのかわからない場合は、おそらくプッシュされていない可能性があるので、指示を続けてください。間違いのあるコミットをプッシュした場合、最も危険の少ない方法は、問題を修正する新しいコミットで欠陥のあるコミットをフォローアップすることです。これは、履歴を書き換えられないバージョン管理システムで行う方法です。 

とは言っても、GUIを使用して最新のフォルトコミットを修正する方法は次のとおりです。

  1. コマンドラインでリポジトリに移動し、git guiでguiを起動します。
  2. 「最後のコミットを修正する」を選択してください。最後のコミットメッセージ、ステージしたファイル、およびしなかったファイルが表示されます。
  3. それでは、見た目を変更して「確定」をクリックします。 
57
Carl

最後のコミットを元に戻すだけです。 

git reset --soft HEAD~

または、前回のコミット前の時間を元に戻します。 

git reset --soft HEAD~2

または以前のコミットを元に戻します。 

git reset --soft <commitID>

git reflogを使ってcommitIDを取得できます)

前回のコミットを元に戻すときは、忘れずに職場をきれいにしてください。

git clean

詳細はドキュメントにあります: git-reset

53
steven

SourceTreeで作業している場合は、これが役に立ちます。

コミットを右クリック それから 選択 "リセット(現在のブランチ)/このコミットへのマスタ"と最後の 選択 "ソフト "リセット

Enter image description here

53
Alexandr

最後のコミットを元に戻す

最後のコミットをコードに元に戻すことを本当に望む状況はたくさんあります。例えば。あなたはそれを広範囲に再構築したいのです - あるいはそれを完全に破棄しさえしたいのです!

このような場合、 "reset"コマンドがあなたの親友です。

$ git reset --soft HEAD~1

上記のコマンド(reset)は現在のHEADブランチを指定されたリビジョンに巻き戻します。上の例では、現在のリビジョンの前のものに戻りたいと思います - 最後のコミットを事実上元に戻します。

--softフラグに注意してください:これは取り消されたリビジョンの変更が確実に保存されるようにします。このコマンドを実行した後、作業コピーの中でコミットされていないローカルな変更として変更が見つかります。

これらの変更を維持したくない場合は、単に--hardフラグを使用してください。これらの変更がもう必要ないと確信している場合にのみ、必ずこれを行ってください。

$ git reset --hard HEAD~1

Enter image description here

51
Mohit

ローカルコミットを元に戻すには、git reset <commit>を使用します。また、 そのチュートリアル は、それがどのように機能するのかを示すのに非常に役立ちます。

あるいは、git revert <commit>reverting を使用することで、変更をロールバックするコミットを追加したい場合に使用する必要があります(ただし、変更はプロジェクト履歴に残ります)。

47
mfathy00

典型的なGitサイクル

前回の回答でGit関連のコマンドを説明したときに、私の典型的なGitサイクルをすべての読者と共有したいと思います。これが私のGitとのやり方です。

  1. リモートサーバーから初めてクローンを作成する

    git clone $project

  2. リモートからのプル(保留中のローカルコミットがない場合)

    git pull

  3. $ to_be_committed_listに新しいローカルファイル1を追加する($ to_be_committed_listがstaged領域を意味すると想像してください)

    git add $file1

  4. 誤って追加されたfile2を$ to_be_committed_listから削除する(file2がステップ3のように追加されたとします。

    git reset $file2

  5. $ to_be_committed_listにあるfile1をコミットしています

    git commit -m "commit message description"

  6. プッシュする前にローカルコミットをリモートリポジトリと同期する

    git pull --rebase

  7. 競合が発生したときの解決 前提条件configure mergetool

    git mergetool #resolve merging here, also can manually merge

  8. 競合解決されたファイルを追加して、file1としましょう:

    git add $file1

  9. 前回のリベースコマンドを続行する

    git rebase --continue

  10. 準備が整い、すでに最後のローカルコミットが同期されている

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

41

私の場合は、間違ったブランチにコミットしてプッシュしたので、変更をすべて元に戻して新しい正しいブランチにコミットすることを望んでいたので、次のようにしました。

コミットしてプッシュしたのと同じブランチで、「git status」と入力しても、コミットしてプッシュしたので何も新しいものは表示されません。次のように入力します。

git reset --soft HEAD~1

これにより、すべての変更(ファイル)がステージ領域に戻されます。これで、変更内容を作業ディレクトリ(ステージング解除)に戻すことができます。

git reset FILE

「ファイル」が再度コミットしたいファイルです。これで、このFILEは作業ディレクトリ(ステージングされていない状態)に追加されたすべての変更とともに表示されます。今、あなたはあなたが望むどんなブランチにでも変更することができて、そのブランチの変更をコミットすることができます。これが私がしたのと同じ間違いを犯した他の人々に役立つことを願っています。もちろん、あなたがコミットした最初のブランチにはまだすべての変更がありますが、私の場合は大丈夫でした。それがあなたにとってでなければ、そのブランチでそのコミットを元に戻す方法を探すことができます。

39
FraK

VISUAL STUDIO USERS(2015など)

"development"のようなブランチにプッシュすることが許可されていないためにVisual Studioで同期できない場合は、私が試したのと同じくらい多く、 _ revert _ NOR the _ reset _ (ハードまたはソフト)が機能します。

投票のトンとの答えによって:

プッシュされようとするものを無効にするには、プロジェクトのルートのコマンドプロンプトでこれを使用します。

git reset --hard HEAD~1

万が一仕事を失いたくない場合などに備えて、ファイルをバックアップまたはZipしてください。

38
Tom Stickel

私はbitbucketからコミットIDを得て、それからそれをしました:

git checkout commitID .

例:

git checkout 7991072 .

そしてそれはそのコミットの作業コピーに戻ってそれを戻しました。

35
ioopl

ローカルで誤ったコミットを行い、それをリモートリポジトリにプッシュしたとします。あなたはこれら二つのコマンドで混乱を元に戻すことができます:

まず、私たちが望むコミットに戻って、ローカルリポジトリを修正する必要があります。

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

これで、このコマンドを使用してリモートリポジトリにこの良好なコミットを強制的にプッシュします。

git Push --force-with-lease

強制オプションの 'リース付き'バージョンは、あなたが知らない(すなわち、最後のプル以降に別のソースから来る)新しいコミットの偶然の削除を防ぎます。

34
KawaiKx

最後のコミットを元に戻します:

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

最後のコミットを元に戻します。

ここで--softはステージングへのリセットを意味します。

HEAD~ or HEAD^はHEADの前にコミットすることを意味します。

最後のコミットを新しいコミットに置き換えます。

git commit --amend -m "message"

最後のコミットを新しいコミットに置き換えます。

32
Ankit Patidar

あなたは簡単かつ迅速にする必要があります

    git commit --amend

それが私的な支店か

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

それが共有または公共の支店の場合.

32
Yahs Hef

最後のコミットを元に戻す方法はいくつかあります。 これが、コードスニペットを使った単一の回答にまとめられた選択肢の一部です。

まず第一にあなたはあなたが捨てたい「間違った」コミットがどれであるかを理解する必要があります。 それを見つけるためにgit reflogを使います。


git reflog

いつでもreflogを使うことができます。
git reflogは、HEADを更新した変更を表示し、目的のreflogエントリーをチェックアウトすると、HEADがこのコミットに戻ります。 

HEADが変更されるたびにreflogに新しいエントリがあります。
reflogは、unix historyコマンドに似ており、ローカルのマシンに保存されています。

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

チェックアウトを使用すると、任意のコミットに戻り、git checkoutで実行できるブランチやその他のオプションを作成できます。

enter image description here


git reset HEAD --hard <commit_id>

"移動" あなたの頭を希望するコミットに戻してください。
Git resetは、選択した値--hard/--soft/--mixedに基づいて、ステージング領域および/または作業ディレクトリに必要なコミット内容をチェックアウトします。 --hardはステージ領域と作業ディレクトリの両方を与えられた内容で更新し、あなたのローカルブランチ上のこの点を越えて他のコミットを "切り離す"でしょう。 

それらのコミットが他のブランチの一部ではない場合、それらは「ぶら下がり」になります。
"dangle"コンテンツとは、あなたのローカルリポジトリに他のブランチの一部ではない到達不可能なコンテンツがあり、削除される可能性があるか、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.

このスキーマは、どのコマンドが何をするのかを示しています。
ご覧のとおり、reset && checkoutHEADを変更します。

enter image description here

28
CodeWizard

このコマンドを使います。

git checkout -b old-state number_commit
27
Fadid

このコマンドを使う

git checkout -b old-state 0d1d7fc32
27

Githubに既にプッシュされている間違ったコミットを削除する

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

Githubでリセットしたい最後の有効なコミットIDを指定してください。

例えば。最新のコミットIDが間違っている場合は、上記のgitコマンドで前のコミットIDをブランチ名で指定します。 

git logを使用して以前のコミットIDを取得できます

25
V V

最後のコミット(内のすべての変更)、最後の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

シモンズ:
1- "hard"オプションのため、リポジトリ内のローカルの変更も削除され、前述のコミットに戻ります。あなたが最後のコミットで失敗したと確信していて、間に合わせたい場合は、あなたがこれを実行します。 

2 - 通常は7文字の "commit sha"で十分ですが、大きなプロジェクトでは、一意であることを保証するために最大12文字が必要になる場合があります。あなたも全40文字のshaを挙げることができます。

3-上記のコマンドはGithub for Windowsでも同様に機能します。

24
Alisa

以前のバージョンのgit checkout <SHA code>をいつでも実行してから、新しいコードで再度コミットすることができます。

24
shreshta bm

Gitのコミットを元に戻すには、2つの方法があります。コミット履歴を残しておきたい場合は、まずgit revertを使用します。

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

2つ目は、git resetを使用することです。これにより、コミット履歴をすべて削除して、必要な場所にコミットすることができます。

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

--hardキーワードのいずれかが他の方法で動作し始めたらまた使用できます。しかし、それが非常に必要になるまで私はそれをお勧めします。

20
Shwetank

Git reset --mixed、-soft、および--hardの違い

前提条件:リポジトリ内の既存のファイルに変更が加えられると、この変更は最初はステージングされていないと見なされます。変更をコミットするには、ステージングする必要があります。つまり、git addを使用してインデックスに追加する必要があります。コミット操作中に、ステージングされたファイルがインデックスに追加されます。

例を見てみましょう。

- A - B - C (master)

HEADCを指し、インデックスはCと一致します。

- 柔らかい

  • コミットCを削除するおよびマスター/ HEADをBにポイントするを意図してgit reset --soft Bを実行した場合。
  • マスター/ HEADはBを指しますが、インデックスはまだCから変更されています
  • git statusを実行すると、commit C as 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で行われたすべての変更とコミットされていない変更が完全に失われます。

git resetコマンドで使用できるフラグのこの比較が、誰かがそれらを賢く使用するのに役立つことを願っています。詳細については、これらを参照してください link1link2

19

参照: Gitで最後のコミットを元に戻す方法は?

Git Extensionsがインストールされている場合は、コミットを元に戻す/元に戻すことができます( here からgit拡張をダウンロードできます)。

Git Extensionsを開き、元に戻すコミットを右クリックしてから[Revert commit]を選択します。 

Git Extensions screen shot

ポップアップが開きます(下のスクリーンショットを参照)。

Revert commit popup

元に戻す変更を直接コミットする場合、または元に戻す変更を手動でコミットする場合は、[コミットを自動的に作成する]チェックボックスをオフにして[このコミットを元に戻す]ボタンをクリックします。

18
Ranadheer Reddy

変更をリセットして新しいコミットを行うには、git reset --hard <last good SHA>を使用するだけです。 git checkout -- <bad filename>を使うこともできます。

16
hubot

あなたがリポジトリにコミットしたことを元に戻す方法を説明した this siteを見つけました。

いくつかのコマンド:

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

これがsiteです: 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 :)
15
Eugen Konkov

ローカルリポジトリからコミットを元に戻すことができます。以下のシナリオに従ってください。

以下の画像では、(Gitコマンドgit checkout -b testを使用して) 'test'ブランチをローカルとしてチェックアウトし、(Gitコマンドgit statusを使用して)コミットするものがないことを確認しています。

Enter image description here

次の画像では、 Filter1.txt にいくつかの変更を加え、そのファイルをステージング領域に追加してから、(Gitコマンドgit commit -m "Doing commit to test revert back"を使用して)メッセージで変更をコミットしました。

" - mはコミットメッセージ用"

Enter image description here

次の画像では、コミットしたものが何であれ、コミットログが表示されます(Gitコマンドgit logを使用)。

Enter image description here

そのため、上の画像では、コミットごとにコミットIDを確認したり、コミットIDを元に戻したり元に戻したりして、下のGitコマンド git revert {"paste your commit id"}を実行します。例:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

Enter image description here

前回のコミットを元に戻しました。 Gitのステータスを確認すると、 Filter1.txt という変更されたファイルがまだコミットされていないことがわかります。

Enter image description here

14
Raj S. Rusia

最後のコミットを元に戻す最も簡単な方法は次のとおりです。

git reset HEAD^

これにより、コミットする前にプロジェクトの状態になります。

14
Arun Karnawat

IntelliJ IDEAを押すと、Gitリポジトリログを開くことができます。 Alt+9、マウスの右ボタンでコミットリストからタグをクリックして、"現在のブランチをここにリセット..."を選択します。

13

HEAD:

リセットコミットの前に、HEADについて知っておく必要があります... HEADは作業ディレクトリ内の現在の状態に他なりません。コミット番号で表されます。

Git commit:

各変更は、一意のタグで表されるコミットの下で割り当てられます。コミットを削除することはできません。ですから、最後のコミットが欲しいなら、git resetを使ってそれに飛び込むことができます。

2つの方法で最後のコミットに飛び込むことができます。

方法1: (コミット番号がわからないが、一番最初に移動したい場合)

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

方法2: (あなたがコミットを知っていればあなたは単にあなたの知られているコミットにリセットします)

git reset 0xab3#コミット番号

注: 最近のコミットを知りたい場合はgit log -p -1を試してください。

これがグラフィック表示です。

Enter image description here

13

履歴を清潔に保ちたい場合はコミットを削除してコミットするのが一番良いでしょう。

一番上のコミットをやめる必要があるなら、次のようなワンライナーが役に立ちます。

git rebase --onto HEAD~1 HEAD

しかし、たくさんのコミットのうちの1つを落としたいのなら、あなたは言った

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

そしてコミット 'c'を削除したい

git rebase --onto b c

これは、 'b'を 'd'の新しい基数として、 'c'を削除することになります。

12
Khem

次の方法でログを見て、最後のコミットハッシュコードを見つけます。

git log

それから

git reset <the previous co>
12
Praveen Singh

完全を期すために、これまでの答えで見落とされていた明らかに明白な方法を1つ挙げます。

コミットがプッシュされていないので、リモートは変更されていません。

  1. ローカルリポジトリを削除します。
  2. リモートリポジトリを複製します。

あなたの空想Gitクライアントがさようならを行くなら、これは時々必要です。 (例:non-fast-forwardエラー)

前回のプッシュ以降に saved の変更を再度コミットすることを忘れないでください。

11

enter image description here

あなたがVisual Studioで働いていると仮定して、あなたがあなたにブランチヒストリーに入って、そしてあなたのすべてのコミットを見るならば、単にあなたが元に戻したいコミットの前のイベントを選択し、それを右クリックしそしてRevertを選択してください。それは簡単です。

11
Uchiha Itachi

あなたが間違ったファイルを排除したいのならあなたがすべきです 

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

8
nPcomp

これを試して、それらのファイルが追加されていない以前のコミットにハードリセットしてから:

git reset --hard <commit_hash>

念のため、あなたが行った変更のバックアップがあることを確認してください。

7
serdarsenay
git reset --soft HEAD~1

リセットすると、現在のHEADブランチが指定したリビジョンに巻き戻されます。--softフラグ:これにより、元に戻したリビジョンでの変更が確実に保持されます。このコマンドを実行した後、作業コピーの中でコミットされていないローカルな変更として変更が見つかります。

これらの変更を維持したくない場合は、単純に--hardフラグを使用してください。あなたがもうこれらの変更を必要としないと確信しているときだけこれをするようにしてください。

 git reset --hard HEAD~1

複数のコミットを元に戻す

git reset --hard 0ad5a7a6

ただし、resetコマンドを使用すると、戻った後に発生したコミットはすべて取り消されます。 enter image description here

6
Abu Bakr

コミットを元に戻す必要があるたびに、私は何をしますか。

  1. git reset HEAD~<n> //元に戻す必要がある最後のコミットの数
  2. git status //オプションすべてのファイルは赤で表示されています(ステージングされていません)。

  3. これで、必要なファイルだけを追加してコミットできます。

    • git add <file names> & git commit -m "message" -m "details"
  4. オプション:必要に応じて、チェックアウトを使用して残りのファイルの変更を以前の状態にロールバックすることができます。
    • git checkout <filename>
  5. 以前にリモートOriginにプッシュしたことがある場合は、
    • git Push Origin <branch name> -f //プッシュを強制するには-fを使用してください。
6
Theo Itzaris

リポジトリの最初のコミットを元に戻したい場合

あなたはこの問題に遭遇するでしょう:

$ 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 .
5
Nicholas

次の手順に従ってください。役に立つかもしれません。

ステップ:1

git logをヒット

ログのリストから、最後のコミットハッシュコードを見つけて入力します。

ステップ:2

git reset <hash code>
4
Paras Korat

このコマンドを使用して最後のコミットIDを取得します(一番上のログのものでは最新のものです)。

git log

コミットID(GUID)を取得して次のコマンドを実行します。

git revert <commit_id>
3

編集 以前のコミット方法

一般的に、私はたくさんのコミットを元に戻すのではなく、最初にコミットした方がいいように以前のコミットを編集します。

私は自分自身のためにスクリプトを書いたのに十分な頻度で過去のコミットを直していました。

これがワークフローです。

  1. git commit-edit <commit-hash>
    

    これはあなたが編集したいコミットであなたをドロップします。

    コミットの変更は un ステージングされ、初めての場合はステージングする準備が整います。

  2. 最初にコミットされたことを望み通りに修正してステージングします。

    git stash save --keep-indexを使用して、コミットしていないファイルを整理することができます)

  3. --amendでコミットをやり直してください。例えば:

    git commit --amend
    
  4. リベースを完了します。

    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 "[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

あなたが単にあなたのローカルな変更/コミットをすべて捨てて、あなたのローカルブランチをあなたが始めたOriginブランチのように見せたいだけなら...

git reset --hard Origin/branch-name

1
JeremyWeir

私はこれらの同じ問題を自分で経験した後、この時代について書きました。

https://ao.gl/how-to-delete-revert-a-git-commit/

基本的にはあなたがする必要があるのは:

git log、SHAの最初の7文字を取得し、git revert <sha>に続いてgit Push --forceを実行します。

次のようにGit revertコマンドを使用して、これを元に戻すこともできます:git revert <sha> -m -1、次にgit Push

1
Andrew Odendaal
git revert commit

これは、元に戻すことを望むコミットから反対の変更を生成し、それからその変更をコミットするだけです。これが最も簡単な方法だと思います。

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

1
Gjorgi Gjorgiev

git revert <commit-id>を使用できます。

コミットIDを取得するには、git logを使用します。

1
Videsh

あなたの変更を含むあなたのローカルのバージョンをサーバのバージョンに置き換えてください。この2行のコードはgitにローカルのpullと上書きを強制するでしょう。コマンドプロンプトを開き、gitプロジェクトのルートに移動します。 VSを使用している場合は、チーム、同期をクリックして、下の「コマンドプロンプトを開く」(画像を参照)をクリックしてください。 

Visual Studio

Cmd Promptに入ったら、次の2つの指示に従ってください。 

git fetch --all

それなら

git reset --hard Origin/master

これは既存のローカルバージョンを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