Move existing, uncommitted work to a new branch in Git

Question

I started some work on a new feature and after coding for a bit, I decided this feature should be on its own branch.

How do I move the existing uncommitted changes to a new branch and reset my current one?

I want to reset my current branch while preserving existing work on the new feature.

Answer 1

Use the following:

git checkout -b <new-branch>

This will leave your current branch as is, create and checkout a new branch and keep all your changes. You can then make a commit with:

git add <files>

and commit to your new branch with:

git commit -m "<Brief description of this commit>"

The changes in the working directory and changes staged in index do not belong to any branch yet. This changes where those changes would end in.

You don't reset your original branch, it stays as it is. The last commit on <old-branch> will still be the same. Therefore you checkout -b and then commit.

Answer 2

Alternatively:

1. Save current changes to a temp stash:

   $ git stash

2. Create a new branch based on this stash, and switch to the new branch:

   $ git stash branch <new-branch> stash@{0}

Tip: use tab key to reduce typing the stash name.

Answer 3

If you have been making commits on your main branch while you coded, but you now want to move those commits to a different branch:

1. Copy your current history onto a new branch, bringing along any uncommitted changes too:

   git checkout -b <new-feature-branch>
   

2. Now force the original "messy" branch to roll back: (without switching to it)

   git branch -f <previous-branch> <earlier-commit-id>
   

   For example:

   git branch -f master origin/master
   

   or if you had made 4 commits:

   git branch -f master HEAD~4
   

Warning: It appears that git branch -f master origin/master will reset the tracking information for that branch. So if you have configured your master branch to push to somewhere other than origin/master then that configuration will be lost.

An alternative is to use this reset technique. But those instructions will discard any uncommitted changes you have. If you want to keep those, stash them first and unstash them at the end.

Answer 4

The common scenario is the following: I forgot to create the new branch for the new feature, and was doing all the work in the old feature branch. I have commited all the "old" work to the master branch, and I want my new branch to grow from the "master". I have not made a single commit of my new work. Here is the branch structure: "master"->"Old_feature"

git stash 
git checkout master
git checkout -b "New_branch"
git stash apply

Answer 5

If you commit it, you could also cherry-pick the single commit ID. I do this often when I start work in master, and then want to create a local branch before I push up to my origin/.

git cherry-pick <commitID>

There is alot you can do with cherry-pick, as described here, but this could be a use-case for you.

Answer 6

I used @Robin answer & listing all that I did,

git status                               <-- review/list uncommitted changes
git stash                                <-- stash uncommitted changes
git stash branch <new-branch> stash@{1}  <-- create a branch from stash
git add .                                <-- add local changes
git status                               <-- review the status; ready to commit
git commit -m "local changes ..."        <-- commit the changes
git branch --list                        <-- see list of branches incl the one created above
git status                               <-- nothing to commit, working tree (new-branch) is clean
git checkout <old-branch>                <-- switch back

! If the repo has more than one stash, see which one to apply to the new-branch:

git stash list  
  stash@{0}: WIP on ...  
  stash@{1}: WIP on ...

and inspect the individual stash by,

git stash show stash@{1}

Or inspect all stashes at once:

git stash list -p

Answer 7

There is actually a really easy way to do this with GitHub Desktop now that I don't believe was a feature before.

All you need to do is switch to the new branch in GitHub Desktop, and it will prompt you to leave your changes on the current branch (which will be stashed), or to bring your changes with you to the new branch. Just choose the second option, to bring the changes to the new branch. You can then commit as usual.

Answer 8

This may be helpful for all using tools for GIT

Command

Switch branch - it will move your changes to new-branch. Then you can commit changes.

 $ git checkout -b <new-branch>

TortoiseGIT

Right-click on your repository and then use TortoiseGit->Switch/Checkout

SourceTree

Use the "Checkout" button to switch branch. You will see the "checkout" button at the top after clicking on a branch. Changes from the current branch will be applied automatically. Then you can commit them.