Clean vs dirty working directory in Git - Quick Revision & Key Differences

Recall & Review

beginner

What does a clean working directory mean in Git?

A clean working directory means there are no changes to tracked files. All files are committed, and Git shows no differences when you run git status.

beginner

What is a dirty working directory in Git?

A dirty working directory means there are changes in files that are not yet committed. These can be modified, added, or deleted files that Git tracks as different from the last commit.

beginner

Which command shows if your working directory is clean or dirty?

The command git status shows the current state of the working directory, listing any changes that make it dirty or confirming it is clean.

intermediate

How can you make a dirty working directory clean?

You can make it clean by committing changes with git commit, discarding changes with git restore <file>, or staging changes with git add followed by commit.

intermediate

Why is it important to have a clean working directory before switching branches?

Having a clean working directory prevents conflicts and lost changes when switching branches. Git requires this to safely move between different snapshots of your project.

What does git status show when your working directory is clean?

A Untracked files listed

B Modified files listed

C No changes to commit, working tree clean

D Merge conflicts present

When the working directory is clean, git status shows 'No changes to commit, working tree clean'.

Which of these indicates a dirty working directory?

A Git repository is empty

B No files listed by <code>git status</code>

C Git prompt shows branch name only

D Files listed under 'Changes not staged for commit'

Files listed under 'Changes not staged for commit' means the working directory has uncommitted changes, so it is dirty.

How do you stage changes to prepare for a clean working directory?

A git add &lt;file&gt;

B git clone &lt;repo&gt;

C git branch &lt;name&gt;

D git merge &lt;branch&gt;

git add <file> stages changes, which is the first step to making the working directory clean after committing.

What happens if you try to switch branches with a dirty working directory?

A Git may prevent switching to avoid losing changes

B Git switches branches without any warning

C Git automatically commits changes

D Git deletes untracked files

Git usually prevents switching branches if there are uncommitted changes to avoid conflicts or data loss.

Which command discards changes in a dirty working directory?

A git commit

B git restore &lt;file&gt;

C git push

D git merge

git restore <file> discards changes in the working directory, reverting the file to the last committed state.

Explain what a clean and a dirty working directory mean in Git and how you can check their status.

Think about what Git shows when you run 'git status'.

Describe the steps you would take to move from a dirty working directory to a clean one.

Consider both saving changes and undoing changes.

Practice

1. What does it mean when your Git working directory is described as clean?

easy

A. There are conflicts from a merge.

B. There are untracked files present.

C. There are changes staged but not committed.

D. There are no changes to commit; all files are saved in Git.

Solution

1. Step 1: Understand the meaning of a clean working directory

   A clean working directory means no changes are pending to be committed or staged.

2. Step 2: Compare with other states

   Untracked files, staged changes, or conflicts mean the directory is dirty, not clean.

3. Final Answer:

   There are no changes to commit; all files are saved in Git. -> Option D

4. Quick Check:

   Clean working directory = no uncommitted changes [OK]

Hint: Clean means no changes to commit or stage [OK]

Common Mistakes:

• Confusing staged changes with clean state
• Thinking untracked files mean clean
• Assuming conflicts mean clean

2. Which Git command correctly shows the current state of your working directory?

easy

A. git push origin main

B. git commit -m "status"

C. git status

D. git checkout

Solution

1. Step 1: Identify the command to check working directory state

   The command git status shows staged, unstaged, and untracked changes.

2. Step 2: Eliminate other commands

   git commit saves changes, git push uploads commits, git checkout switches branches or files.

3. Final Answer:

   git status -> Option C

4. Quick Check:

   Check working directory state = git status [OK]

Hint: Use 'git status' to see working directory changes [OK]

Common Mistakes:

• Using git commit to check status
• Confusing git push with status check
• Using git checkout incorrectly

3. You run git status and see:

Changes not staged for commit:
  modified:   app.js

What is the state of your working directory?

medium

A. Dirty working directory with unstaged changes

B. Dirty working directory with staged changes

C. Clean working directory

D. Detached HEAD state

Solution

1. Step 1: Interpret the git status output

   The message "Changes not staged for commit" means files are modified but not added to staging.

2. Step 2: Determine working directory state

   Unstaged changes mean the directory is dirty, not clean, and changes are not staged.

3. Final Answer:

   Dirty working directory with unstaged changes -> Option A

4. Quick Check:

   Unstaged changes = dirty directory [OK]

Hint: Unstaged changes mean dirty directory [OK]

Common Mistakes:

• Confusing unstaged with staged changes
• Assuming clean when files are modified
• Mixing detached HEAD with working directory state

4. You see this output after running git status:

On branch main
Changes to be committed:
  modified:   index.html

But you want to check if your working directory is clean. What should you do?

medium

A. Run git reset HEAD index.html to unstage changes

B. Run git commit to save changes

C. Run git add index.html again

D. Run git checkout index.html to stage changes

Solution

1. Step 1: Understand the meaning of staged changes

   "Changes to be committed" means files are staged but not committed, so directory is dirty.

2. Step 2: Unstage changes to check clean state

   Running git reset HEAD index.html unstages the file, showing if working directory has unstaged changes.

3. Final Answer:

   Run git reset HEAD index.html to unstage changes -> Option A

4. Quick Check:

   Unstage changes to check clean state [OK]

Hint: Unstage files with git reset HEAD to check clean state [OK]

Common Mistakes:

• Adding files again instead of unstaging
• Committing without checking unstaged changes
• Using git checkout to stage files (wrong)

5. You modified two files: app.py and README.md. You staged app.py but not README.md. What will git status show?

hard

A. No changes to commit, working directory clean

B. Changes to be committed: app.py; Changes not staged for commit: README.md

C. Changes not staged for commit: app.py and README.md

D. Untracked files: app.py and README.md

Solution

1. Step 1: Identify staged and unstaged files

   app.py is staged, so it appears under "Changes to be committed".

2. Step 2: Identify unstaged files

   README.md is modified but not staged, so it appears under "Changes not staged for commit".

3. Final Answer:

   Changes to be committed: app.py; Changes not staged for commit: README.md -> Option B

4. Quick Check:

   Staged vs unstaged files shown separately [OK]

Hint: Staged files show as 'to be committed', unstaged as 'not staged' [OK]

Common Mistakes:

• Assuming all modified files are staged
• Confusing untracked with modified files
• Thinking working directory is clean with staged changes