git list stashes

Oranges Authors

3 min read

·

05-03-2025

5

0

Share

Git stashes are a powerful feature often overlooked by developers. They provide a way to temporarily shelve changes you've made to your working directory and index without committing them. This is incredibly useful when you need to switch branches, fix a bug quickly, or handle urgent tasks without losing your current progress. This article will explore Git stashes using examples and explanations inspired by insights from the community (though not directly quoting specific users from Crosswordfiend, the spirit of collaborative problem-solving found there guides this explanation).

What is a Git Stash?

Imagine you're working on a new feature, but a critical bug arises in the master branch. Committing your half-finished feature would clutter your history. This is where stashes come in. A stash is essentially a snapshot of your current working directory and index. You can apply this snapshot later, resuming exactly where you left off.

Key Git Stash Commands and Their Uses:

• git stash push [-u] [-a] [-k] [-m <message>] [<file>...]: This is the core command for creating a stash.

  • -u: Includes untracked files in the stash.
  • -a: Includes ignored files in the stash. Use with caution!
  • -k: Keeps the working directory and index unchanged after stashing (useful for only saving changes to the index).
  • -m <message>: Adds a descriptive message to your stash, crucial for later identification. Example: git stash push -m "Half-finished UI changes for feature X"
  • <file>...: Specifies particular files to stash. Useful for stashing only parts of your changes. Example: git stash push -m "Stashing only stylesheet changes" styles.css

• git stash list: This command lists all your existing stashes. Each stash is given a unique ID, making it easy to reference specific stashes. The output looks similar to this:

stash@{0}: WIP on feature-x: added login functionality
stash@{1}: WIP on master: fixed critical bug

• git stash pop [<stash>]: This command applies the most recent stash (or the specified stash using its ID) to your working directory. It also removes the stash from the stash list. If there are conflicts (e.g., the same files were modified since the stash was created), the pop operation will stop, requiring you to resolve the conflicts manually.

• git stash apply [<stash>]: Similar to pop, but it keeps the stash in the list after application. This is useful when you want to reuse the stash later or experiment with different ways to integrate the changes.

• git stash drop [<stash>]: This command deletes the specified stash. Use caution, as this operation is irreversible.

• git stash clear: Removes all stashes.

Practical Example: Switching Branches with a Stash

Let's say you're working on feature-branch and need to quickly fix a bug on master.

1. Stash your changes: git stash push -u -m "Work in progress on feature-branch" (The -u flag is crucial to include untracked files).
2. Switch branches: git checkout master
3. Fix the bug and commit: ... (your bug fixing steps)... git commit -m "Fixed critical bug on master"
4. Switch back: git checkout feature-branch
5. Apply your stash: git stash pop

Your changes from feature-branch are now back in your working directory.

Advanced Stash Techniques

• Using git stash branch <branch_name> <stash>: This creates a new branch from a specific stash. This is ideal for creating a new branch from a saved work-in-progress without the need to manually apply the stash and commit.

Conclusion:

Git stashes are a valuable tool for managing your workflow efficiently. Mastering these commands will significantly improve your Git proficiency and allow you to handle interruptions and context switching seamlessly. Remember to use descriptive messages with your stashes to avoid confusion later. By strategically using stashes, you can maintain a clean and organized Git history while maximizing your productivity.