How Do I Squash Multiple Commits in Git?

Squashing multiple commits in Git is a common technique used to combine a series of commits into one. This process helps maintain a clean and concise Git history, especially when working on collaborative projects or submitting changes via pull requests. In this article, we’ll explore how to squash multiple commits in Git step by step, understand why it’s useful, and discuss best practices for leveraging this feature effectively.

What Does It Mean to Squash Commits?

Squashing commits is the process of merging several commits into a single commit. This is typically done during a rebase operation. The purpose of squashing commits is to simplify your Git history, especially when working with branches that include many minor or incremental commits.

For example, instead of having a Git log like this:


commit 1a2b3c4d
Author: John Doe
Message: Fix typo in README

commit 2b3c4d5e
Author: John Doe
Message: Update CSS styling

commit 3c4d5e6f
Author: John Doe
Message: Refactor code for better readability

You can squash them into a single commit:


commit 4d5e6f7g
Author: John Doe
Message: Improve documentation, styling, and code readability

Why Squash Commits?

Squashing commits is especially beneficial for the following reasons:

  • Clean Git History: A clean commit history makes it easier for developers to understand the evolution of the codebase.
  • Better Code Reviews: By combining minor changes, reviewers can focus on the overall improvement rather than reviewing trivial commits.
  • Reduced Noise: Minor changes, such as fixing typos or debugging code, can clutter the Git log. Squashing consolidates these into meaningful commits.

How to Squash Commits in Git

Squashing commits is typically done during an interactive rebase. Below, we’ll break it down into simple steps.

Step 1: Identify the Commits to Squash

First, use the git log command to view the commit history and identify the range of commits you want to squash:


git log --oneline

This command will display a concise history of commits. For example:


3c4d5e6 Refactor code for better readability
2b3c4d5 Update CSS styling
1a2b3c4 Fix typo in README

Let’s say you want to squash these three commits into a single commit. Note the most recent commit hash you want to squash and the one before it.

Step 2: Start an Interactive Rebase

Run the following command to start an interactive rebase:


git rebase -i HEAD~3

The HEAD~3 indicates that you want to interactively rebase the last three commits. Adjust the number based on how many commits you want to squash.

Step 3: Mark Commits for Squashing

After running the rebase command, Git will open a text editor (such as Vim or Nano) showing a list of commits:


pick 1a2b3c4 Fix typo in README
pick 2b3c4d5 Update CSS styling
pick 3c4d5e6 Refactor code for better readability

To squash commits, change pick to squash (or simply s) for all but the first commit:


pick 1a2b3c4 Fix typo in README
squash 2b3c4d5 Update CSS styling
squash 3c4d5e6 Refactor code for better readability

Save and close the editor.

Step 4: Edit the Commit Message

Next, Git will prompt you to edit the commit message for the squashed commit. The editor will display something like this:


# This is a combination of 3 commits.
# The first commit's message is:
Fix typo in README

# The following commit messages will also be included:
Update CSS styling
Refactor code for better readability

Edit the message to summarize the combined changes:


Improve documentation, styling, and code readability

Save and close the editor. Git will now squash the commits into one.

Step 5: Confirm the Rebase

To verify the rebase was successful, run:


git log --oneline

You should now see a single commit representing the squashed changes.

Best Practices for Squashing Commits

  • Squash Before Pushing: Always squash your commits before pushing them to the remote repository. Squashing after pushing can cause conflicts and disrupt team workflows.
  • Communicate with Your Team: If you’re working on a shared branch, notify your team before performing a rebase and squash.
  • Use Descriptive Commit Messages: When squashing commits, write a clear and concise commit message summarizing the changes.

Frequently Asked Questions

1. Can I squash commits that have already been pushed?

Yes, but it’s not recommended unless absolutely necessary. Squashing commits that have been pushed will rewrite the commit history, which can cause issues for other developers working on the branch. If you must squash pushed commits, use git push --force (--force-with-lease is safer).

2. What is the difference between squashing and merging commits?

Squashing commits combines multiple commits into one during a rebase, while merging creates a new commit that combines the changes from two branches. Squashing is used to clean up history, whereas merging is used to integrate branches.

3. Can I squash commits without rebasing?

Technically, squashing is part of the rebase process. However, some tools (like Git GUIs) provide interfaces to squash commits without manually performing a rebase.

Conclusion

Squashing multiple commits in Git is an essential skill for maintaining a clean and readable commit history. By following the steps outlined in this guide, you can effectively combine minor changes into meaningful commits, making it easier for your team to review and understand your contributions. Remember to follow best practices and communicate with your team when working on shared branches.

Now that you understand how to squash commits, you can confidently clean up your Git history and make your repositories more organized!