22.10.2024

The Difference Between Git Reset, Git Checkout, and Git Revert

When working with Git, there are multiple commands that allow you to undo changes or navigate between different states of your repository. Three of the most commonly used commands for this purpose are git reset, git checkout, and git revert. While they can seem similar, each serves a distinct purpose and operates in a different way.

Here’s a detailed breakdown of the differences between git reset, git checkout, and git revert:

1. git reset

git reset is used to undo commits or unstage changes by moving the current branch’s HEAD pointer to a specified commit. It modifies the commit history and can affect your working directory, staging area, or both, depending on how it’s used.

Use Cases:

Undoing recent commits.
Moving the HEAD pointer back to an earlier commit.
Unstaging files from the staging area (while keeping the changes in the working directory).

Command Syntax:

git reset [–soft | –mixed | –hard] <commit>

Reset Modes:

–soft: Moves the HEAD pointer to the specified commit but keeps changes in both the staging area and working directory.
–mixed (default): Moves the HEAD pointer to the specified commit and resets the staging area, but keeps changes in the working directory.
–hard: Moves the HEAD pointer, resets the staging area, and discards all changes in the working directory.

Example:

git reset –hard HEAD~1 # Move HEAD back by one commit and discard all changes

Caution: git reset –hard is a destructive operation because it permanently removes changes from the working directory and commit history.

2. git checkout

git checkout is used to switch between branches or to check out a specific commit or file. It modifies the working directory to match the state of the branch, commit, or file that you check out, but it doesn’t modify the commit history unless you create a new commit after switching branches.

Use Cases:

Switching between branches.
Checking out a previous commit or specific files without altering the commit history.
Creating a new branch.

Command Syntax:

git checkout <branch_name> # Switch to a different branch git checkout <commit_hash> # Checkout a specific commit in a detached HEAD state git checkout — <file_name> # Restore a specific file to its last committed state

Example:

git checkout feature-branch # Switch to ‘feature-branch’ git checkout 123abc # Checkout commit with hash 123abc (detached HEAD state) git checkout — file.txt # Restore file.txt to its state in the last commit

Caution: If you check out a specific commit (not a branch), you enter a detached HEAD state, meaning changes won’t be associated with any branch unless you create a new branch from that point.

3. git revert

git revert is used to undo a commit by creating a new commit that reverses the changes introduced by the original commit. It preserves the commit history, making it a safe way to undo changes without rewriting the history.

Use Cases:

Safely undoing commits, especially in shared or remote branches.
Reverting specific commits while keeping the commit history intact.
Undoing changes in a collaborative environment.

Command Syntax:

git revert <commit>

Example:

git revert HEAD # Undo the most recent commit and create a new commit with the inverse changes git revert <commit> # Undo a specific commit by creating a new commit that reverses its changes

Important Note: git revert doesn’t delete any history or commits. Instead, it creates a new commit that undoes the changes from the specified commit. This makes git revert a non-destructive command that maintains a complete history of changes.

When to Use Each Command

Use git reset when:
- You need to undo a recent commit (or multiple commits) in your local repository.
- You want to unstage files or roll back changes in your working directory.
- You are working on a local branch and don’t need to preserve the commit history.
Use git checkout when:
- You need to switch between branches.
- You want to check out an earlier commit without modifying history (in a detached HEAD state).
- You need to restore a file or folder to its previous state without affecting the rest of your changes.
Use git revert when:
- You need to undo changes that have already been pushed to a shared or remote branch.
- You want to undo a commit but keep the history intact.
- You are collaborating with others and want to maintain a clear and accurate commit history.

Conclusion

Each of these Git commands—git reset, git checkout, and git revert—has its unique purpose and effect. Understanding when and how to use them correctly is essential for managing your project’s history and changes effectively. When working in a collaborative environment, it’s often safer to use git revert to undo changes, whereas git reset can be useful for cleaning up your local history. git checkout, on the other hand, is the go-to command for switching branches or navigating different commits without altering the repository’s history.