Gitを使用して、最後のXコミットを1つのコミットにまとめる方法を教えてください。

マニュアルでgit rebase -i <after-this-commit>説明されているように、 2回目以降のコミットで「pick」を使用し、「squash」または「fixup」で置き換えます。

この例で<after-this-commit>は、SHA1ハッシュまたは現在のブランチのHEADからの相対位置のいずれかであり、rebaseコマンドでコミットが分析されます。たとえば、ユーザーが過去に現在のHEADから5つのコミットを表示したい場合、コマンドはgit rebase -i HEAD~5です。

あなたはせずに、かなり簡単にこれを行うことができますgit rebaseかgit merge --squash。この例では、最後の3つのコミットを押しつぶします。

新しいコミットメッセージを一から書きたい場合は、これで十分です。

git reset --soft HEAD~3 &&
git commit

既存のコミットメッセージを連結して新しいコミットメッセージの編集を開始する場合（つまり、pick / squash / squash /…/ squashのgit rebase -i指示リストから開始する場合と同様）、それらのメッセージを抽出して渡す必要があります。それらにgit commit：

git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"

これらの方法はどちらも、最後の3つのコミットを同じ方法で1つの新しいコミットに押しつぶします。ソフトリセットは、スカッシュしたくない最後のコミットにHEADを再ポイントするだけです。インデックスも作業ツリーもソフトリセットの影響を受けず、インデックスは新しいコミットの望ましい状態のままになります（つまり、「破棄しようとしている」コミットからのすべての変更がすでにあります）。

git merge --squashこれに使用できますgit rebase -i。これは、よりも少しエレガントです。あなたがマスターであり、最後の12のコミットを1つに潰したいとします。

警告：最初に作業をコミットしてください— git statusクリーンであることを確認してください（git reset --hardステージングされた変更とアンステージングされた変更が破棄されるため）

次に：

# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12

# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}

# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit

のドキュメントでgit mergeは、--squashオプションについて詳しく説明しています。

更新：この方法の唯一の本当の利点git reset --soft HEAD~12 && git commit、Chris Johnsenが彼の回答で提案つぶしているすべてのコミットメッセージが事前に入力されたコミットメッセージが得られることです。

git reset特にGit初心者は、可能な限り回避することをお勧めします。本当に多くのコミットに基づいてプロセスを自動化する必要がない限り、それほど珍しい方法はありません...

1. 押しつぶされるコミットを作業ブランチに配置します（まだコミットされていない場合）-これにはgitkを使用します
2. 対象のブランチをチェックしてください（例： 'master'）
3. git merge --squash (working branch name)
4. git commit

コミットメッセージはスカッシュに基づいて事前に入力されます。

クリスジョンセンの答えに基づいて、

bash：（またはWindowsのGit Bash）からグローバルな「スカッシュ」エイリアスを追加します。

git config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"; };f'

...またはWindowsのコマンドプロンプトを使用：

git config --global alias.squash "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

あなた~/.gitconfigは今このエイリアスを含むべきです：

[alias]
    squash = "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

使用法：

git squash N

...これは、最後のNコミットを包括的に自動的につぶします。

注：結果のコミットメッセージは、すべての押しつぶされたコミットを順番に組み合わせたものです。これに不満がある場合は、いつでもgit commit --amend手動で変更できます。（または、好みに合わせてエイリアスを編集します。）

この便利なブログ投稿のおかげで、このコマンドを使用して最後の3つのコミットを押しつぶすことができることがわかりました。

git rebase -i HEAD~3

これは、追跡情報/リモートリポジトリのないローカルブランチにいる場合でも機能するので便利です。

このコマンドはインタラクティブなリベースエディターを開き、通常どおりに並べ替え、スカッシュ、リワードなどを行うことができます。

インタラクティブなリベースエディターの使用：

インタラクティブなリベースエディターは、最後の3つのコミットを表示します。この制約はHEAD~3、コマンドの実行時に決定されましたgit rebase -i HEAD~3。

最新のコミットはHEAD、1行目に最初に表示されます。aで始まる行#はコメント/ドキュメントです。

表示されるドキュメントはかなり明確です。任意の行で、コマンドをから任意のコマンドに変更できpickます。

fixup上の行のコミットにコミットの変更を「押しつぶし」、コミットのメッセージを破棄するので、コマンドを使用することを好みます。

1行目のコミットはなのでHEAD、ほとんどの場合、そのままにしておきますpick。squashまたはfixupコミットを押しつぶす他のコミットがないので、使用することはできません。

コミットの順序を変更することもできます。これにより、時間的に隣接していないコミットをスカッシュまたは修正することができます。

実用的な日常の例

最近、新しい機能をコミットしました。それ以来、2つのバグ修正をコミットしました。しかし、私はコミットした新機能にバグ（またはおそらくスペルミス）を発見しました。なんてうるさい！コミット履歴を汚染する新しいコミットが必要ない！

私が最初にやることは間違いを修正し、コメントで新しいコミットをすることです squash this into my new feature!です。

次に、git logまたはgitkを実行して、新機能のコミットSHAを取得します（この場合1ff9460）。

次に、でインタラクティブなリベースエディターを起動しgit rebase -i 1ff9460~ます。~コミット後SHAは、エディタにコミットそれ含めるエディタに指示します。

次に、修正（fe7f1e0）を含むコミットを機能コミットの下に移動し、に変更pickしfixupます。

エディターを閉じると、修正により機能のコミットが抑制され、コミット履歴がきれいに表示されます。

これはすべてのコミットがローカルである場合にうまく機能しますが、すでにリモートにプッシュされているコミットを変更しようとすると、同じブランチをチェックアウトしている他の開発者に本当に問題を引き起こす可能性があります！

TortoiseGitを使用すると、次の機能を実行できますCombine to one commit。

1. TortoiseGitコンテキストメニューを開く
2. 選択する Show Log
3. ログビューで関連するコミットをマークします
4. Combine to one commitコンテキストメニューから選択

この関数は、必要な単一のgitステップをすべて自動的に実行します。残念ながらWindowsでのみ利用できます。

これを行うには、次のgitコマンドを使用できます。

 git rebase -i HEAD~n

n（= 4 here）は最後のコミットの数です。次に、次のオプションがあります、

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

以下のようにpick1つのコミットとsquash他のコミットを最新のものに更新します。

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

詳細については、リンクをクリックしてください

この記事に基づいて、私はこの方法が私のユースケースにとってより簡単であることを発見しました。

私の 'dev'ブランチは 'origin / dev'より96コミット進んでいました（これらのコミットはまだリモートにプッシュされていません）。

変更をプッシュする前に、これらのコミットを1つにまとめたいと思いました。ブランチを 'origin / dev'の状態にリセットし（これにより、96コミットからのすべての変更がステージングされないままになります）、変更を一度にコミットすることを好みます。

git reset origin/dev
git add --all
git commit -m 'my commit message'

コミットを組み合わせるブランチで、次のコマンドを実行します。

git rebase -i HEAD~(n number of commits back to review)

例：

git rebase -i HEAD~1

これによりテキストエディターが開き、これらのコミットをマージする場合は、各コミットの前にある「ピック」を「スカッシュ」に切り替える必要があります。ドキュメントから：

p、pick =コミットを使用

s、squash =コミットを使用しますが、以前のコミットにマージします

たとえば、すべてのコミットを1つにマージする場合は、「ピック」が最初のコミットであり、将来のすべてのコミット（最初の下に配置）は「スカッシュ」に設定する必要があります。vimを使用している場合は、挿入モードで：xを使用して、エディターを保存して終了します。

次に、リベースを続行するには：

git rebase --continue

これとコミット履歴を書き換える他の方法の詳細については、この役立つ投稿を参照してください

Anomiesの回答は良いですが、私はこれに不安を感じたので、スクリーンショットをいくつか追加することにしました。

ステップ0：gitログ

あなたがいる場所を参照してくださいgit log。最も重要なのは、スカッシュしたくない最初のコミットのコミットハッシュを見つけることです。だから：

ステップ1：git rebase

git rebase -i [your hash]私の場合、実行します：

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

ステップ2：必要なものを選択する/つぶす

私の場合、最初にコミットしたすべてのものを押しつぶしたいと思います。順序は最初から最後までなので、とまったく逆git logです。私の場合、私は欲しい：

ステップ3：メッセージを調整する

1つのコミットのみを選択して残りを押しつぶした場合は、1つのコミットメッセージを調整できます。

それでおしまい。これ（:wq）を保存すると、完了です。でそれを見てくださいgit log。

手順1

1）コミットの短いハッシュを特定する

# git log --pretty=oneline --abbrev-commit
abcd1234 Update to Fix for issue B
cdababcd Fix issue B
deab3412 Fix issue A
....

ここでもgit log --oneline短いハッシュを取得するために使用できます。

2）最後の2つのコミットをスカッシュ（マージ）する場合

# git rebase -i deab3412 

3）これによりnano、マージ用のエディターが開きます。そして、それは以下のように見えます

....
pick cdababcd Fix issue B
pick abcd1234 Update to Fix for issue B
....

4）ワードの名前を変更pickするsquash前に存在しているがabcd1234。名前を変更すると、次のようになります。

....
pick cdababcd Fix issue B
squash abcd1234 Update to Fix for issue B
....

5）次に、nanoエディターを保存して閉じます。を押してctrl + o、を押しEnterて保存します。次に、を押しctrl + xてエディターを終了します。

6）次にnano、必要に応じて更新して、コメントを更新するためのエディターを再度開きます。

7）これで正常につぶれたので、ログを確認することで確認できます。

# git log --pretty=oneline --abbrev-commit
1122abcd Fix issue B
deab3412 Fix issue A
....

8）リポジトリにプッシュします。+ブランチ名の前に記号を追加することに注意してください。これは強制プッシュを意味します。

# git push origin +master

注：これはubuntuシェルでのgitの使用に基づいています。異なるos（WindowsまたはMac）を使用している場合、上記のコマンドはエディターを除いて同じです。別のエディターが表示される場合があります。

手順2

1. まず、コミットに必要なファイルを追加します

git add <files>

2. 次に、--fixupオプションを使用してコミットすると、OLDCOMMITこのコミットをマージ（スカッシュ）する必要があります。

git commit --fixup=OLDCOMMIT

これで、HEADの上に新しいコミットが作成されfixup1 <OLDCOMMIT_MSG>ます。

3. 次に、以下のコマンドを実行して、新しいコミットをにマージ（スカッシュ）しOLDCOMMITます。

git rebase --interactive --autosquash OLDCOMMIT^

ここでは、^以前はにコミットすることOLDCOMMIT。このrebaseコマンドは、エディター（vimまたはnano）で対話式ウィンドウを開き、保存するだけで終了するだけで十分です。これに渡されたオプションは、最新のコミットを古いコミットの隣に自動的に移動し、操作をfixup（スカッシュと同等）に変更するためです。その後、リベースが続行して終了します。

手順3

1. 最後のコミットに新しい変更を追加する必要がある場合は、--amendで使用できますgit-commit。

    # git log --pretty=oneline --abbrev-commit
    cdababcd Fix issue B
    deab3412 Fix issue A
    ....
    # git add <files> # New changes
    # git commit --amend
    # git log --pretty=oneline --abbrev-commit
    1d4ab2e1 Fix issue B
    deab3412 Fix issue A
    ....  

ここで--amendは、最後のコミットへの新しい変更をマージし、cdababcd新しいコミットIDを生成します1d4ab2e1

結論

• 最初の手順の利点は、複数のコミットを押しつぶして並べ替えることです。しかし、非常に古いコミットの修正をマージする必要がある場合、この手順は困難になります。
• したがって、2番目の手順は、コミットを非常に古いコミットに簡単にマージするのに役立ちます。
• そして、3番目の手順は、最後のコミットに対する新しい変更を破棄する場合に役立ちます。

最後の10個のコミットを1つのコミットにつぶすには：

git reset --soft HEAD~10 && git commit -m "squashed commit"

破棄されたコミットでリモートブランチも更新する場合：

git push -f

feature-branchゴールデンリポジトリ（golden_repo_name）から複製されたリモートブランチ（と呼ばれます）を使用している場合、コミットを1つにまとめる方法は次のとおりです。

1. ゴールデンリポジトリをチェックアウトする

   git checkout golden_repo_name
   

2. 次のように、そこから新しいブランチを作成します（ゴールデンレポ）。

   git checkout -b dev-branch
   

3. すでに持っているローカルブランチとスカッシュマージ

   git merge --squash feature-branch
   

4. 変更をコミットします（これは、開発ブランチで行われる唯一のコミットになります）

   git commit -m "My feature complete"
   

5. ブランチをローカルリポジトリにプッシュする

   git push origin dev-branch
   

本当に便利なこと：
スカッシュしたいコミットハッシュを見つけてくださいd43e15。

今使う

git reset d43e15
git commit -am 'new commit name'

これは非常に粗雑ですが、一種のクールな方法なので、リングに投げ込みます。

GIT_EDITOR='f() { if [ "$(basename $1)" = "git-rebase-todo" ]; then sed -i "2,\$s/pick/squash/" $1; else vim $1; fi }; f' git rebase -i foo~5 foo

翻訳：gitに新しい「エディタ」を提供します。編集するファイル名が git-rebase-todo（インタラクティブなリベースプロンプト）が最初の「pick」以外のすべてを「squash」に変更し、それ以外の場合はvimを生成するため、プロンプトが表示されたときに押しつぶされたコミットメッセージを編集するには、vimを取得します。（そして明らかに私はブランチfooの最後の5つのコミットを押しつぶしていましたが、好きなように変更できます。）

でも、おそらく私はMark Longairが提案したことをするでしょう。

すべてのコミットを1つのコミットに圧縮する場合（たとえば、プロジェクトを初めて一般公開する場合）、次のことを試してください。

git checkout --orphan <new-branch>
git commit

2020リベースなしのシンプルなソリューション：

git reset --soft HEAD~2

git commit -m "new commit message"

git push --force

2は、最後の2つのコミットが押しつぶされることを意味します。あなたはそれを任意の数に置き換えることができます

これを行う最も簡単な方法は、masterから新しいブランチを作成し、機能ブランチのスカッシュをマージすることです。

git checkout master
git checkout -b feature_branch_squashed
git merge --squash feature_branch

その後、すべての変更をコミットする準備が整います。

スカッシュしたいブランチに現在いる場合、常に機能する単純なワンライナー、マスターはそのブランチの元のブランチであり、最新のコミットには使用するコミットメッセージと作成者が含まれます。

git reset --soft $(git merge-base HEAD master) && git commit --reuse-message=HEAD@{1}

たとえば、最後の3つのコミットをブランチ（リモートリポジトリ）の単一のコミットに押しつぶしたい場合は、たとえば、https：//bitbucket.org

私がしたことは

1. git reset --soft Head〜3 &&
2. git commit
3. git push origin（branch_name）--force

⚠️警告：「最後のX回のコミット」はあいまいな場合があります。

  (MASTER)  
Fleetwood Mac            Fritz
      ║                    ║
  Add Danny  Lindsey     Stevie       
    Kirwan  Buckingham    Nicks                                              
      ║         ╚═══╦══════╝     
Add Christine       ║          
   Perfect      Buckingham
      ║           Nicks            
    LA1974══════════╝                                    
      ║                  
      ║                  
    Bill <══════ YOU ARE EDITING HERE
  Clinton        (CHECKED OUT, CURRENT WORKING DIRECTORY)              

https://github.com/fleetwood-mac/band-historyリポジトリのこの非常に簡略化された履歴では、Bill Clintonのコミットを元の（MASTER）Fleetwood Macコミット。

プルリクエストを開き、GitHubに次のように表示されます。

4つのコミット：

• ダニー・カーワンを追加
• クリスティンパーフェクトを追加
• LA1974
• ビル・クリントン

誰もリポジトリの完全な履歴を読もうとは思わないだろうと考えています。（実際にはリポジトリがあります。上のリンクをクリックしてください！）これらのコミットを破棄することにしました。だからあなたは行って実行しgit reset --soft HEAD~4 && git commitます。次にあなたgit push --force GitHubにそれを追加して、PRをクリーンアップします。

そして、何が起こりますか？FritzからBill Clintonへの単一コミットを作成しました。昨日、このプロジェクトのバッキンガムニックスバージョンで作業していたことを忘れたためです。そしてgit log、GitHubに表示されるものと一致しません。

🐻道徳の物語

1. あなたが取得したい正確なファイル検索をして、git checkoutそれら
2. 履歴に残したい正確な以前のコミットを見つけ、そして git reset --softすることを
3. fromから toにgit commit直接ワープするa を作成します

中間のコミットのコミットメッセージを気にしない場合は、

git reset --mixed <commit-hash-into-which-you-want-to-squash>
git commit -a --amend

GitLabを使用している場合は、以下に示すように、マージリクエストの[スカッシュ]オプションをクリックするだけです。コミットメッセージはマージリクエストのタイトルになります。

git rebase -i HEAD^^

ここで、^の数はXです。

（この場合、最後の2つのコミットを押しつぶします）

他の優れた答えに加えgit rebase -iて、コミット順序と常に混乱する方法を追加したいと思います-古いものから新しいものへ、またはその逆ですか？これが私のワークフローです：

1. git rebase -i HEAD~[N]ここで、Nは、最新のコミットから始めて、参加したいコミットの数です。つまりgit rebase -i HEAD~5、「最後の5つのコミットを新しいものにつぶす」ことを意味します。
2. エディターがポップアップし、マージしたいコミットのリストが表示されます。現在は逆の順序で表示されています。古いコミットが一番上にあります。最初/古いものを除いて、そこにあるすべてのコミットを「スカッシュ」または「s」としてマークしますます。これは開始点として使用されます。エディターを保存して閉じます。
3. エディターがポップアップし、新しいコミットのデフォルトメッセージが表示されます。必要に応じて変更し、保存して閉じます。スカッシュ完成！

ソースと追加の読み取り：＃1、＃2。

このようなワークフローに関連する質問に対する回答はどうですか？

1. マスターからの複数のマージと混合された多くのローカルコミット、
2. 最後に、リモートへのプッシュ、
3. PRとレビュー担当者によるマスターへのマージ。（はい、開発者がmerge --squashPR を実行する方が簡単ですが、チームはそれによりプロセスが遅くなると考えました。）

このようなワークフローはこのページでは見ていません。（それが私の目かもしれません。）私がrebase正しく理解している場合、複数のマージには複数の競合解決が必要になります。そんなこと考えたくない！

したがって、これは私たちにとってはうまくいくようです。

1. git pull master
2. git checkout -b new-branch
3. git checkout -b new-branch-temp
4. ローカルでたくさん編集してコミットし、定期的にマスターをマージする
5. git checkout new-branch
6. git merge --squash new-branch-temp //すべての変更をステージに入れます
7. git commit 'one message to rule them all'
8. git push
9. レビュー担当者がPRを行い、マスターにマージします。

より一般的な解決策は、「N」コミットを指定するのではなく、スカッシュしたいブランチ/コミットIDを指定することです。これは、特定のコミットまでのコミットをカウントするよりもエラーが発生しにくくなります。タグを直接指定するか、本当にカウントしたい場合はHEAD〜Nを指定できます。

私のワークフローでは、ブランチを開始し、そのブランチでの最初のコミットで目標を要約します（つまり、これは通常、機能の「最終」メッセージとしてパブリックリポジトリにプッシュするものです）。私はやりたいgit squash master最初のメッセージに戻った後、私がプッシュする準備ができています。

私はエイリアスを使用します：

squash = !EDITOR="\"_() { sed -n 's/^pick //p' \"\\$1\"; sed -i .tmp '2,\\$s/^pick/f/' \"\\$1\"; }; _\"" git rebase -i

これにより、破棄される前に履歴が破棄されます。元に戻す場合は、古いコミットIDをコンソールから取得することで、復元する機会があります。（Solarisユーザーは、GNU sed -iオプションを使用していることに注意してください。MacおよびLinuxユーザーは、これで問題ありません。）

問題は、「最後の」が何を意味するのか曖昧である可能性があります。

たとえばgit log --graph、以下を出力します（簡略化）：

* commit H0
|
* merge
|\
| * commit B0
| |
| * commit B1
| | 
* | commit H1
| |
* | commit H2
|/
|

次に、時間までの最後のコミットはH0、マージ、B0です。それらを押しつぶすには、コミットH1でマージされたブランチをリベースする必要があります。

問題は、H0にH1とH2が含まれていること（および一般に、マージ前と分岐後のコミット数が多い）ですが、B0には含まれていません。したがって、少なくともH0、マージ、H1、H2、B0からの変更を管理する必要があります。

リベースを使用することは可能ですが、別の方法で他の言及された回答とは異なります：

rebase -i HEAD~2

これにより、（他の回答で述べたように）選択オプションが表示されます。

pick B1
pick B0
pick H0

ピックの代わりにスカッシュをH0に配置します。

pick B1
pick B0
s H0

保存して終了した後、リベースはH1の後にコミットを順番に適用します。つまり、再び競合を解決するように求められます（最初にHEADがH1になり、適用されるとコミットが累積されます）。

リベースが終了したら、押しつぶされたH0とB0のメッセージを選択できます。

* commit squashed H0 and B0
|
* commit B1
| 
* commit H1
|
* commit H2
|

PS BOへのリセットを行うだけの場合：（たとえば、それを使用するreset --mixedことについては、https：//stackoverflow.com/a/18690845/2405850で詳しく説明しています）：

git reset --mixed hash_of_commit_B0
git add .
git commit -m 'some commit message'

次に、H0、H1、H2のB0変更につぶします（分岐後、マージ前の変更に対するコミットを完全に失います）。

1）git reset --soft HEAD〜n

n-コミットの数、スカッシュする必要がある

2）git commit -m "新しいコミットメッセージ"

3）git push origin branch_name --force