Table of contents

• Understanding Git reset and HEAD
• Types of Git reset
• Step-by-step guide to using git reset HEAD
• Best practices for using git reset
• Frequently Asked Questions
• Summary of commands

The git reset command is a powerful tool used to undo changes in a Git repository. It can be used to unstage files, alter commits, and even delete changes altogether. This guide explains the different modes of using git reset, particularly focusing on resetting the HEAD pointer to a previous state in the project's history. For more specific scenarios, you might also want to check out our guides on how to remove files from staging and how to remove files from commits.

Understanding Git reset and HEAD

HEAD in Git refers to the current pointer to the branch you are working on, which is essentially the last commit on that branch. When you use the git reset command, you change where the HEAD and potentially the current branch pointer points to in the history of the project.

Types of Git reset

There are three main types of resets in Git: soft, mixed, and hard. Each affects the repository in different ways:

• Soft reset (--soft): This mode does not change the working directory or the staging area (index), but only the HEAD itself. Changes from reset commits move to the staging area.
• Mixed reset (default): This resets the index but not the working directory. It undoes commits and leaves the changes as uncommitted in your local working directory.
• Hard reset (--hard): This resets the index and working directory. Any changes to tracked files in the working directory since the commit to which HEAD is reset are discarded.

Step-by-step guide to using git reset HEAD

1. Check your current status

Always check your current status with git status before performing a reset to understand what changes are staged, committed, or uncommitted.

git status

2. Unstaging files using git reset HEAD

If you've staged files that you no longer wish to commit, you can unstage them with:

git reset HEAD

This command will unstage all currently staged files. For a more detailed guide on managing staged files, see our comprehensive guide on removing files from staging.

3. Performing a soft reset

To undo your last commit but keep the changes available in your staging area, use:

git reset --soft HEAD~1

This command moves the HEAD back by one commit and keeps the changes in the staging area.

4. Performing a mixed reset

To undo your last commit and move the changes to your working directory, you can run:

git reset HEAD~1

This will not touch your files; it only removes changes from the staging area.

5. Performing a hard reset

Use this command with caution. If you want to discard changes in your working directory and staging area, resetting the HEAD to the previous commit, use:

git reset --hard HEAD~1

For a more detailed explanation of hard resets and their implications, check out our dedicated guide on git reset --hard HEAD.

6. Resetting to a remote HEAD

If you need to reset your local branch to reflect a remote branch, first fetch the latest changes:

git fetch origin

Then reset:

git reset --hard origin/main

This will reset your local branch to match the main branch on the remote named origin.

Best practices for using git reset

• Be cautious with git reset --hard: This command can permanently delete your work if not used carefully.
• Regularly commit your work: More frequent commits mean you can afford to lose less work if you need to reset to an earlier point.
• Use soft and mixed resets for most tasks: These are safer and allow more flexibility.

Summary of commands

• git reset HEAD: Unstages files.
• git reset --soft HEAD~1: Moves HEAD back by one commit, changes are left staged.
• git reset HEAD~1: Moves HEAD back by one commit, changes are left in working directory.
• git reset --hard HEAD~1: Resets index and working directory to previous commit, discards all changes.
• git reset --hard origin/main: Resets local branch to match remote main branch.

For further reading see the official Git documentation.

Frequently Asked Questions

What's the difference between git reset and git revert?

git reset moves the HEAD pointer to a previous commit, effectively "erasing" commits from history, while git revert creates a new commit that undoes the changes from a previous commit, preserving the history. Use git reset for local changes you haven't pushed, and git revert for changes that have been shared with others.

Can I recover files after a hard reset?

If you haven't run garbage collection yet, you might be able to recover files using git reflog to find the commit hash before the reset, then use git reset --hard <commit-hash> to restore. However, this is not guaranteed, so always be careful with hard resets.

What happens to my staged changes when I use git reset HEAD?

When you use git reset HEAD (which is the same as git reset --mixed HEAD), your staged changes are moved back to the working directory as unstaged changes. Your files remain unchanged, but they're no longer staged for commit.

How do I reset to a specific commit?

You can reset to any commit by using its hash: git reset --hard <commit-hash>. You can find commit hashes using git log --oneline to see a compact history.

What's the difference between HEAD~1 and HEAD~2?

HEAD~1 refers to the commit before the current HEAD (one commit back), while HEAD~2 refers to two commits back. You can use HEAD~n to go back n commits from the current HEAD.

Can I reset to a remote branch without losing local changes?

Yes, you can use git stash to temporarily save your local changes, then reset to the remote branch, and finally use git stash pop to restore your changes:

git stash
git reset --hard origin/main
git stash pop

What does "HEAD detached" mean?

A "detached HEAD" occurs when HEAD points directly to a commit instead of a branch. This can happen when you checkout a specific commit. To avoid this, always checkout branches or create a new branch when checking out a specific commit.

How do I know which reset mode to use?

• Use --soft when you want to undo a commit but keep changes staged
• Use --mixed (default) when you want to undo a commit and unstage changes
• Use --hard when you want to completely discard all changes (use with caution)