DEV Community

Cover image for Switch Branches in Git Without Losing Your Work
Asad Bukhari
Asad Bukhari

Posted on

Switch Branches in Git Without Losing Your Work

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:

  1. Stash Your Changes:

Run the following command to stash your changes:

git stash
Enter fullscreen mode Exit fullscreen mode

This command saves your uncommitted changes and resets your working directory to match the last commit.

  1. Switch to the Other Branch:

Now that your working directory is clean, you can safely switch to the other branch:

git checkout <branch-name>
Enter fullscreen mode Exit fullscreen mode

Fix the urgent issue in the other branch as needed.

  1. Restore Your Stashed Changes:

Once you've addressed the issue, switch back to your original branch:

git checkout <original-branch>
Enter fullscreen mode Exit fullscreen mode

Then, restore your stashed changes with:

git stash pop
Enter fullscreen mode Exit fullscreen mode

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:

  1. Save your changes using git stash:
git stash
Enter fullscreen mode Exit fullscreen mode
  1. Switch to the master branch:
git checkout master
Enter fullscreen mode Exit fullscreen mode
  1. Fix the bug in master and commit your changes.

  2. Switch back to feature-branch:

git checkout feature-branch
Enter fullscreen mode Exit fullscreen mode
  1. Restore your stashed changes:
git stash pop
Enter fullscreen mode Exit fullscreen mode

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

  1. Create a Temporary Branch:

First, create and switch to a new temporary branch:

git checkout -b temp-branch
Enter fullscreen mode Exit fullscreen mode

This branch will hold your current work while you address the urgent issue.

  1. Commit Your Changes:

Commit your work in the temporary branch:

git add . && git commit -m "WIP: Save work before switching branches"
Enter fullscreen mode Exit fullscreen mode
  1. Switch to the Other Branch:

Now, switch to the branch where you need to make the urgent changes:

git checkout <branch-name>
Enter fullscreen mode Exit fullscreen mode

Continuing Your Work

Once you've resolved the issue:

  1. Switch Back:

Return to your original branch:

git checkout <original-branch>
Enter fullscreen mode Exit fullscreen mode
  1. 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
Enter fullscreen mode Exit fullscreen mode
  1. Delete the Temporary Branch (Optional):

Once you're done, you can delete the temporary branch:

git branch -d temp-branch
Enter fullscreen mode Exit fullscreen mode

Example Workflow

Let’s go through a quick example:

  1. Create and switch to a temporary branch:
git checkout -b temp-fix
Enter fullscreen mode Exit fullscreen mode
  1. Commit your current changes:
git add . && git commit -m "WIP: Temporary save before switching branches"
Enter fullscreen mode Exit fullscreen mode
  1. Switch to the required branch to fix the issue:
git checkout master
Enter fullscreen mode Exit fullscreen mode
  1. After fixing the issue, switch back to your original branch:
git checkout feature-branch
Enter fullscreen mode Exit fullscreen mode
  1. 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)

Collapse
 
doncallisto profile image
Samuele Lilli

There's at least another solution:

  • push your branch as it is (without the current work) to remote
  • commit all changes to current branch with a commith you're gonna reset after
  • do whatever job you need to on the other branch
  • switch back to previous branch
  • reset to HEAD~1
  • continue your work

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.

Collapse
 
asadbukhari profile image
Asad Bukhari

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!

Collapse
 
xuandinhgl profile image
Xuan Dinh

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>

Collapse
 
matthewpersico profile image
Matthew O. Persico

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.

Collapse
 
seanbracksdev profile image
SeanBracksDev

Good info!

However it’s good practice to use things like git switch or git branch rather than git checkout for everything now.

Collapse
 
aless10 profile image
Alessio Izzo

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

Collapse
 
khuongduybui profile image
Duy K. Bui

Check out GitButler.

Collapse
 
ahmad_ali_786 profile image
ahmad ali

Outstanding,
Very informative good job :)

Collapse
 
phpartisanmakeweeb profile image
phpArtisanMakeWeeb

It's me, or this post reeks of AI?

Collapse
 
odrinr profile image
odrinr

increíble... buen dato gracias por tomar parte de tu tiempo y compartir esta valiosa información.

Collapse
 
tomaszprasolek profile image
Tomasz Prasołek • Edited

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 stash command :)