Undoing a Git Commit Locally Without Losing Changes

When working with Git, it’s common to accidentally commit changes to the wrong branch. Fortunately, if you haven’t pushed these changes yet, there are straightforward methods for undoing a local commit while preserving your work in an uncommitted state. This tutorial will guide you through different approaches depending on your development environment and preferences.

Understanding `git reset`

The primary tool for addressing this situation is the git reset command. It allows you to revert changes made by previous commits. Depending on how you want to handle your working directory and staging area, you can use one of three options with git reset: soft, mixed, or hard.

Soft Reset: This option will undo the last commit but keep all changes in your staging area. It’s useful if you want to modify the commit message or add more changes before committing again.
```
git reset --soft HEAD~1
```
After executing this command, running git status will show that changes are staged for commit.
Mixed Reset: The mixed reset is the default mode for git reset. It undoes the last commit and retains changes in your working directory but unstages them. This option allows you to review or modify files before restaging them.
```
git reset --mixed HEAD~1
```
You’ll see that changes are present in your working directory but not staged for commit when you check git status.
Hard Reset: Use this if you want to discard all changes completely. It undoes the last commit and removes changes from both the staging area and working directory.
```
git reset --hard HEAD~1
```
After a hard reset, your working directory will be clean with no pending changes.

Using Visual Studio Code (VSCode)

For those who use VSCode as their IDE, there’s an even simpler way to undo the last commit:

Open the Source Control tab (Ctrl + Shift + G).
Click on the three dots next to the update icon.
Navigate to Commit > Undo Last Commit.

This action will revert your repository to its state before the last commit, keeping your changes intact in an uncommitted form.

Using IntelliJ IDEA or Other JetBrains IDEs

If you’re working with IntelliJ IDEA or a similar JetBrains product:

Open the Version Control window (Alt + 9 on Windows/Linux, Command + 9 on macOS) and navigate to the "Log" tab.
Right-click on the commit before your last one.
Choose "Reset current branch to here."
Select Soft as the reset mode.
Click the Reset button.

This sequence will uncommit your changes, leaving them in an uncommitted state while preserving all modifications.

Undoing a Commit When Pushed

If you find yourself needing to undo a commit after it has been pushed to a remote repository, you have two main options:

Create and Apply a Patch: This method involves creating a patch file from the last commit, reverting the commit, and then applying the changes back to your working tree.
```
git show HEAD > patch
git revert HEAD
git apply patch
```
Revert the Commit: A more straightforward approach is to use git revert, which will create a new commit that undoes all changes introduced by the previous commit, preserving history integrity without altering it.
```
git revert <commit-hash>
```

Best Practices

Always ensure you’re working on the correct branch before committing.
Use feature branches to isolate work and make merges more predictable.
Familiarize yourself with your chosen IDE’s Git functionalities for efficient workflows.

By mastering these techniques, you’ll be well-equipped to handle common mistakes in Git without losing valuable progress.