When you try to merge your working copy with the remote repository, you may encounter the error: Git commit your changes or stash them before you can merge. This issue shouldn’t take much time to fix if you understand how merging works with uncommitted changes. This article will help you with it.
Merging Uncommitted Changes
Sometime you want to pull and merge changes from the upstream repository. However, your local copy may have some modifications since the last time you pulled from upstream.
For instance, let’s say the recent commit history of your upstream: A—B
And this is your local branch’s: A—(uncommitted changes)
A is where you last pulled the remote repository. Since then, there has been a commit (B) in it. You have also done some work locally but haven’t committed it.
If you merge the remote repository with your local work, you may stumble on errors like this:
git merge origin master Updating adbd09e..c96479d error: Your local changes to the following files would be overwritten by merge: ... Please commit your changes or stash them before you merge. Aborting
Git refuses to carry out the merging operation and throws this error when it detects there are local changes that merging would overwrite with incoming changes from the remote repository. This behavior is designed to prevent developers from accidentally erasing their work with ‘git merge’ as well as ‘git pull’.
Solutions to “Git commit your changes or stash them before you can merge”
Commit Your Changes
As the error message explicitly recommends, you can simply commit your local work before merging it with upstream:
git commit -m "your commit message" git merge origin master
Now the merging operation should run normally. It doesn’t mean there would be absolutely no errors. You may still need to deal with conflicts, which are normal in file versioning. But committing first makes sure there are no local changes that Git doesn’t know how to deal with.
What it does is basically to create a snapshot of your local repository, including recent changes you have made. These snapshots are safer than leaving your work uncommitted. Git saves them and won’t modify them unless you require so.
Stash Your Changes
If you aren’t sure about committing your recent changes, stashing them is a nice alternative. This operation temporarily shelves your uncommitted code modifications. You can come back and deal with them later after working on something else in your project. Stashing is a great solution when you need to switch contexts quickly but aren’t ready to commit your recent changes.
git stash git merge origin master
The first command will take and save your uncommitted work (both unstaged and staged) for later use. It reverts those files from your local copy.
After stashing recent changes, you are free to perform any Git operations, including pulling and merging. Keep in mind that the stash of your local work is saved to the local repository and doesn’t get transferred to the repository.
When you are done with merging (and resolving conflicts, if there are any), you can come back to and apply the stash to your local repository and keep working. This operation is called popping:
git stash pop
The command re-applies changes that have been previously stashed with ‘git stash’. It removes them from the stash and merges those changes to the working copy.
You can also apply your recent changes to the local repository and keep them in the stash at the same time. You may need this command when you need to apply those changes to other branches as well:
git stash apply
Remember that the stashing operation doesn’t save ignored files or new files you haven’t staged.
The error “Git commit your changes or stash them before you can merge” happens when you try to pull or merge a remote branch when your working copy has uncommitted changes. You should stash or commit them first, and the problem should go away.
Maybe you are interested:
- How to skip Git commit hooks
- Fatal: could not read username for ‘https://github.com’: terminal prompts disabled
- Git cannot be resolved to branch
My name is Robert. I have a degree in information technology and two years of expertise in software development. I’ve come to offer my understanding on programming languages. I hope you find my articles interesting.
Name of the university: HUST