As developers, we often find ourselves in situations where we're deep into coding a feature when suddenly an urgent issue demands our immediate attention. To address it, we need to switch branches in Git. However, doing so can be risky if we haven't yet committed our current changes. We could lose our work or face merge conflicts.
In this post, I'll walk you through two effective strategies to switch branches in Git without losing your changes.
Understanding the Scenario
Imagine you're working on a new feature in your current branch. You've made several changes, but you haven’t committed them yet. Suddenly, you receive a request to fix a bug in another branch. The dilemma: How do you switch to the other branch to address the issue without losing the changes you’ve made?
Git provides a couple of powerful tools to handle this situation smoothly: git stash and creating a temporary branch.
Solution 1: Using git stash
What is git stash?
git stash is a command that allows you to temporarily save (or "stash") your changes without committing them. This is useful when you need to switch branches but want to come back to your current work later without losing anything.
How to Use git stash
Here’s how you can stash your changes:
- Stash Your Changes:
Run the following command to stash your changes:
git stash
This command saves your uncommitted changes and resets your working directory to match the last commit.
- Switch to the Other Branch:
Now that your working directory is clean, you can safely switch to the other branch:
git checkout <branch-name>
Fix the urgent issue in the other branch as needed.
- Restore Your Stashed Changes:
Once you've addressed the issue, switch back to your original branch:
git checkout <original-branch>
Then, restore your stashed changes with:
git stash pop
This command applies the stashed changes back to your working directory and removes the stash from your stash list.
Example Workflow
Let's say you're working on a feature in the feature-branch, and you receive a request to fix a bug in master:
- Save your changes using
git stash:
git stash
- Switch to the
masterbranch:
git checkout master
Fix the bug in
masterand commit your changes.Switch back to
feature-branch:
git checkout feature-branch
- Restore your stashed changes:
git stash pop
Now, you're back to where you left off, with all your changes intact.
Solution 2: Committing Your Changes to a Temporary Branch
Another approach is to commit your changes to a temporary branch. This is useful if you prefer committing your work before switching branches.
Creating a Temporary Branch
- Create a Temporary Branch:
First, create and switch to a new temporary branch:
git checkout -b temp-branch
This branch will hold your current work while you address the urgent issue.
- Commit Your Changes:
Commit your work in the temporary branch:
git add . && git commit -m "WIP: Save work before switching branches"
- Switch to the Other Branch:
Now, switch to the branch where you need to make the urgent changes:
git checkout <branch-name>
Continuing Your Work
Once you've resolved the issue:
- Switch Back:
Return to your original branch:
git checkout <original-branch>
- Merge the Temporary Branch (Optional):
If you want to bring your work from the temporary branch back into your original branch, you can merge it:
git merge temp-branch
- Delete the Temporary Branch (Optional):
Once you're done, you can delete the temporary branch:
git branch -d temp-branch
Example Workflow
Let’s go through a quick example:
- Create and switch to a temporary branch:
git checkout -b temp-fix
- Commit your current changes:
git add . && git commit -m "WIP: Temporary save before switching branches"
- Switch to the required branch to fix the issue:
git checkout master
- After fixing the issue, switch back to your original branch:
git checkout feature-branch
- Optionally merge the temporary branch if needed.
Conclusion
Switching branches in Git can be smooth and stress-free, even with uncommitted changes. By leveraging git stash or creating a temporary branch, you can seamlessly manage your workflow and keep your progress intact. These techniques help you address urgent issues swiftly without losing any of your ongoing work.
Try these methods in your next project and see how they can enhance your development process!
I hope this guide on using git stash was helpful. If you have any questions or need further details, don’t hesitate to leave a comment below.
Stay tuned for more methods in my upcoming blogs—there's much more to explore!
Connect with me:
GitHub: - Explore my open-source projects and repositories.
LinkedIn: - Connect with me professionally and stay updated on my career.
Feel free to reach out or follow me on these platforms for more insights, updates, and opportunities. Thanks for reading!
Top comments (11)
There's at least another solution:
This is my preferred way as, with stash, you can inadvertently pop back changes that would mess up all the things and with your second scenario you need to do a lot of extra ("useless") work.
You're absolutely right, there are many different methods people use to achieve the same result in Git. Thank you for sharing your preferred approach! It’s always great to learn about different techniques and perspectives. Appreciate your input!
Use git worktree, it's really useful when you need to switch to a different branch while working
Ex:
git worktree ../<dir_name> <branch name>Disk is cheap. Every time you start a branch to do some work, make a worktree. Switching contexts is now as simple as 'cd'. No work lost. You just need discipline to do that EVERY TIME you need to make a branch. I have written a framework around that workflow if you're interested: github.com/matthewpersico/personal > But be forewarned - it's involved.
Good info!
However it’s good practice to use things like
git switchorgit branchrather thangit checkoutfor everything now.Or just clone the repo again in another folder.
Btw I think that git worktree is THE solution to this, but I also use the git stash approach
Check out GitButler.
Outstanding,
Very informative good job :)
It's me, or this post reeks of AI?
increíble... buen dato gracias por tomar parte de tu tiempo y compartir esta valiosa información.
I always commit my code with the message "WIP" only or "WIP: what I am doing". I always work on some feature branch, so I don't have to create a temporary branch.
I have never in my life used
git stashcommand :)