誤って間違ったファイルをGitにコミットしましたが、まだサーバーにコミットをプッシュしていません。
ローカルリポジトリからこれらのコミットを元に戻すにはどうすればよいですか？
唯一の方法は、ある種のGUIテキストエディタで編集をコピーし、ローカルクローン全体をワイプし、リポジトリを再クローンしてから、編集を再適用することだと思われます。でも、
git commit。もっと良い方法はありますか？
$ 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 add新しいコミットに含めたいものは何でも。
古いコミットメッセージを再利用して、変更をコミットします。reset古い頭をにコピーしました.git/ORIG_HEAD; commitwith-c ORIG_HEADはエディターを開きます。エディターには、最初は古いコミットからのログメッセージが含まれており、編集することができます。メッセージを編集する必要がない場合は、この-Cオプションを使用できます。
または、前のコミット（またはそのコミットメッセージのみ）を編集するにcommit --amendは、現在のインデックス内の変更を前のコミットに追加します。
サーバーにプッシュされたコミットを削除（元に戻さない）するには、履歴をで書き換えるgit push origin master --force必要があります。
HEADを前の場所に戻すにはどうすればよいですか？（切り離された頭）＆元にコミットコミット
上記の回答はgit reflog、元に戻したいコミットのSHA-1を決定するために使用できるを示しています。この値を取得したら、上記で説明した一連のコマンドを使用します。
HEAD~と同じHEAD~1です。記事gitのHEADとは何ですか？複数のコミットをコミット解除する場合に役立ちます。
コミットの仕組みがわからない場合、コミットを元に戻すのは少し怖いです。しかし、あなたが理解していれば、それは実際には驚くほど簡単です。コミットを元に戻すことができる4つの異なる方法を紹介します。
git reset --hardこれがあるとしましょう。ここで、CはHEADで、（F）はファイルの状態です。
(F)
A-B-C
↑
master
コミットCを削除し、それを二度と表示せず、ローカルで変更されたファイルのすべての変更を失いたいとします。これをして：
git reset --hard HEAD~1
結果は次のとおりです。
(F)
A-B
↑
master
これでBがHEADになります。を使用したため--hard、ファイルはコミットBでの状態にリセットされます。
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ポインターを1つのコミットに戻すように指示します。ただし、（使用しない限り--hard）ファイルはそのままにしておきます。これgit statusで、Cにチェックインした変更が表示されます。何も失われていません。
git reset --soft最軽量の場合は、コミットを元に戻すこともできますが、ファイルとインデックスはそのままにしておきます。
git reset --soft HEAD~1
これにより、ファイルがそのままになるだけでなく、インデックスもそのままになります。を実行するとgit status、以前と同じファイルがインデックスに含まれていることがわかります。実際、このコマンドの直後に実行でき、git commit今行ったのと同じコミットをやり直すことになります。
git reset --hard、そのコードを取り戻す必要がありますもう1つ：最初の例のようにコミットを破棄したが、結局それが必要であることに気付いたとしますか？頑張ってね？
いいえ、それを取り戻す方法はまだあります。git reflog入力すると、移動した（部分的な）コミットシャ（つまり、ハッシュ）のリストが表示されます。破棄したコミットを見つけて、次のようにします。
git checkout -b someNewBranchName shaYouDestroyed
これで、そのコミットが復活しました。コミットは実際にはGitで約90日間破棄されないため、通常は戻って、削除するつもりがなかったコミットをレスキューできます。
コミットをすでに公開（リモートリポジトリにプッシュ）しているかどうかに応じて、最後のコミットを「元に戻す」には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の基本-元に戻すことを確認してください。
ファイルを追加/削除して、希望どおりの方法でファイルを作成します。
git rm classdir
git add sourcedir
次に、コミットを修正します。
git commit --amend
以前の誤ったコミットは、新しいインデックスの状態を反映するように編集されます。つまり、最初から間違いを犯したことがないようになります。
まだプッシュしていない場合にのみこれを行う必要があることに注意してください。プッシュした場合は、通常どおり修正をコミットする必要があります。
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"
また
git reset --hard HEAD~1
警告：上記のコマンドは.java、コミットしたいファイル（およびその他のファイル）への変更を完全に削除します。
hard resettoHEAD-1は、間違ったコミットの前に、作業コピーをコミットの状態に設定します。
インデックス内のファイルを置き換えます。
git rm --cached *.class
git add *.java
次に、それがプライベートブランチの場合は、コミットを修正します。
git commit --amend
または、共有ブランチの場合は、新しいコミットを行います。
git commit -m 'Replace .class files with .java files'
（以前のコミットを変更するには、素晴らしいインタラクティブリベースを使用してください。）
ProTip™：gitignore*.classに追加して、これが再び発生しないようにします。
最後のコミットを変更する必要がある場合は、コミットを修正することが理想的な解決策ですが、より一般的な解決策は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
を使用しgit revert <commit-id>ます。
コミットIDを取得するには、を使用しますgit log。
ローカルコミットを完全に元に戻すことを計画している場合は、コミットで行った変更が何であれ、それについて何も心配しない場合は、次のコマンドを実行します。
git reset --hard HEAD^1
（このコマンドはコミット全体を無視し、変更はローカルの作業ツリーから完全に失われます）。コミットを元に戻したいが、ステージング領域での変更が必要な場合（コミット前と後のようにgit add）、次のコマンドを実行します。
git reset --soft HEAD^1
これで、コミットされたファイルがステージング領域に入ります。間違ったコンテンツを編集する必要があるためにファイルをアップステージしたい場合は、次のコマンドを実行します。
git reset HEAD
これで、ステージングされた領域からステージングされていない領域にファイルが送られるようにコミットされました。これでファイルを編集する準備ができたので、変更するものは何でも、編集して追加し、新しい/新しいコミットを行います。
Git Extrasがインストールされている場合は、実行git undoして最新のコミットを元に戻すことができます。git undo 3最後の3つのコミットを元に戻します。
共有リポジトリにある最新の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 git@bitbucket.org:thecompany/prometheus.git
+ 09a6480...5a74047 master -> master (forced update)
prompt>
私はこの仕事に使用することを好みますgit rebase -i。なぜなら、削除するコミットを選択できる素敵なリストがポップアップするからです。ここでの他の答えほど直接的ではないかもしれませんが、それはちょうどいい感じです。
リストするコミットの数を選択し、次のように呼び出します（最後の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は、削除した行のコミットを削除します。
git-gui（または同様のもの）を使用してを実行しgit commit --amendます。GUIから、コミットから個々のファイルを追加または削除できます。コミットメッセージを変更することもできます。
ブランチを以前の場所にリセットするだけです（たとえば、gitkまたはを使用してgit rebase）。次に、保存したコピーから変更を再適用します。ローカルリポジトリでガベージコレクションを実行すると、不要なコミットが発生しなかったようになります。これらすべてを1つのコマンドで実行するには、を使用します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)
通常の場合、プライベートブランチのコミット履歴が元の状態であることを心配する必要はおそらくありません。フォローアップコミットをプッシュするだけで（上記の「パブリックコミットを元に戻す方法」を参照）、後でスカッシュマージを実行して履歴を非表示にします。
完全に元に戻したい場合で、リポジトリのクローンを作成しました。
コミットIDは次の人が見ることができます：
git log
次に、次のように行うことができます。
git reset --hard <commit_id>
git push origin <branch_name> -f
ジャンクをコミットしたがプッシュされていない場合は、
git reset --soft HEAD~1
HEAD〜1は、headの前のコミットの省略形です。または、リセットする場合は、ハッシュのSHA-1を参照できます。--softオプションはコミットを削除しますが、git statusが示すように、変更されたすべてのファイルを「コミットする変更」のままにします。
ヘッドの前のコミット以降に作業ツリー内の追跡されたファイルへの変更を取り除きたい場合は、代わりに「 --hard 」を使用してください。
また
すでにプッシュして誰かがプルした場合（通常は私の場合）、gitresetを使用することはできません。ただし、gitrevertを実行することはできます。
git revert HEAD
これにより、偶発的なコミットによって導入されたすべてを元に戻す新しいコミットが作成されます。
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.
単一のコマンド：
git reset --soft 'HEAD^'
最後のローカルコミットを元に戻すのは素晴らしいことです！
以下のコマンドを使用してリセットするだけgitです：
git reset --soft HEAD~1
説明：git reset基本的には、戻りresetたいコミットに対してです。それを--softキーと組み合わせると、元に戻りますが、ファイルの変更は保持されるため、ステージに戻ります。ファイルが追加されたばかりHEADで、ブランチのヘッドであり、と組み合わせると~1（この場合はも使用しますHEAD^）、必要なコミットを1つだけ戻します...
以下の画像に、実際の状況で発生する可能性のあるすべてのステップやコードのコミットなど、詳細なステップを作成します。
最後のGitコミットを元に戻す方法は？
すべてを最後のコミット前の状態に戻すには、HEADの前にコミットにリセットする必要があります。
行った変更を保持したくない場合：
git reset --hard HEAD^
変更を保持したい場合：
git reset --soft HEAD^
次に、gitログを確認します。最後のコミットが削除されたことが表示されます。
「作業ツリーを最後のコミットにリセットしてください」
git reset --hard HEAD^
「作業ツリーから不明なファイルを削除する」
git clean
注：このコマンドは以前のコミットを削除するため、注意して使用してください。git reset --hardより安全です。
reflogを使用して正しい状態を見つけます
git reflog
リセット前の再ログ
正しいreflog（私の場合はf3cb6e2）を選択し、次のように入力します
git reset --hard f3cb6e2
その後、リポジトリHEADはリセット後にそのHEADid
ログにリセットされます
最後に、reflogは次の図のようになります
REFLOG FINAL
ファーストラン：
git reflog
リポジトリで実行した可能性のあるすべてのアクション（コミット、マージ、プルなど）が表示されます。
次に、次のことを行います。
git reset --hard ActionIdFromRefLog
git reset --soft HEAD^またgit reset --soft HEAD~
これにより、最後のコミットが取り消されます。
--softこれは、ステージングにリセットすることを意味します。
HEAD~またはHEAD^HEADの前にコミットするために移動することを意味します。
git commit --amend -m "message"
最後のコミットが新しいコミットに置き換えられます。
別の方法：
復元するブランチをチェックアウトしてから、ローカルの作業コピーをリセットして、リモートサーバー上で最新のブランチにしたいコミットに戻します（それ以降はすべてバイバイになります）。これを行うには、SourceTreeで右クリックし、[BRANCHNAMEをこのコミットにリセット]を選択しました。
次に、リポジトリのローカルディレクトリに移動して、次のコマンドを実行します。
git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
これにより、ローカルリポジトリ内の現在のコミット以降のすべてのコミットが消去されますが、その1つのブランチのみが消去されます。
git log最後のコミットハッシュコードを入力して見つけ、次のように入力します。
git reset <the previous co>
私の場合、やりたくないファイルを誤ってコミットしてしまいました。だから私は次のことをしました、そしてそれはうまくいきました：
git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD
gitkまたはgitlog--statを使用して結果を確認します
簡単です。コマンドラインでこれを実行します。
git reset --soft HEAD~
2つの主なシナリオがあります
まだコミットをプッシュしていません
問題がコミットした余分なファイルであった場合（そしてそれらをリポジトリに残したくない場合）、を使用してそれらを削除し、でコミットすることができgit rmます--amend
git rm <pathToFile>
ディレクトリ全体を、で削除したり、他のBashコマンド-rと組み合わせたりすることもできます
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リポジトリからも削除されます。
すでにコミットをプッシュしました
他のシナリオと同じソリューションを適用してgit pushから-fオプションを使用することもできますが、リモート履歴が異なる変更で上書きされるため、お勧めしません（リポジトリを混乱させる可能性があります）。
代わりに、コミットせずにコミットする必要があります--amend（-amend`についてこれを覚えておいてください：このオプションは最後のコミットの履歴を書き換えます）。
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）のマニュアルページを参照してください。
以前のリビジョンにリセットするには、コミットされていないすべての変更を完全に削除します。
git reset --hard HEAD~1
reset --softまたはreset --hard？@Kyralessaの回答に2セントを追加しています。
何を使用すればよいかわからない場合は、--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に送られます。
それを行うには多くの方法があります。
最後のコミット/前のコミットを元に戻す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
SourceTree （Gitのグラフィカルツール）を使用して、コミットとツリーを確認します。右クリックすると、手動で直接リセットできます。
code.txtファイルがあると思います。いくつか変更を加えてコミットします。
このコミットは3つの方法で元に戻すことができますが、最初にステージングされたファイルとは何かを知っておく必要があります...ステージングされたファイルはコミットする準備ができているファイルであり、git statusこのファイルを実行すると緑色で表示され、ステージングされていない場合コミットの場合は赤い色で表示されます：
これは、変更をコミットした場合、このファイルの変更は保存されないことを意味します。このファイルをステージに追加してgit add code.txtから、変更をコミットできます。
最後のコミットを元に戻す：
これで、他の変更を加えずにコミットを元に戻したい場合は、次を使用できます。
git reset --soft HEAD^
コミットとその変更を元に戻したい場合（変更が失われるため、これは危険です）、次を使用できます
git reset --hard HEAD^
そして、コミットを元に戻し、ステージから変更を削除したい場合は、
git reset --mixed HEAD^または短い形式でgit reset HEAD^
通常、ミスを犯して修正したいので、コミットを元に戻したいと思います。基本的に、OPが質問したときに行ったことです。本当に、あなたは実際にコミットをやり直したいのです。
ここでの回答のほとんどは、コマンドラインに焦点を当てています。コマンドラインは、Gitに慣れているときに使用するのに最適な方法ですが、他のバージョン管理システムからGitに送られるものにはおそらく少し異質です。
GUIを使用してこれを行う方法は次のとおりです。Gitをインストールしている場合は、これらの手順に従うために必要なものがすべて揃っています。
注：ここでは、コミットをプッシュする前に、コミットが間違っていることに気付いたと想定します。プッシュの意味がわからない場合は、プッシュしていない可能性があります。指示を続けてください。障害のあるコミットをプッシュした場合、最もリスクの低い方法は、障害のあるコミットを、履歴を書き換えることができないバージョン管理システムで行う方法である、問題を修正する新しいコミットでフォローアップすることです。
そうは言っても、GUIを使用して最新のフォールトコミットを修正する方法は次のとおりです。
git gui次を使用できます。
git reset HEAD@{1}
このコマンドは、Gitログなしで間違ったコミットを削除します。
最後のコミットを元に戻す
コードへの最後のコミットを本当に元に戻したい状況はたくさんあります。たとえば、広範囲に再構築したい、または完全に破棄したいからです。
このような場合、「リセット」コマンドが親友です。
$ git reset --soft HEAD~1
上記のコマンド（リセット）は、現在のHEADブランチを指定されたリビジョンに巻き戻します。上記の例では、現在のリビジョンの前の例に戻したいと思います。つまり、最後のコミットを事実上元に戻します。
フラグに注意してください--soft。これにより、元に戻されたリビジョンの変更が確実に保持されます。コマンドを実行すると、作業コピーにコミットされていないローカル変更として変更が表示されます。
これらの変更を保持したくない場合は、--hardフラグを使用してください。これらの変更が不要であることが確実な場合にのみ、これを行うようにしてください。
$ git reset --hard HEAD~1
答える前に、これが何であるかを説明するいくつかの背景を追加しましょうHEAD。
First of all what is HEAD?HEAD単に現在のブランチの現在のコミット（最新）への参照です。
一度に存在できるのは1つだけHEADです。（を除くgit worktree）
のコンテンツHEADは内部.git/HEADに保存され、現在のコミットの40バイトのSHA-1が含まれています。
detached HEAD最新のコミットを行っていない場合、つまりHEAD、履歴内の以前のコミットを指している場合は、と呼ばれdetached HEADます。
HEADコマンドラインでは、次のようになります-現在のブランチの先端を指していないため、ブランチ名の代わりにSHA-1
git checkoutgit 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 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ます。
最後のコミットを元に戻すだけです。
git reset --soft HEAD~
または、前回コミットする前の時間を元に戻します。
git reset --soft HEAD~2
または、以前のコミットを元に戻します。
git reset --soft <commitID>
（を使用してcommitIDを取得できますgit reflog）
以前のコミットを取り消すときは、職場をきれいにすることを忘れないでください
git clean
詳細については、ドキュメントをご覧ください：git-reset
最後のコミットを元に戻したいが、コミットで行われた変更をローカルに保持したい場合は、次のコマンドを使用します。
git reset HEAD~1 --mixed
最後のコミットを元に戻します。
git reset --soft HEAD^ or git reset --soft HEAD~
これにより、最後のコミットが取り消されます。
--softこれは、ステージングにリセットすることを意味します。
HEAD~ or HEAD^HEADの前にコミットするために移動することを意味します。
最後のコミットを新しいコミットに置き換えます。
git commit --amend -m "message"
最後のコミットが新しいコミットに置き換えられます。
私の場合、間違ったブランチにコミットしてプッシュしたので、すべての変更を元に戻して、新しい正しいブランチにコミットできるようにすることでした。そのため、次のようにしました。
コミットしてプッシュしたのと同じブランチで、「git status」と入力すると、コミットしてプッシュしたため、新しいものは何も表示されません。ここで、次のように入力します。
git reset --soft HEAD~1
これにより、すべての変更（ファイル）がステージ領域に戻されます。次に、次のように入力するだけで、変更を作業ディレクトリ（ステージング解除）に戻します。
git reset FILE
ここで、「ファイル」は、再度コミットするファイルです。これで、このファイルは、行ったすべての変更を含む作業ディレクトリ（ステージングされていない）にあるはずです。これで、必要なブランチに変更して、そのブランチで変更をコミットできます。もちろん、コミットした最初のブランチはすべての変更を加えたままですが、私の場合は問題ありませんでした。そうでない場合は、そのブランチでそのコミットを元に戻す方法を探すことができます。
ローカルで間違ったコミットを行い、それをリモートリポジトリにプッシュしたとします。次の2つのコマンドを使用して、混乱を元に戻すことができます。
まず、必要なコミットに戻ってローカルリポジトリを修正する必要があります。
git reset --hard <previous good commit id where you want the local repository to go>
次に、次のコマンドを使用して、この適切なコミットをリモートリポジトリに強制的にプッシュします。
git push --force-with-lease
強制オプションの「リースあり」バージョンは、知らない新しいコミットの誤った削除を防ぎます（つまり、最後のプル以降に別のソースから来たものです）。
ローカルコミットを元に戻すには、を使用しますgit reset <commit>。また、そのチュートリアルは、それがどのように機能するかを示すのに非常に役立ちます。
または、次を使用することもできますgit revert <commit>。変更をロールバックする（ただし、プロジェクト履歴に保持する）別のコミットを追加する場合は、revertingを使用する必要があります。
VISUAL STUDIOユーザー（2015年など）
「開発」のようなブランチにプッシュすることが許可されていないためにVisualStudioで同期できない場合は、私が試した限り、Visual Studioではリバートもリセット（ハードまたはソフト）も機能しません。
多数の投票による回答によると：
プロジェクトのルートのコマンドプロンプトでこれを使用して、プッシュされようとするものをすべて削除します。
git reset --hard HEAD~1
作業内容を失いたくない場合などに備えて、ファイルをバックアップまたはzip形式で保存してください...
以前の回答でGit関連のコマンドについて話す際に、私の典型的なGitサイクルをすべての読者と共有したいと思います。これが私がGitでどのように作業するかです。
リモートサーバーからの最初のクローン作成
git clone $project
リモートからのプル（プッシュするための保留中のローカルコミットがない場合）
git pull
新しいローカルファイル1を$to_be_committed_listに追加します（$ to_be_committed_listがstaged領域を意味すると想像してください）
git add $file1
誤って追加されたfile2を$to_be_committed_listから削除します（file2がステップ3のように追加されたと仮定しますが、これは不要でした）
git reset $file2
$to_be_committed_listにあるfile1をコミットしています
git commit -m "commit message description"
プッシュする前にローカルコミットをリモートリポジトリと同期する
git pull --rebase
競合が発生した場合の解決の前提条件configuremergetool
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.
誰もがとても複雑な方法でコメントします。
ブランチから最後のコミットを削除したい場合、それを行う最も簡単な方法は次のとおりです。
git reset --hard HEAD~1
最後のコミットを取り除くために実際にその変更をプッシュするには、次のことを行う必要があります
git push --force
以上です。これにより、最後のコミットが削除されます。
このような場合、「リセット」コマンドが親友です。
git reset --soft HEAD~1
リセットすると、現在のHEADブランチが指定されたリビジョンに巻き戻されます。上記の例では、現在のリビジョンの前の例に戻したいと思います。つまり、最後のコミットを事実上元に戻します。
--softフラグに注意してください。これにより、元に戻されたリビジョンの変更が確実に保持されます。コマンドを実行すると、作業コピーにコミットされていないローカル変更として変更が表示されます。
これらの変更を保持したくない場合は、-hardフラグを使用するだけです。これらの変更が不要であることが確実な場合にのみ、これを行うようにしてください。
git reset --hard HEAD~1
すでにGithubにプッシュされている間違ったコミットを削除します
git push origin +(previous good commit id):(branch name)
Githubでリセットする最後の適切なコミットIDを指定してください。
例えば。最新のコミットIDが間違っている場合は、上記のgitコマンドで前のコミットIDをブランチ名で指定します。
以前のコミットIDは次を使用して取得できますgit log
最後のコミット（のすべての変更）を取り除くために、最後の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
ハードオプションには注意してください。リポジトリ内のローカルの変更も削除され、前述のコミットに戻ります。これを実行するのは、最後のコミットで混乱したことが確実で、時間を遡りたい場合にのみ実行してください。
補足として、コミットハッシュは約7文字で十分ですが、大規模なプロジェクトでは、一意にするために最大12文字が必要になる場合があります。必要に応じて、コミットSHA全体を使用することもできます。
上記のコマンドは、GitHubforWindowsでも機能します。
からコミットIDを取得してからbitbucket、次のことを実行しました。
git checkout commitID .
例：
git checkout 7991072 .
そして、それをそのコミットの作業コピーに戻しました。
あなたは簡単かつ迅速に行う必要があります
git commit --amend
プライベートブランチの場合または
git commit -m 'Replace .class files with .java files'
共有ブランチまたはパブリックブランチの場合。
次の手順に従ってください。
ステップ1
打つgit log
ログのリストから、最後のコミットハッシュコードを見つけて、次のように入力します。
ステップ2
git reset <hash code>
このコマンドを使用する
git checkout -b old-state 0d1d7fc32
次のコマンドを使用します。
git checkout -b old-state number_commit
いつでもgit checkout <SHA code> 以前のバージョンを実行してから、新しいコードで再度コミットできます。
Gitコミットは2つの方法で元に戻すことができます。1つはgit revert、コミット履歴を保持したい場合に使用できることです。
git revert HEAD~3
git revert <hashcode of commit>
2つ目は、を使用できることですgit reset。これにより、すべてのコミット履歴が削除され、必要な場所に頭をコミットできます。
git reset <hashcode of commit>
git reset HEAD~3
キーワードのいずれかが別の方法で動作し始めた場合は、キーワードを使用することもでき--hardます。しかし、私はそれが非常に必要になるまでそれをお勧めします。
git reset --soft HEAD~1
リセットすると、現在のHEADブランチが指定されたリビジョンに巻き戻されます。
フラグに注意してください--soft。これにより、元に戻されたリビジョンの変更が確実に保持されます。コマンドを実行すると、作業コピーにコミットされていないローカル変更として変更が表示されます。
これらの変更を保持したくない場合は、--hardフラグを使用してください。これらの変更が不要であることが確実な場合にのみ、これを行うようにしてください。
git reset --hard HEAD~1
複数のコミットを元に戻す
git reset --hard 0ad5a7a6
ただし、resetコマンドを使用すると、次の場所に戻った後に行われたすべてのコミットが取り消されることに注意してください。
リポジトリにコミットしたことを元に戻す方法を説明しているこのサイトを見つけました。
いくつかのコマンド：
git commit --amend # Change last commit
git reset HEAD~1 --soft # Undo last commit
ここにサイトがあります：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 :)
ローカルリポジトリからコミットを元に戻すことができます。以下のシナリオに従ってください。
次の画像では、「test」ブランチ（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であり、まだコミットされていない変更されたファイルを確認できます。
前提条件：リポジトリ内の既存のファイルに変更が加えられた場合、この変更は最初はステージングされていないと見なされます。変更をコミットするには、ステージングする必要があります。つまり、を使用してインデックスに追加し
git addます。コミット操作中に、ステージングされたファイルがインデックスに追加されます。
例を見てみましょう：
- A - B - C (master)
HEADを指しC、インデックスが一致しCます。
git reset --soft B目的で実行する場合。git statusれていることがわかります。git commitこの時点でを実行すると、Cと同じ変更を加えた新しいコミットが作成されますgit reset --mixed Bます。git add通常どおりにコミットします。git reset --hard Bコマンドで使用できるフラグのこの比較が、git reset誰かがそれらを賢く使用するのに役立つことを願っています。link1とlink2の詳細については、これらを参照してください
最後のコミットを元に戻す最も簡単な方法は
git reset HEAD^
これにより、コミットする前にプロジェクトの状態が表示されます。
Gitコミットから一部のファイルを削除するには、「-soft」オプションを指定して「gitreset」コマンドを使用し、HEADの前にコミットを指定します。
$ git reset --soft HEAD~1
このコマンドを実行すると、最新のコミット（HEAD）のファイルが表示され、それらをコミットできるようになります。
ファイルがステージング領域にあるので、「gitreset」コマンドを再度使用してファイルを削除（またはステージング解除）できます。
$ git reset HEAD <file>
注：今回は、ステージング領域からファイルを除外したいだけなので、HEADからリセットします。
このファイルに興味がなくなった場合は、「git rm」コマンドを使用して、インデックス（ステージング領域とも呼ばれます）からファイルを削除できます。
$ git rm --cached <file>
変更が完了したら、「–amend」オプションを使用して変更を再度コミットできます。
$ git commit --amend
ファイルがリポジトリから正しく削除されたことを確認するには、「git ls-files」コマンドを実行して、ファイルがファイルに表示されないことを確認します（もちろん新しいファイルの場合）。
$ git ls-files
<file1>
<file2>
Git 2.23以降、コミットからファイルを削除する新しい方法がありますが、2.23以降のGitバージョンを使用していることを確認する必要があります。
$ git --version
Gitバージョン2.24.1
注：Git 2.23は2019年8月にリリースされたため、このバージョンがコンピューターでまだ利用できない場合があります。
新しいバージョンのGitをインストールするには、このチュートリアルを確認してください。コミットからファイルを削除するには、「git restore」コマンドを使用し、「-source」オプションを使用してソースを指定し、リポジトリから削除するファイルを指定します。
たとえば、HEADから「myfile」という名前のファイルを削除するには、次のコマンドを記述します。
$ git restore --source=HEAD^ --staged -- <file>
例として、「マスター」ブランチでの最新のコミットでファイルを編集したとしましょう。
ファイルは正しくコミットされていますが、Gitリポジトリから削除したいと考えています。
Gitリポジトリからファイルを削除するには、最初にファイルを復元する必要があります。
$ git restore --source=HEAD^ --staged -- newfile
$ git status
あなたのブランチは「origin/master」より1コミット進んでいます。（「gitpush」を使用してローカルコミットを公開します）
コミットする変更：
(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
ご覧のとおり、ファイルはステージング領域に戻っています。
そこから、2つの選択肢があります。ファイルを編集して再度コミットするか、Gitリポジトリからファイルを削除するかを選択できます。
このセクションでは、Gitリポジトリからファイルを削除するための手順について説明します。
まず、ステージングされている場合はファイルを削除できないため、ファイルのステージングを解除する必要があります。
ファイルのステージングを解除するには、「git reset」コマンドを使用して、ソースとしてHEADを指定します。
$ git reset HEAD newfile
ファイルが正しくステージングされていない場合は、「-cached」オプションを指定して「gitrm」コマンドを使用し、このファイルをGitインデックスから削除します（これにより、ディスク上のファイルは削除されません）
$ git rm --cached newfile
rm'newfile'
これで、リポジトリのステータスを確認すると、Gitが削除コミットをステージングしたことがわかります。
$ git status
あなたのブランチは「origin/master」より1コミット進んでいます。（「gitpush」を使用してローカルコミットを公開します）
コミットする変更：
(use "git restore --staged <file>..." to unstage)
deleted: newfile
ファイルがステージングされたので、リポジトリから最新のコミットを修正するには、「-amend」オプションを指定した「gitcommit」を使用するだけです。
`$ 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
「ご覧のとおり、これによって新しいコミットは作成されませんが、変更を含めるために、基本的に最新のコミットが変更されます。
場合によっては、すべてのファイルを再度ステージングする必要はありません。リポジトリの1つの非常に特定のファイルを変更するのは1つだけです。
Gitコミットから特定のファイルを削除するには、「– soft」オプションを指定して「gitreset」コマンドを使用し、HEADの前のコミットと削除するファイルを指定します。
$ git reset HEAD^ -- <file>
変更が完了すると、ファイルはステージング領域に戻ります。
まず、「git reset」コマンドを使用してステージング領域からファイルを削除し、HEADからリセットすることを指定できます。
$ git reset HEAD <file>
注：これは、このファイルの変更が失われることを意味するのではなく、ファイルがステージング領域から削除されることを意味します。
インデックスからファイルを完全に削除する場合は、「-cached」オプションを指定して「gitrm」コマンドを使用する必要があります。
$ git reset HEAD <file>
ファイルがステージング領域から正しく削除されたことを確認するには、「gitls-files」コマンドを使用してインデックスに属するファイルを一覧表示します。
$ git ls-files
変更が完全に完了したら、「-amend」オプションを指定した「gitcommit」コマンドを使用して、ファイルを削除したコミットを修正できます。
$ git commit --amend
Git Extensionsがインストールされている場合は、コミットを簡単に元に戻す/元に戻すことができます（Git Extensionsはここからダウンロードできます）。
Git Extensionsを開き、元に戻すコミットを右クリックして、[コミットを元に戻す]を選択します。
ポップアップが開きます（下のスクリーンショットを参照）
元に戻された変更を直接コミットする場合、または元に戻された変更を手動でコミットする場合は、[コミットを自動的に作成する]を選択し、ボックスの選択を解除したまま、[このコミットを元に戻す]ボタンをクリックします。
完全を期すために、これまでの回答では見落とされていた、明白な方法を1つ挙げます。
コミットがプッシュされなかったため、リモートは変更されませんでした。
これは、派手なGitクライアントがさようならをする場合に必要になることがあります。（例：non-fast-forwardエラー）
最後のプッシュ以降に保存した変更を再コミットすることを忘れないでください。
頭：
コミットをリセットする前に、HEADについて知っておく必要があります...HEADは作業ディレクトリの現在の状態に他なりません。コミット番号で表されます。
Gitコミット：
一意のタグで表されるコミットの下で割り当てられた各変更。コミットは削除できません。したがって、最後のコミットが必要な場合は、を使用して簡単にそのコミットに飛び込むことができますgit reset。
次の2つの方法を使用して、最後のコミットに飛び込むことができます。
方法1:(コミット番号がわからないが、最初に移動したい場合）
git reset HEAD~1 # It will move your head to last commit
方法2:(コミットがわかっている場合は、既知のコミットにリセットするだけです）
git reset 0xab3＃コミット番号
注：最近のコミットを知りたい場合は、git log -p -1
グラフィカルな表現は次のとおりです。
git reset --hard <last good SHA>変更をリセットして新しいコミットを与えるために使用するだけです。を使用することもできますgit checkout -- <bad filename>。
あなたが間違ったファイルを排除したい場合はあなたがすべきです
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
AltIntelliJ IDEAでは、 +を押してGitリポジトリログを開き9、コミットリストからタグを右クリックして、[現在のブランチをここにリセット... ]を選択します。
パブリックブランチなどにパッチを提案するときに履歴をクリーンに保ちたい場合は、コミットのリベースとドロップが最適です。
最上位のコミットを削除する必要がある場合は、次のワンライナーが役立ちます
git rebase --onto HEAD~1 HEAD
しかし、あなたが言った多くのコミットの1つをドロップしたい場合
a-> b->c->d->マスター
コミット'c'を削除したい
git rebase --onto b c
これにより、「b」が「d」の新しいベースになり、「c」が削除されます。
git reset --soft HEAD~1
git status
ブランチマスター
の場合ブランチは「origin/master」より1コミット進んでいます。
（「gitpush」を使用してローカルコミットを公開します）コミットする変更
:(「gitrestore--staged...」を使用してステージングを解除します）新しいファイル：file1
git log --oneline --graph
- 90f8bb1（HEAD->マスター）2番目のコミット\
- 7083e29初期リポジトリコミット\
提案された効率的な方法を検証します。これを使用した具体的な例を次に示します。
最後のコミットを完全に元に戻す/キャンセルする場合（以下同様に、必要な数だけ）、次の3つの手順を実行します。
1：もちろん、到達したいコミットのID=SHAを取得します
$ git log
2：前のコミットを削除します
$ git reset --hard 'your SHA'
3：オプションを使用して元のGitHubに新しいローカル履歴を強制し-fます（最後のコミットトラックは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 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
変更を破棄せずに最後のローカルコミットを元に戻すために、この便利なエイリアスがあります~/.gitconfig
[alias]
undo = reset --soft HEAD^
次にgit undo、覚えやすいものを使用します。
答える前に、これが何であるかを説明するいくつかの背景を追加しましょうHEAD。
First of all what is HEAD?HEAD単に現在のブランチの現在のコミット（最新）への参照です。
常に1つしか存在できませんHEAD（を除くgit worktree）。
のコンテンツHEADは内部.git/HEADに保存され、現在のコミットの40バイトのSHA-1が含まれています。
detached HEAD最新のコミットを行っていない場合、つまりHEAD、履歴内の以前のコミットを指している場合は、と呼ばれdetached HEADます。
コマンドラインでは、次のようになります-HEADは現在のブランチの先端を指していないため、ブランチ名の代わりにSHA-1になります。
git checkoutgit 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 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ます。
OP：Gitで最新のローカルコミットを元に戻すにはどうすればよいですか？[いくつかのコミットの一部として]誤って間違ったファイルをコミットしました。
目的の結果に応じて、一連のコミットとして「元に戻す」にはいくつかの方法があります。以下の開始ケースを考慮するとreset、、、rebaseおよびfilter-branchすべてを使用して履歴を書き換えることができます。
C1とC2tmp.logを元に戻して、各コミットからファイルを削除するにはどうすればよいですか？
HEAD~2以下の例では、絶対コミット参照が使用されていますが、相対参照（または）に慣れている場合も同じように機能しますHEAD@{n}。
reset$ git reset --soft t56pi
を使用resetすると、ブランチを前の状態にリセットでき、複合された変更をステージングエリアに戻し、そこから不要な変更を破棄できます。
注：reset以前のすべての変更をステージング領域にクラスター化すると、個々のコミットメタデータが失われます。rebaseこれで問題が解決しない場合は、おそらく、またはfilter-branchその代わりに使用したほうがよいでしょう。
rebase$ git rebase --interactive t56pi
ブランチ内の問題のある各コミットをインタラクティブに使用するとrebase、書き換えが可能になり、不要な変更を変更して破棄できます。上のインフォグラフィックでは、右側のソースツリーが状態の投稿を示していrebaseます。
ステップバイステップ
t56pi）pickに置き換えて、変更するコミットを選択しますedit。保存して閉じます。HEAD、不要なファイルの削除、新しいコミットの作成が可能になります。注：上記の代替方法とは対照的にrebase、コミットメタデータの多くは保持されます。reset履歴の多くを保持したいが、不要なファイルのみを削除したい場合は、これがおそらく推奨されるオプションです。
filter-branch$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD
./tmp.log上記のコマンドは、目的の範囲内のすべてのコミットからファイルを除外しますt56pi..HEAD（上記からの最初の開始ケースを想定）。わかりやすくするために、下の図を参照してください。
と同様にrebase、filter-branchブランチのサブセクションから不要なファイルをワイプするために使用できます。リベースプロセスを通じて各コミットを手動で編集する代わりに、各コミットでfilter-branch目的のアクションを自動的に実行できます。
注：と同様rebaseにfilter-branch、目的のファイルを破棄するだけで、残りのコミットメタデータを保持します。C1とC2がどのように書き換えられ、各コミットからログファイルが破棄されたかに注意してください。
ソフトウェア開発に関連するものと同じように、与えられた問題に対して同じ（または同様の）結果を達成するための複数の方法があります。特定のケースに最も適したものを選択する必要があります。
上記の3つの選択肢はすべて、履歴を完全に書き換えることに注意してください。自分が何をしているかを正確に理解していて、チーム内で良好なコミュニケーションが取れていない限り、リモートでまだ公開されていないコミットのみを書き直してください。
出典：上記のすべての例は、このブログから借用しています。
次の方法でログを確認して、最後のコミットハッシュコードを見つけます。
git log
それで
git reset <the previous co>
Visual Studioで作業していると仮定して、ブランチ履歴に移動してすべてのコミットを確認する場合は、元に戻すコミットの前のイベントを選択し、右クリックして、を選択しますRevert。そのように簡単です。
コミット/コミットを元に戻す必要があるたびに行うことは次のとおりです。
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を使用してプッシュを強制します。変更を含むローカルバージョンをサーバーバージョンに置き換えます。これらの2行のコードは、Gitにローカルをプルして上書きするように強制します。
コマンドプロンプトを開き、Gitプロジェクトルートに移動します。Visual Studioを使用している場合は、[チーム] 、 [同期]の順にクリックし、下の[コマンドプロンプトを開く]（画像を参照）をクリックします。
Cmdプロンプトが表示されたら、次の2つの手順に進みます。
git fetch --all
その後、あなたはします
git reset --hard origin/master
これにより、既存のローカルバージョンがGitサーバー上のバージョンで上書きされます。
これを試して、それらのファイルが追加されていない前のコミットにハードリセットしてから、次のようにします。
git reset --hard <commit_hash>
ハードリセットであるため、万が一の場合に備えて、変更のバックアップがあることを確認してください。これは、変更が失われることを意味します（以前に隠しておいた場合を除く）。
私はこれらの同じ問題を自分で抱えた後、何年も前にこれについて書きました：
基本的にあなたはただする必要があります：
git log、SHAハッシュの最初の7文字を取得してから、git revert <sha>その後に。を実行しgit push --forceます。
次のようにGitrevertコマンドを使用して、これを元に戻すこともできます。git revert <sha> -m -1次にgit push。
この問題が発生します：
$ 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〜がないため、エラーが発生します。
「マスター」ブランチの唯一のコミットをリセットしたい場合
$ git update-ref -d HEAD
$ git rm --cached -r .
このコマンドを使用して最後のコミットIDを取得します（一番上のログの1つは最新のものです）：
git log
コミットID（GUID）を取得し、次のコマンドを実行します。
git revert <commit_id>
すべてのローカル変更/コミットを破棄して、ローカルブランチを元のブランチのように見せたい場合は...
git reset --hard origin/branch-name
一般的に、私はたくさんのコミットを元に戻したくはありませんが、最初にコミットしたかった方法に以前のコミットを編集します。
過去のコミットを頻繁に修正するので、そのためのスクリプトを作成しました。
ワークフローは次のとおりです。
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
を使用できますgit revert <commit-id>。
コミットIDを取得するには、を使用しますgit log。
git revert commit
これにより、元に戻したいコミットとは逆の変更が生成され、その変更をコミットするだけです。これが最も簡単な方法だと思います。
$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend
最後のコミットを修正するときは、古いコミットを邪魔にならずに新しいコミットを配置する新しい改善されたコミットに完全に置き換えるほど、修正しているわけではないことを理解することが重要です。事実上、前のコミットが発生しなかったかのようになり、リポジトリの履歴には表示されません。
コミットを修正することの明らかな価値は、「おっと、ファイルを追加するのを忘れた」または「最後のコミットでタイプミスを修正する」という形式のコミットメッセージでリポジトリ履歴を乱雑にすることなく、最後のコミットに小さな改善を加えることです。
私は通常、最近のコミットのコミットハッシュを最初に見つけます。
git log
次のようになります。commit {long_hash}
これをコピーしlong_hashてリセットします（同じファイルに戻る/そのコミット時の状態）：
git reset --hard {insert long_hash without braces}
#1) $ git commit -m "Something terribly misguided"
#2) $ git reset HEAD~
[必要に応じてファイルを編集]
#3) $ git add .
#4) $ git commit -c ORIG_HEAD
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
git reset HEAD@{n}最後のn個のアクションをリセットします。
リセットの場合、最後のアクションには、を使用しますgit reset HEAD@{1}。
リポジトリがローカルにコミットされていて、まだサーバーにプッシュされていない場合、それを解決する別の大雑把な/素人の方法は次のようになります。
Visual Studio Codeを使用すると、これが非常に簡単になります。
まず、次のコマンドを実行してコミットをリセットします。
git reset --hard HEAD~1
次に、次のコマンドを実行して、新しいコミットをプッシュします。
git push upstream head -f
git reset unwanted_fileステージングしたくないファイルでコマンドを使用できます。このコマンドを使用すると、変更したファイルをステージング領域から作業ディレクトリに移動できます。
最後のコミットに戻り、ログ履歴を削除したい場合
以下のコマンドを使用して、commitID SHA- 71e2e57458bde883a37b332035f784c6653ec509を持つ前のコミットに移動すると します。このコミットをポイントすると、このコミット後にログメッセージが表示されず、その後すべての履歴が消去されます。
git push origin + 71e2e57458bde883a37b332035f784c6653ec509 ^：master