How to discard unstaged changes in Git

Discarding unstaged changes in Git allows you to revert modifications made to files that have not yet been staged (added to the index) for committing. This is useful when you want to reset files back to their last committed state or undo recent changes that you do not wish to keep. Git provides several methods to discard unstaged changes, depending on whether you want to discard changes selectively per file or discard all changes across the entire repository.

Using `git checkout` Command

1. Discarding changes in a specific file

If you want to discard changes in a specific file and revert it back to the state it was in at the last commit, you can use the git checkout command followed by the file path.
```
git checkout -- path/to/file
```
This command replaces the current contents of path/to/file with the contents of the file as it exists in the index (staging area), effectively discarding any unstaged changes made to the file since the last commit.

2. Caution with git checkout

Be cautious when using git checkout -- path/to/file as it permanently removes any unstaged changes in the specified file. Ensure that you do not need these changes before proceeding.

Using `git restore` Command (Git 2.23 and later)

1. Discarding changes in a specific file

The git restore command provides a more intuitive and safer way to discard changes in specific files. To discard unstaged changes in a file and revert it back to the index (staging area) state:
```
git restore path/to/file
```
This command resets the contents of path/to/file to match the version in the index, effectively discarding any unstaged changes.

2. Discarding all unstaged changes

To discard all unstaged changes across the entire repository, you can use:
```
git restore .
```
The dot (.) notation refers to the current directory and recursively applies the restore operation to all files within the repository, reverting them to the index state.

Using `git reset` Command

1. Resetting specific files

The git reset command with the --hard option can be used to reset files to the state of the last commit. However, it should be used with caution as it can discard all changes, including staged changes.
```
git reset --hard HEAD path/to/file
```
This command resets path/to/file to match the state it was in at the last commit (HEAD), discarding any changes made to the file since then.

2. Resetting all files

To reset all files in the repository to the last committed state, you can use:
```
git reset --hard HEAD
```
This command resets all files to match the state they were in at the last commit (HEAD), effectively discarding all unstaged changes and resetting the index and working directory to match the commit.

Using `git clean` Command (for untracked files)

1. Removing untracked files

If you have untracked files (files that are not staged for commit), you can remove them using the git clean command with the -f (force) and -d (directory) options.
```
git clean -f -d
```
This command removes all untracked files and directories from the working directory, effectively discarding any new files or directories that Git does not track.

2. Caution with git clean

Exercise caution when using git clean -f -d as it permanently deletes untracked files and directories. Ensure that you do not need these files before proceeding.

Using `git stash` Command

1. Stashing changes

If you want to temporarily save your changes before discarding them, you can use git stash to stash the changes.
```
git stash
```
This command saves your modifications into a stack of stashes, effectively removing them from the working directory and index.

2. Applying or discarding stashed changes

You can later apply the stashed changes back to your working directory with git stash apply, or discard them entirely with git stash drop.
```
git stash apply  # Apply stashed changes
git stash drop   # Discard stashed changes
```

Considerations and Best Practices

1. Backup and Safety

Always make sure to have backups or copies of important changes before discarding them, especially when using commands like git reset --hard or git clean -f -d that can permanently delete changes.

2. Selective Discard vs. Full Discard

Choose the appropriate method based on whether you want to discard changes selectively in specific files or discard all changes across the entire repository.

3. Review Changes

Before discarding changes, review the modifications carefully to ensure that you are discarding the correct changes and not inadvertently removing important updates.

Summary

Discarding unstaged changes in Git is a fundamental operation for managing modifications in your codebase. By using commands such as git checkout, git restore, git reset, and git clean, you can selectively discard changes in specific files or across the entire repository, ensuring that your codebase remains clean and aligned with the desired state. It’s important to exercise caution when discarding changes, especially when using commands that can permanently remove modifications. Understanding these Git commands empowers developers to efficiently manage their workflows, revert unwanted changes, and maintain a streamlined and organized codebase.

Using git checkout Command

Using git restore Command (Git 2.23 and later)

Using git reset Command

Using git clean Command (for untracked files)

Using git stash Command