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

bashCopy
# 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

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

Key Differences Between git reset and git revert

Command	Purpose	Data Loss	Safe for Shared Branches
git reset	Moves HEAD and modifies history	Potential	No
git revert	Creates a new commit to reverse changes	No	Yes

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:

bashCopy
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

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

Add Another Line and Make a Second Commit

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

Add a Third Line and Make a Third Commit

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

Check the history:

bashCopy
git log --oneline

Example output:

bashCopy
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:

   bashCopy
   git reset --soft HEAD~1
   

2. Observe the Result:

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

   bashCopy
   git status
   

3. Check the Contents:

   bashCopy
   cat file.txt
   

   Output:

   bashCopy
   Line 1
   Line 2
   Line 3
   

4. Recommit or Modify:

   bashCopy
   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:

   bashCopy
   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.

   bashCopy
   git status
   

3. Check the File:

   bashCopy
   cat file.txt
   

   Output:

   bashCopy
   Line 1
   Line 2
   Line 3
   

4. Stage and Commit Again if Needed:

   bashCopy
   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:

   bashCopy
   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:

   bashCopy
   cat file.txt
   

   Output:

   bashCopy
   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:

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

Reset to Commit efgh456 (Second Commit)

bashCopy
git reset --mixed efgh456

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

Check the file:

bashCopy
cat file.txt

---

Step 5: View History and Status Throughout

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

bashCopy
git log --oneline
git status
cat file.txt

---

Key Takeaways

Command	Result
git reset --soft HEAD~1	Undo commit, keep changes staged
git reset --mixed HEAD~1 (default)	Undo commit, keep changes unstaged
git reset --hard HEAD~1	Undo commit, discard changes in working directory and staging

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.