Git Tutorial: Using the Stash Command

Git stash is the safety net for uncommitted work: it temporarily saves local changes so developers can switch branches, inspect other code, or back out to a clean working tree—then restore those exact changes later. In practice, it prevents the “uncommitted changes” block that stops branch checkouts, while keeping work from being lost when priorities shift.

The walkthrough starts with a simple Python file whose arithmetic functions initially lack return values. After creating and checking out an `ad` branch, the author edits the `add` function (adding `return a + b`) and confirms the modifications with `git diff`. When the need arises to return to `master` and see the file as it was before the edits, the changes are stashed using `git stash save` along with a message like “worked on ADD function.” Immediately after stashing, `git diff` shows no pending differences and `git status` reports nothing to commit; the working directory is reverted to the pre-stash state.

Those saved edits remain available in the stash list. Running `git stash list` shows stash entries with numeric IDs (e.g., `stash@{0}`) and the custom message used at save time. To bring changes back, two commands appear: `git stash apply` and `git stash pop`. `git stash apply` restores the stashed changes but leaves the stash entry in place, meaning it can be reapplied later. `git stash pop` restores the top stash and removes it from the stash list in one step, leaving the stash history cleaner once the work has been recovered.

The tutorial then demonstrates stacking multiple stashes. After adding more functions (like `subtract`, `multiply`, `divide`, and later a `square` function), each set of edits is stashed with its own message. As new stashes are created, older ones shift down the list: the most recent change sits at the top (`stash@{0}`). Using `git stash pop` repeatedly pulls off the latest stash first, restoring changes in reverse chronological order.

For cleanup, `git stash drop` deletes a specific stash entry by ID, while `git stash clear` removes all stashes at once. The examples emphasize caution with `git stash clear`, since it permanently discards every saved stash and leaves no way to recover those uncommitted changes.

Finally, the practical branch-switching scenario ties everything together. On `master`, uncommitted edits prevent checking out the `ad` branch. Stashing the changes on `master` clears the working tree, enabling `git checkout ad`. After switching, `git stash pop` reintroduces the exact edits that were meant for the `ad` branch, after which the changes can be staged and committed normally.