git restore to discard working changes - Deep Dive

Overview - git restore to discard working changes

What is it?

git restore is a command used to undo changes in your working directory. It lets you discard edits you made to files, returning them to the last saved state in your repository. This helps you fix mistakes or start fresh without affecting your commit history. It is a safer and clearer way to undo changes compared to older commands.

Why it matters

Without git restore, undoing changes could be confusing or risky, leading to lost work or messy histories. This command solves the problem of safely discarding unwanted edits, making it easier to manage your code and avoid errors. It helps developers feel confident experimenting, knowing they can quickly revert mistakes.

Where it fits

Before learning git restore, you should understand basic git concepts like the working directory, staging area, and commits. After mastering git restore, you can explore more advanced undo commands like git reset and git checkout for different undo scenarios.

Mental Model

Core Idea

git restore resets files in your working folder back to their last committed state, discarding any unsaved changes.

Think of it like...

Imagine you are writing on a whiteboard and make some marks you don't like. Using git restore is like wiping the whiteboard clean to how it looked before you started writing.

Working Directory
  ┌───────────────┐
  │ Modified File │
  └──────┬────────┘
         │ git restore
         ▼
  ┌───────────────┐
  │ Clean File    │
  └───────────────┘

This shows how git restore changes a modified file back to clean.

Build-Up - 7 Steps

1

Foundation

Understanding Working Directory Changes

Concept: Learn what it means when files are changed but not saved in git.

When you edit a file in your project, git sees it as 'modified' but not yet saved in a commit. These changes live only in your working directory until you save them by committing.

Result

You know that changes exist but are not permanent until committed.

Understanding the working directory is key to knowing what git restore will affect.

2

Foundation

Difference Between Staged and Unstaged Changes

Concept: Distinguish between changes you have marked for commit (staged) and those you haven't (unstaged).

Git tracks changes in two places: the staging area (ready to commit) and the working directory (not yet staged). git restore primarily affects unstaged changes unless told otherwise.

Result

You can identify where your changes live and how git restore targets them.

Knowing this helps prevent accidentally discarding changes you meant to keep.

3

Intermediate

Using git restore to Discard Unstaged Changes

🤔Before reading on: do you think git restore affects staged changes by default? Commit to yes or no.

Concept: Learn the basic command to discard changes in files that are not staged.

Run 'git restore ' to reset the file to the last committed version, removing any edits you made but did not stage.

Result

The file returns to its clean, committed state, and your edits are lost.

Understanding this command lets you safely undo mistakes before staging.

4

Intermediate

Discarding Changes in Multiple Files

🤔Before reading on: can git restore discard changes in multiple files at once? Commit to yes or no.

Concept: You can restore multiple files or all files in one command.

Use 'git restore .' to discard all unstaged changes in the current directory and its subdirectories. Or list multiple files separated by spaces.

Result

All specified files revert to their last committed state.

This saves time when you want to discard many changes quickly.

5

Intermediate

Restoring Staged Changes with git restore --staged

🤔Before reading on: does git restore remove changes from the staging area? Commit to yes or no.

Concept: Learn how to unstage files using git restore.

Run 'git restore --staged ' to remove a file from the staging area but keep your edits in the working directory.

Result

The file is no longer staged for commit but your changes remain.

Knowing this helps you fix staging mistakes without losing work.

6

Advanced

Combining --staged and Working Directory Restore

🤔Before reading on: can git restore remove changes both from staging and working directory in one command? Commit to yes or no.

Concept: You can discard changes both from staging and working directory together.

Run 'git restore --staged ' to unstage, then 'git restore ' to discard working changes. Or combine with scripting for batch operations.

Result

The file returns to the last commit state with no staged or unstaged changes.

Understanding this combination prevents partial undo mistakes.

7

Expert

Why git restore Replaced git checkout for This Use

🤔Before reading on: do you think git checkout and git restore do the same thing? Commit to yes or no.

Concept: Learn the design reasons behind introducing git restore as a clearer alternative.

Git checkout was overloaded with many functions, causing confusion and mistakes. git restore was created to separate concerns: restoring files only affects working directory and staging, making commands safer and clearer.

Result

You understand why modern git uses git restore for discarding changes and git checkout for switching branches.

Knowing this history helps avoid confusion and use git commands correctly.

Under the Hood

git restore works by replacing the content of files in your working directory with the content from the last commit or the index (staging area). It reads the saved snapshot and overwrites your current files, effectively discarding any unsaved edits. When using --staged, it updates the staging area by removing the file from the index, but leaves the working directory untouched unless combined with other options.

Why designed this way?

Git originally used git checkout for many tasks, which was confusing and error-prone. To improve clarity and safety, git restore was introduced to focus solely on restoring file content, separating concerns and reducing accidental data loss. This design makes commands more intuitive and easier to learn.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Last Commit   │──────▶│ Staging Area  │──────▶│ Working Dir   │
└───────────────┘       └───────────────┘       └───────────────┘
       ▲                      ▲                      ▲
       │                      │                      │
       │                      │                      │
       │                      │                      │
       └──── git restore <file> ─────────────────────┘

This shows git restore replacing files in working directory from commit or staging.

Myth Busters - 4 Common Misconceptions

Quick: Does git restore delete committed files? Commit yes or no.

Common Belief: git restore can delete files from the repository permanently.

Reality: git restore only affects your working directory and staging area; it never deletes committed files from the repository history.

Why it matters: Believing this can cause unnecessary fear or misuse, preventing safe undoing of local changes.

Quick: Does git restore affect staged changes by default? Commit yes or no.

Common Belief: git restore discards both staged and unstaged changes by default.

Reality: By default, git restore only discards unstaged changes; staged changes remain unless --staged is used.

Why it matters: Misunderstanding this can lead to unexpected loss or retention of changes.

Quick: Is git restore the same as git reset? Commit yes or no.

Common Belief: git restore and git reset do the same thing and can be used interchangeably.

Reality: git restore focuses on working directory and staging area file content, while git reset changes commit history and staging area pointers.

Why it matters: Confusing these commands can cause serious repository state problems or data loss.

Quick: Can git restore recover deleted files from commits? Commit yes or no.

Common Belief: git restore can recover files deleted in previous commits automatically.

Reality: git restore only restores files to the last commit state in your current branch; it cannot recover files deleted in past commits without extra commands.

Why it matters: Expecting automatic recovery can lead to lost work if proper recovery steps are not taken.

Expert Zone

1

git restore does not update the HEAD or commit history, so it is safe for local undo without affecting others.

2

Using git restore with --source allows restoring files from any commit, not just the latest, enabling selective rollback.

3

git restore can be combined with pathspecs to target specific files or directories precisely, avoiding broad unintended changes.

When NOT to use

Do not use git restore when you want to undo commits or change branch pointers; use git reset or git revert instead. Also, avoid git restore if you want to keep changes but move them between branches; use git stash or git cherry-pick.

Production Patterns

In professional workflows, git restore is used to quickly discard local experimental changes before switching tasks. It is often combined with git status to review changes first. Teams use it to maintain clean working directories and avoid committing unfinished work.

Connections

Undo in Text Editors

Similar pattern of reverting changes to a previous state

Understanding git restore is like knowing how undo works in editors helps grasp the idea of discarding unwanted edits safely.

Version Control History

Builds on the concept of commits as snapshots

Knowing how commits save snapshots clarifies why git restore can reset files to those saved states.

Database Transactions

Shares the idea of rollback to a known good state

Seeing git restore as a rollback operation helps understand its role in maintaining consistent project states.

Common Pitfalls

#1 Accidentally discarding staged changes when intending only to discard unstaged edits.

Wrong approach:

git restore --staged

Correct approach:

git restore # discard unstaged changes
# and separately
git restore --staged # unstage changes

Root cause:

Confusing the --staged option and its effect on staging area versus working directory.

#2 Using git restore to undo committed changes expecting to remove commits.

Wrong approach:

git restore --source HEAD~1

Correct approach:

git revert # to undo commits safely
# or
git reset --hard # to move HEAD and discard commits

Root cause:

Misunderstanding git restore's scope limited to working directory and staging.

#3 Running git restore . without checking which files will be discarded.

Wrong approach:

git restore .

Correct approach:

git status # check changes first
git restore . # then discard if sure

Root cause:

Not reviewing changes before discarding leads to unintended data loss.

Key Takeaways

git restore safely discards changes in your working directory by resetting files to their last committed state.

It separates concerns clearly from older commands, focusing only on file content restoration, making undo operations safer and easier.

You can discard unstaged changes, unstage files, or both, using different options with git restore.

Understanding the difference between working directory, staging area, and commits is essential to using git restore correctly.

Always review your changes before discarding to avoid losing important work unintentionally.