git restore to discard working changes - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output after discarding changes with git restore?

You have modified a file named app.js in your working directory. You run the command git restore app.js. What happens to the file app.js?

A The changes in <code>app.js</code> are discarded and the file is restored to the last committed state.

B The changes in <code>app.js</code> are staged for commit but not discarded.

C The file <code>app.js</code> is deleted from the working directory.

D The changes in <code>app.js</code> are committed automatically.

💡 Hint

Think about what 'restore' means in the context of undoing changes.

The git restore command resets the file in the working directory to match the last commit, discarding any changes made since then.

💻 Command Output

intermediate

What error occurs if you run git restore on a file not tracked by git?

You create a new file notes.txt but never added it to git. You run git restore notes.txt. What is the result?

A The file <code>notes.txt</code> is deleted from the working directory.

B The file <code>notes.txt</code> is restored to an empty file.

C The file <code>notes.txt</code> is added to the staging area.

D Error: pathspec 'notes.txt' did not match any files

💡 Hint

Consider what git knows about the file before restoring.

Git cannot restore a file it does not track. It will show an error that the pathspec did not match any files.

🔀 Workflow

advanced

Which command sequence discards all local changes in the working directory?

You want to discard all local changes in your working directory for all tracked files. Which command sequence achieves this?

A git clean -fd

B git reset --hard

C git restore .

D git checkout master

💡 Hint

Focus on discarding changes only, not deleting untracked files.

git restore . discards all changes in tracked files in the current directory and below. git reset --hard also resets the index and HEAD, which is more than just discarding working changes.

❓ Troubleshoot

advanced

Why does git restore not discard changes in a file?

You run git restore config.yaml but your changes in config.yaml remain. What is the most likely reason?

A You need to run <code>git commit</code> first.

B The file <code>config.yaml</code> is untracked by git.

C The file is locked by another process.

D You forgot to add the <code>--staged</code> option.

💡 Hint

Think about whether git knows about the file.

If the file is untracked, git restore cannot discard changes because git does not manage it yet.

✅ Best Practice

expert

What is the safest way to discard changes in a file without affecting the staging area?

You have changes in index.html both staged and unstaged. You want to discard only the unstaged changes, keeping the staged ones intact. Which command should you use?

A git restore index.html

B git restore --staged index.html

C git reset index.html

D git checkout -- index.html

💡 Hint

Consider the difference between restoring staged and unstaged changes.

git restore index.html discards only unstaged changes in the working directory, leaving staged changes untouched. Using --staged affects the staging area instead.

Practice

1. What does the command git restore <filename> do in a Git repository?

easy

A. It permanently deletes the specified file from the repository history.

B. It discards changes in the specified file and restores it to the last committed state.

C. It stages the specified file for the next commit.

D. It creates a new branch with the name of the specified file.

Solution

1. Step 1: Understand the purpose of git restore

   The git restore command is used to undo changes in the working directory before committing.

2. Step 2: Effect on the specified file

   Using git restore <filename> resets the file to its last committed state, discarding any edits made since then.

3. Final Answer:

   It discards changes in the specified file and restores it to the last committed state. -> Option B

4. Quick Check:

   Undo changes = git restore [OK]

Hint: Use git restore to undo file edits before commit [OK]

Common Mistakes:

• Confusing restore with delete or branch creation
• Thinking it stages files instead of discarding changes
• Assuming it affects commit history

2. Which of the following is the correct syntax to discard changes in a file named app.js using git restore?

easy

A. git restore app.js

B. git restore --discard app.js

C. git restore -d app.js

D. git restore --reset app.js

Solution

1. Step 1: Recall the basic syntax of git restore

   The command to discard changes in a file is simply git restore <filename> without extra flags.

2. Step 2: Check the options given

   Options B, C, and D use incorrect or non-existent flags. Only git restore app.js uses the correct syntax.

3. Final Answer:

   git restore app.js -> Option A

4. Quick Check:

   Correct syntax = git restore filename [OK]

Hint: Use git restore filename without extra flags to discard changes [OK]

Common Mistakes:

• Adding unnecessary flags like --discard or --reset
• Using shorthand flags that don't exist
• Confusing git restore with git reset

3. Given the following sequence of commands in a Git repository:

echo 'Hello' > file.txt
git add file.txt
echo 'World' >> file.txt
git restore file.txt
cat file.txt

What will be the output of cat file.txt?

medium

A. Hello

B. World

C. Hello\nWorld

D. file.txt: No such file or directory

Solution

1. Step 1: Understand the commands before restore

   First, 'Hello' is written to file.txt and staged. Then 'World' is appended but not staged.

2. Step 2: Effect of git restore on file.txt

   The git restore file.txt discards the unstaged changes, reverting file.txt to the last staged (or committed) state which contains only 'Hello'.

3. Step 3: Output of cat file.txt

   After restore, file.txt contains only 'Hello'. So, cat file.txt outputs 'Hello'.

4. Final Answer:

   Hello -> Option A

5. Quick Check:

   Restore discards unstaged changes = Hello [OK]

Hint: Restore resets file to last staged or committed state [OK]

Common Mistakes:

• Assuming restore keeps appended changes
• Confusing staged and unstaged changes
• Expecting both lines to appear after restore

4. You ran git restore file.txt but your changes were not discarded. What is the most likely reason?

medium

A. Git restore only works on new files, not modified ones.

B. The file was already committed and has no changes to discard.

C. You used the wrong filename in the command.

D. You have staged the changes, so restore does not affect them by default.

Solution

1. Step 1: Understand git restore behavior with staged changes

   By default, git restore <file> only discards unstaged changes. Staged changes remain unless you add the --staged flag.

2. Step 2: Analyze why changes were not discarded

   If changes were staged, running restore without --staged won't discard them, so the file appears unchanged.

3. Final Answer:

   You have staged the changes, so restore does not affect them by default. -> Option D

4. Quick Check:

   Restore ignores staged changes unless --staged used [OK]

Hint: Use --staged to discard staged changes with git restore [OK]

Common Mistakes:

• Assuming restore discards staged changes without flags
• Thinking restore works only on new files
• Not checking if filename is correct

5. You have modified three files: index.html, style.css, and script.js. You staged index.html and style.css but want to discard only the unstaged changes in style.css and script.js. Which command will achieve this?

hard

A. git restore --discard style.css script.js

B. git restore --staged style.css script.js

C. git restore style.css script.js

D. git restore --staged style.css && git restore script.js

Solution

1. Step 1: Identify which changes to discard

   You want to discard unstaged changes in style.css and script.js. Staged changes should remain.

2. Step 2: Choose the correct git restore command

   git restore --discard style.css script.js uses invalid --discard flag. Options B and C use --staged which would discard staged changes, which is not desired. git restore style.css script.js discards unstaged changes only.

3. Final Answer:

   git restore style.css script.js -> Option C

4. Quick Check:

   Restore without --staged discards unstaged changes [OK]

Hint: Restore files without --staged to discard only unstaged changes [OK]

Common Mistakes:

• Using --staged and discarding staged changes accidentally
• Running separate commands unnecessarily
• Using invalid flags like --discard