Switching with uncommitted work

Changes you haven't committed come along when you switch branches, as you saw in Branches. But when the other branch has a different version of a file you changed, git refuses rather than overwrite your work:

$ git switch title
error: Your local changes to the following files would be overwritten by checkout:
	index.html
Please commit your changes or stash them before you switch branches.
Aborting

You could commit the change, but it isn't finished, and it may not even belong on this branch. The other way out is the stash: a place to set changes aside and bring them back later, on any branch.

Setting changes aside: git stash

$ git stash
Saved working directory and index state WIP on main: a4b8d97 Style the heading

git stash saves your changes, staged or not, in a new stash entry. Then it puts your files and the staging area back as the last commit has them. Nothing is in the way any more, so git switch title works. git stash is short for git stash push.

A stash entry is stored as a commit of its own, on no branch. Your branch doesn't move.

A new file that git doesn't track yet isn't stashed: it stays in your files, and comes along when you switch. git stash -u (for "untracked") stashes new files too. When new files are all you've changed, plain git stash says No local changes to save and does nothing.

Seeing what's stashed: git stash list

You can stash more than once. Each entry goes on top of the ones before, and git stash list lists them, newest first:

$ git stash list
stash@{0}: On main: Purple heading
stash@{1}: On main: New heading

stash@{0} is the newest entry, and stash@{1} the one before it. Give each entry a message with -m, as in git stash push -m "Purple heading", so you can tell them apart later. Without one, git writes WIP on the branch you were on, and the last commit.

Bringing changes back: pop and apply

git stash pop puts the newest entry's changes back in your files and drops the entry from the stash. git stash pop stash@{1} takes that entry instead.

You can pop on any branch, not just the one you stashed on. git merges the entry's changes into the files you have now, so changes with an unchanged line between them combine, as in a merge. When they can't combine, the pop stops with a conflict in that file, as a merge does. The entry stays in the stash: The stash entry is kept in case you need it again. Fix the file as you would after a merge, then drop the entry yourself.

Changes come back unstaged, even ones you had staged. Only a new file you'd staged comes back staged. And if you've changed a file since you stashed, and the entry changes it too, git refuses to pop, and keeps the entry.

git stash apply does what pop does, but keeps the entry. git stash drop throws an entry away: the newest, unless you name another. A dropped entry is gone from the list, so drop only what you're done with.

Command	What it does
git stash	Sets your changes aside in a new stash entry and puts your files back as the last commit has them. Short for git stash push.
git stash push -m "<message>"	The same, with a message to tell the entry apart.
git stash -u	Stashes new, untracked files too.
git stash list	Lists the entries, newest first: stash@{0}, stash@{1}, and so on.
git stash pop	Brings the newest entry's changes back and drops it. Name an entry to take that one.
git stash apply	Brings the changes back and keeps the entry.
git stash drop	Throws an entry away: the newest, unless you name another.