How Do I Squash Commits in Git?

In Git, squashing commits refers to the process of combining multiple commit entries into a single commit. This can be useful when you want to clean up your commit history before merging a feature branch into the main branch. Squashing commits can make the history more readable, reduce clutter, and improve the overall quality of your project’s commit history. In this article, we will walk you through how to squash commits in Git and explain the various methods you can use to do so.

What is Git Squash?

Before diving into how to squash commits in Git, let’s take a moment to understand what “squashing” means. Squashing in Git allows you to combine multiple commits into one, essentially “squashing” them together. When you squash commits, you are consolidating the changes of several commits into a single, coherent commit with a clean commit message. This is especially helpful when you have a series of minor or intermediate commits that are part of a larger change but are not necessary to retain individually in the project’s history.

Why Should You Squash Commits?

Squashing commits offers several advantages for project maintenance and collaboration. Some of the key reasons to squash commits include:

Cleaner Git History: Squashing commits eliminates unnecessary commit entries, making the Git history easier to understand.
Improved Collaboration: A concise commit history helps other contributors understand the project’s evolution and reduces the noise in version control.
Reduced Merge Conflicts: Squashing commits can help resolve merge conflicts by reducing the number of changes involved.
Better Code Review: By squashing commits, reviewers can focus on the overall change rather than reviewing small, incremental changes.

How to Squash Commits in Git

Now that we understand why squashing commits is beneficial, let’s explore the different methods you can use to squash commits in Git.

Method 1: Using Git Rebase Interactive

The most common method for squashing commits in Git is using git rebase in interactive mode. This allows you to pick, squash, and edit commits in a controlled way. Here’s how you can squash commits using this method:

Open your terminal or command prompt and navigate to your Git repository.
Run the following command to start an interactive rebase for the last N commits (where N is the number of commits you want to include in the squash):

git rebase -i HEAD~N

In the editor that opens, you’ll see a list of commits. The commits will be listed from the oldest to the most recent.
For each commit you want to squash, change the word pick to squash or simply s next to the commit.
Once you’ve marked all the commits you want to squash, save and close the editor.
Git will now attempt to squash the commits. If there are no conflicts, you will be prompted to edit the commit message. You can choose to keep the commit messages from the squashed commits or create a new message that summarizes the changes.
After confirming the commit message, the rebase will complete, and your commits will be squashed into one.

Method 2: Using Git Merge –squash

Another way to squash commits is by using the git merge --squash command. This method is useful if you’re merging a feature branch into the main branch and want to squash all commits from the feature branch into a single commit.

First, checkout the branch that you want to merge into (e.g., main or master):

git checkout main

Then, run the following command to merge the feature branch with the --squash option:

git merge --squash feature-branch-name

This will stage the changes from all the commits in the feature branch as a single commit.
Now, commit the changes with a descriptive message:

git commit -m "Squashed commit message for feature branch"

Method 3: Using Git Reset and Commit

Another option for squashing commits involves using git reset followed by a new commit. This method is useful if you want to modify the commits and then commit the changes again as a single commit.

Start by running the following command to reset your branch to a specific commit (usually the commit just before the ones you want to squash):

git reset --soft HEAD~N

Now, all the changes from the squashed commits will be staged. You can commit them again as a single commit:

git commit -m "New commit message after squashing"

Best Practices for Squashing Commits

While squashing commits is a powerful tool, it should be done with care. Here are some best practices for squashing commits in Git:

Squash Before Merging: It’s a good practice to squash commits before merging feature branches into the main branch. This ensures that the commit history remains clean.
Don’t Squash Public Commits: Avoid squashing commits that have already been shared with others, as this can lead to confusing histories and conflicts for your collaborators.
Use Descriptive Commit Messages: When you squash commits, take the time to write a meaningful commit message that accurately summarizes the changes made in the squashed commits.
Review Changes Before Squashing: Before squashing, ensure that all the changes are correct and necessary. Squashing commits doesn’t undo changes, so it’s essential to be sure that everything is in order.

Conclusion

Squashing commits in Git is a useful technique to keep your project’s commit history clean, concise, and easy to follow. Whether you’re working on a feature branch or cleaning up a messy commit history, Git offers several ways to squash commits, including using interactive rebase, merge with --squash, or resetting and committing changes. By following the methods outlined in this guide and adhering to best practices, you can improve the readability of your Git history and contribute to a more organized and efficient development process.