XQA
Back to Git & Dev Tools
2026-02-056 min read

Reset Demystified (Git & Dev Tools)

Learn Reset Demystified (Git & Dev Tools) step by step with clear examples and exercises.

Title: Reset Demystified (Git & Dev Tools)

Why This Matters

In software development, mistakes are an inevitable part of the process. However, understanding how to effectively use Git's reset command can help you manage and recover from these errors efficiently. By learning the ins and outs of reset, you will be better prepared for real-world scenarios where your codebase needs a fresh start or a specific commit needs to be undone. This skill is essential for developers, as it enhances productivity and reduces stress during project development.

Prerequisites

Before diving into the reset command, you should have a basic understanding of Git and its core concepts such as commits, branches, and merges. Familiarity with the command line is also beneficial but not mandatory, as there are graphical user interfaces available for those who prefer them. To get started, it's recommended to set up a local Git repository and make some initial commits to practice the reset commands.

Setting Up a Local Repository

  1. Install Git on your system if you haven't already: https://git-scm.com/downloads
  2. Create a new directory for your project and navigate into it using the command line:
mkdir my_project && cd my_project
  1. Initialize a new Git repository:
git init
  1. Create a sample file to track changes:
echo "Hello, world!" > README.md
  1. Add the file to the staging area and commit it:
git add .
git commit -m "Initial commit"

Core Concept

The reset command in Git allows you to move your current branch to a different commit or even create a new one based on an existing commit. This command can be used to:

  1. Move the HEAD pointer to another commit (soft, mixed, or hard reset)
  2. Replace the working directory and index with files from a specific commit
  3. Remove commits entirely (hard reset)

Soft Reset

A soft reset changes the HEAD pointer but keeps all changed files in the working directory and the index. It does not modify any commit objects, so you can continue to work on your project without losing any changes. To perform a soft reset, use the following command:

git reset --soft <commit>

Replace `` with the hash or name of the desired commit.

Mixed Reset

A mixed reset moves the HEAD pointer and discards changes in the working directory and index, but it preserves the commit objects. This means that you will lose any local modifications made since the last commit. To perform a mixed reset, use:

git reset <commit>

Hard Reset

A hard reset moves the HEAD pointer, discards changes in the working directory and index, and deletes the commit object. This command is irreversible and should be used with caution. To perform a hard reset, use:

git reset --hard <commit>

Worked Example

Let's consider a simple scenario where you accidentally committed an unwanted change (e.g., a typo or a debugging print statement). You can use the reset command to revert back to the previous commit and clean up your codebase.

  1. First, find the hash of the last commit before the unwanted change by running:
git log --oneline
  1. Copy the hash of the desired commit.
  1. Perform a soft reset to move the HEAD pointer and keep your changes in the working directory:
git reset --soft <commit-hash>
  1. Now, you can continue working on your project without the unwanted change.

Common Mistakes

  1. Not specifying a commit: If you omit the `` argument in the command, Git will move the HEAD pointer to the most recent commit in the current branch, potentially overwriting any uncommitted changes.
  1. Performing a hard reset without caution: Hard resets are irreversible and can cause data loss if used improperly. Be sure to understand the implications of this command before using it.
  1. Not updating the working directory after a mixed or hard reset: After performing a mixed or hard reset, you will need to use git checkout to get the latest version of the files from the new HEAD commit.
  1. ### Unintentionally discarding uncommitted changes
  • If you perform a hard reset on your current branch and have uncommitted changes in the working directory, those changes will be lost. To avoid this, consider creating a backup or stash before performing a hard reset.
  1. ### Moving the HEAD pointer to an unreachable commit
  • If you try to move the HEAD pointer to a commit that is not part of your current branch's history, Git will refuse to perform the reset. In this case, you may need to create a new branch or cherry-pick the desired commit onto your current branch.

Practice Questions

  1. You have made several changes in your working directory but haven't committed them yet. Suddenly, you realize that these changes are not what you intended. How can you revert back to the last committed state using Git?
  • Perform a hard reset (git reset --hard) and then use git checkout to get the latest version of the files from the new HEAD commit.
  1. You have accidentally pushed a commit containing sensitive information to a public repository. What command can you use to remove this commit from your project history?
  • To remove the commit from your local repository, you can perform an interactive rebase (git rebase -i ^) and delete the offending commit using the pick or squash commands. After removing the commit locally, push the changes to the remote repository with the --force flag (git push origin --force).
  1. You are working on a feature branch and want to discard all changes made since a specific commit. How can you do this using the reset command?
  • Perform a hard reset (git reset --hard) on your current branch, specifying the hash of the desired commit as the argument. This will move the HEAD pointer to the specified commit and discard all changes made since that point.

FAQ

  1. What is the difference between soft, mixed, and hard resets in Git? Soft resets keep your changes in the working directory, while mixed resets discard local modifications but preserve the commit objects. Hard resets move the HEAD pointer, discard changes in the working directory and index, and delete the commit object.
  1. Can I undo a hard reset in Git? No, hard resets are irreversible once committed. To recover from a hard reset, you will need to use additional commands like git reflog or git fsck.
  1. Is it safe to perform a hard reset on the master branch? Hard resets should be used with caution, especially on branches that other developers may be working on. It is generally recommended to create a new branch for experimental changes and merge them into the main branch once tested and verified.

### How can I recover lost or discarded files after a hard reset?

  • If you accidentally lose or discard files during a hard reset, you may be able to recover them using Git's reflog. The git reflog command shows the history of your repository, including commits that have been deleted. You can find the hash of the commit where the lost file was last committed and use it to restore the file (git checkout -- ).

### What happens if I perform a hard reset on a remote branch?

  • Performing a hard reset on a remote branch will affect other developers who are working on that branch or have it merged into their local repositories. To avoid conflicts, it's best to coordinate with your team before performing hard resets on shared branches. If necessary, use the --force flag when pushing changes to the remote repository (git push origin --force) to overwrite other developers' work. However, be aware that this can lead to data loss and should be used with caution.
Reset Demystified (Git & Dev Tools) | Git & Dev Tools | XQA Learn