Tired of messy commit histories cluttering up your Git repositories and pull requests? Luckily, Git has the ability to “squash commits,” which merges multiple small commits into one. This helps keep your code history clean and organized, and it’s easy to do with a few commands.
Why Squash Commits?
One of the golden rules of good Git etiquette is to commit often with good messages explaining what the commits do. However, this can quickly become an issue if too many commits are pushed. After all, nobody wants to review a pull request with 40 different commits, all ready to be merged into master—it’s simply too much clutter.
So, before you push to a remote repository like GitHub, it’s good practice to squash those commits, which will merge them all into one big commit. All of the commit messages from those commits will be added to the “squash commit” so that they are still all visible when you go to push them to GitHub or submit your pull request.
It’s also not always necessary to squash every commit, since sometimes it is nice to split things up if you’re working on multiple different files or parts of the repository. However, if you’re just making multiple changes to a single file over time, you should probably squash those commits.
It’s important to note that you cannot squash commits already pushed to GitHub without force pushing, which is a destructive operation. Squashing commits overwrites Git history, which is fine if you’re doing it only on your local machine. If you’re doing it on GitHub, it requires a force push, which means all of your team members must re-clone the repository to avoid conflicts.
To avoid these issues, it’s best to squash commits before pushing to the remote repository. Since this is usually when you’d want to do this anyway, it’s usually not an issue.
Squashing Git Commits With git merge
There are a couple different ways to squash commits, since there isn’t an official “git squash” command. One of the easiest is using git merge with the --squash flag. This technique will merge the last N commits together into one.
First, you’ll want to make sure your repository is entirely clean, with no active changes. You can check git status to verify that you have no local changes that would be thrown away by the reset.
Next, you’ll want to reset the branch to the position it was at before any of the commits you’d like to squash together. For example, to squash the last three commits, you would use HEAD~3, which is technically the fourth commit in the history, but will remove all three squashable commits from your history.
git reset --hard HEAD~3
You can also use a commit SHA-1 hash to reference a commit directly. Next, we run git merge --squash, with the merge target being HEAD@{1}, which is the position of the HEAD before the last command.
git merge --squash 'HEAD@{1}'
Git has already staged all the changes with the proper commit message at this point, but it needs to be committed:
git commit
Once that’s done, you’re free to push all the commits to your upstream source repository.
More Control Over Squashing With Interactive Rebase
If you don’t want to squash everything into one bit commit, you can perform an interactive rebase to select only the commits that you want to squash. Rebasing can be complicated, but it’s easy to do with the right steps.
First, start the interactive rebase by targeting the commit before the last squashable commit:
git rebase -i HEAD~3
This will open up a text editor, where you will want to change “pick” to “squash” for each commit that you would like to merge.
Git will then open another editor, allowing you to create a new commit message for the combined commit. Save this, and the rebase should finish.
Rebasing this way will merge all the squashed commits into the next commit above them. In this case, the second and third commits were merged into the first one.
Squashing Git Commits With a Git GUI
Like most actions in Git, squashing commits with an interface is much easier than remembering and typing commands every time. In fact, in GitKraken, you can simply just Control-Click the commits you want to squash, and right click to press “Squash 2 commits”:
You can read our guide on GUI Git clients to learn more.
RELATED: Should You Use a GUI Git Client?
