Summary  
This chapter covers how to use the git restore command with the --staged and --worktree flags to unstage and revert file modifications that have been staged for commit, restoring both the staging area and working directory to their previous states.

General domain of usage  
Version control

Sometimes, changes are **staged** for commit, but upon further consideration, you realize that certain modifications should not be included. Luckily, it is possible to **revert staged changes** in Git, ensuring that your commits accurately reflect the intended modifications.



## Undoing Staged Changes with git restore
The `git restore` command is a powerful tool for reverting staged changes. To undo modifications in files that have been staged but **not yet committed**, you can use the following command:
```bash
git restore --staged <file>
```
Where `<file>` is the **name** of the files or its **path relative to the project directory**. The `--staged` flag here "tells" Git to restore the changes in the **staging area**. After running this command the changes in the `<file>` will be **unstaged**.





This command doesn't revert the changes in the working tree. Instead, it only unstages them.

Note

In case you want to **unstage** and then revert the changes in the **working directory**, you can use the following command:
```bash
git restore --staged --worktree <file>
```
Here is an image to make things clear:

## Example Workflow

Suppose you want to add another line with the next step of the recipe:
```
echo "7. Serve the eggs" >> recipe.txt
```

Unlike in the previous chapter, no mistake was made, so stage this change:
```
git add recipe.txt
```

However, after reconsidering **before committing**, it appears that adding this line to the recipe file is unnecessary.
Therefore, completely **revert this change**.
First, check the status of the **working tree** and **staging area**:
```
git status
```

This change is indeed staged, so run the `git restore` command with the appropriate flags to **fully** revert it:
```
git restore --staged --worktree recipe.txt
```

Finally, verify that both the **working tree** and **staging area** are **clean**:
```
git status
```

Git ist das weltweit am häufigsten verwendete Versionskontrollsystem und wird von Millionen Entwicklern genutzt. Unabhängig davon, ob Sie ein erfahrener Entwickler oder Einsteiger sind, vermittelt Ihnen dieser Kurs das Wissen und die Fähigkeiten, um Ihre Softwareprojekte effizient zu verwalten, mit anderen zusammenzuarbeiten und die Kunst der Versionskontrolle zu beherrschen.

Zunächst geben wir einen Überblick über Versionskontrollsysteme im Allgemeinen. Anschließend besprechen wir Git und lernen die Grundlagen der Erstellung eines Repositories sowie das Vornehmen von Änderungen daran.

Nun ist es an der Zeit, fortgeschrittenere Interaktionen mit Git zu besprechen, die Ihre Effizienz steigern und Ihnen mehr Sicherheit im Umgang mit gängigen Git-Workflows geben.

Als Versionskontrollsystem ermöglicht Git das Rückgängigmachen von Änderungen bei Bedarf. Es ist daher an der Zeit, die Techniken in Git kennenzulernen, um nicht gestagte Änderungen im Arbeitsverzeichnis, gestagte Änderungen sowie das Zurücksetzen oder Überschreiben von Commits rückgängig zu machen.

Branches in Git sind äußerst nützlich bei der Zusammenarbeit mit anderen Personen, der Behebung von Fehlern oder der Entwicklung bestimmter Funktionen in Ihrem Projekt. Ohne weitere Umschweife werden wir alle Feinheiten der Arbeit mit Branches betrachten.

Reverting Staged Changes

Undoing Staged Changes with git restore

Example Workflow