How to Check If a Git Repository Has Stashed Changes

Introduction

In this lab, you will learn how to check if a Git repository has stashed changes. We will explore the git stash list command to view existing stashes and use git status to verify the state of your working directory.

By following the steps, you will understand how to identify if you have temporarily saved changes using git stash and confirm that your working tree is clean when no stashes or uncommitted changes are present.

Skills Graph

Run git stash list to Check

In this step, we'll learn about git stash. Imagine you're working on a feature, but suddenly you need to switch to another task or fix a bug. Your current work isn't ready to be committed yet, but you don't want to lose it. This is where git stash comes in handy!

git stash temporarily saves your uncommitted changes (both staged and unstaged) and reverts your working directory to match the HEAD commit. It's like putting your current work aside in a safe place so you can work on something else, and then come back to it later.

Let's start by checking if you have any stashed changes. In your terminal, make sure you are in the ~/project/my-time-machine directory and run the following command:

cd ~/project/my-time-machine
git stash list

Since this is likely your first time using git stash in this repository, the output should be empty, or show no stashes found. This means there are no saved stashes in your current repository.

## If no stashes exist, you might see no output or a message like:
## No stashed changes found.

Understanding git stash list is the first step to managing your stashed changes. It allows you to see what stashes you have saved, which is crucial before applying or dropping them.

Verify with git status

In the previous step, we checked for existing stashes using git stash list. Now, let's use git status to see the current state of our working directory. This command is essential for understanding what changes are present and whether they are tracked by Git.

Make sure you are still in the ~/project/my-time-machine directory. Run the following command:

git status

Since we haven't made any changes since our last commit (in the previous lab), the output should indicate that your working tree is clean.

On branch master
nothing to commit, working tree clean

This output confirms that there are no uncommitted changes in your repository. The working directory matches the latest commit on the master branch. This is the state you would expect after creating a commit or after applying a stash and resolving any conflicts.

Understanding the output of git status is crucial for managing your Git workflow. It tells you which files have been modified, which are staged for the next commit, and which are untracked.

Test Stashless Repository

In the previous steps, we confirmed that our repository is clean and has no existing stashes. This is the ideal state to begin experimenting with git stash.

To demonstrate how git stash works, we first need to make some changes to our repository. Let's modify the message.txt file we created in the previous lab.

Make sure you are in the ~/project/my-time-machine directory. Open the message.txt file using the nano editor:

nano message.txt

Add a new line to the file, for example:

Hello, Future Me
This is a new line.

Save the file by pressing Ctrl + S and exit nano by pressing Ctrl + X.

Now, let's check the status of our repository again:

git status

You should see output indicating that message.txt has been modified:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

This output shows that we have made changes to message.txt, but these changes are not yet staged for a commit. This is the perfect scenario to use git stash. In the next step, we will use git stash to save these changes temporarily.

Summary

In this lab, we learned how to check for stashed changes in a Git repository. We started by using the git stash list command to see if any stashes were currently saved. An empty output or a message indicating no stashes confirms that no changes have been temporarily stored using git stash.

We then used git status to verify the state of our working directory. A clean working tree, as indicated by the git status output, confirms that there are no uncommitted changes present in the repository. These two commands are fundamental for understanding the current state of your Git repository and managing stashed changes.