git reset is a powerful command in Git that allows developers to undo changes in their repositories. It is often used to move the current HEAD to a specified state, enabling developers to modify or discard certain commits. Understanding git reset is crucial for effective version control and maintaining clean project histories.

The Basics of git reset

git reset primarily operates on three distinct areas within a Git repository:

• HEAD: The pointer to the current branch and its latest commit.
• Index (Staging Area): The area that holds changes scheduled for the next commit.
• Working Directory: The files in your local directory that you are actively working on.

The behavior of git reset depends on the mode used:

Modes of git reset

1. git reset --soft <commit>

• HEAD is moved to <commit>.
• Index remains unchanged.
• Working Directory remains unchanged.
• Use Case: Undoing the last commit while keeping changes staged for editing.

2. git reset --mixed <commit> (default)

• HEAD is moved to <commit>.
• Index is updated to match <commit>.
• Working Directory remains unchanged.
• Use Case: Undoing a commit and unstaging the changes for further modification.

3. git reset --hard <commit>

• HEAD is moved to <commit>.
• Index is updated to match <commit>.
• Working Directory is updated to match <commit>.
• Use Case: Discarding commits and changes permanently (Use with caution).

Examples

Resetting the Last Commit

# Keep changes staged
git reset --soft HEAD~1

# Unstage changes but keep modifications
git reset --mixed HEAD~1

# Discard changes permanently
git reset --hard HEAD~1

Resetting to a Specific Commit

git reset --soft <commit-hash>
git reset --mixed <commit-hash>
git reset --hard <commit-hash>

Key Differences Between git reset and git revert

Precautions

• Use --hard carefully as it can permanently delete changes.
• Avoid git reset on public/shared branches to prevent rewriting history that others rely on.

We’ll walk through creating a simple file, making some commits, and performing various git reset operations to see the actual effect.

Step 1: Set Up a Test Repository

Open your terminal and follow these steps:

mkdir git-reset-demo
cd git-reset-demo
git init

This creates an empty Git repository.

Step 2: Create a File and Make Commits

Create file.txt and Make Initial Commit

echo "Line 1" > file.txt
git add file.txt
git commit -m "Add Line 1"

Add Another Line and Make a Second Commit

echo "Line 2" >> file.txt
git add file.txt
git commit -m "Add Line 2"

Add a Third Line and Make a Third Commit

echo "Line 3" >> file.txt
git add file.txt
git commit -m "Add Line 3"

Check the history:

git log --oneline

Example output:

abcd123 Add Line 3
efgh456 Add Line 2
ijkl789 Add Line 1

(Your commit hashes will differ.)

Step 3: Perform git reset Operations

We’ll demonstrate each type of reset using the third commit (HEAD) as the starting point.

A. git reset --soft: Undo Commit, Keep Changes Staged

Scenario: You want to undo the last commit but keep your changes ready for a new commit.

1. Run:

   git reset --soft HEAD~1
   

2. Observe the Result:

   • The last commit is removed, but changes from Line 3 are still staged.

   git status
   

3. Check the Contents:

   cat file.txt
   

   Output:

   Line 1
   Line 2
   Line 3
   

4. Recommit or Modify:

   git commit -m "Revised Line 3"
   

B. git reset --mixed: Undo Commit, Keep Changes in Working Directory

Scenario: You want to undo the last commit and unstage the changes, but keep the file edits.

1. Run:

   git reset --mixed HEAD~1
   

2. Observe the Result:

   • The last commit is removed.
   • Changes from Line 3 are in the working directory but NOT staged.

   git status
   

3. Check the File:

   cat file.txt
   

   Output:

   Line 1
   Line 2
   Line 3
   

4. Stage and Commit Again if Needed:

   git add file.txt
   git commit -m "Recommit Line 3"
   

C. git reset --hard: Undo Commit and Discard Changes (DANGEROUS)

Scenario: You want to undo the last commit and completely remove any changes from your working directory.

1. Run:

   git reset --hard HEAD~1
   

2. Observe the Result:

   • The last commit is removed.
   • Changes from Line 3 are discarded from both:
     • Working directory
     • Staging area

3. Check the File:

   cat file.txt
   

   Output:

   Line 1
   Line 2
   

   Line 3 is GONE!

⚠️ Be Careful: This cannot be undone easily.

Step 4: Reset to a Specific Commit (Optional)

Assuming your commit history looks like this:

abcd123 Add Line 3
efgh456 Add Line 2
ijkl789 Add Line 1

Reset to Commit efgh456 (Second Commit)

git reset --mixed efgh456

• Moves HEAD to Add Line 2 commit.
• Line 3 is in the working directory but unstaged.

Check the file:

cat file.txt

Step 5: View History and Status Throughout

Use these at any step to understand what’s happening:

git log --oneline
git status
cat file.txt

Key Takeaways

Conclusion

git reset is a versatile tool for managing commits, the index, and the working directory. Mastering its different modes enables developers to effectively control their project history and recover from mistakes. Understanding when to use git reset versus git revert is vital to ensuring smooth collaboration and preventing data loss in version-controlled projects.