Summary  
This chapter covers how to discard uncommitted changes in the working tree using `git restore`, allowing you to reset files either to the staged version or to the latest commit.  

General domain of usage  
Version control with Git

Sometimes you may modify the **working tree** but decide to discard those changes before staging them.  
Now explore methods for reverting changes in **Git** before they are added to the staging area.

## Discarding Changes with git restore
The `git restore` command is a versatile tool for discarding changes in your **working tree**. To revert changes in modified files before staging, you can use this command as follows:

```bash
git restore <file>
```
Where `<file>` is the **name** of the files or its **path relative to the project directory**. This command reverts the specified file to the version that is **staged**. If the staging area is empty, it reverts the file to the version in the **latest commit**. 


## Reverting to Staged Version

First, create a new file named `recipe.txt` containing a simple **recipe for boiled eggs** using the `echo` command:
```
echo "1. Prepare the Eggs
2. Boil Water
3. Place Eggs in the Saucepan
4. Boil the Eggs
5. Reduce Heat
6. Cook for 6-7 minutes" > recipe.txt
```

Now add this file and modify it by appending another line with the next step of the recipe:
```
git add recipe.txt
```

```
echo "7. Transfer eggs to ice water or run cold water over them" > recipe.txt
```

Oops, the **wrong operator** was used — `>` (which overwrites the file) instead of `>>` (which appends a new line).
Before fixing it, check the **status** of the working tree and staging area:
```
git status
```

As you can see, the initial version of the file is **staged**, so revert the file to this version and check the **status** of the working tree and staging area again:
```
git restore recipe.txt
```

As you can see, our working tree is now **clean**, so the changes were undone, and the file was reverted to the **staged** version.


## Reverting to the Latest Commit

First, commit the creation of the `recipe.txt` file:
```
git commit -m "Add a file with a simple recipe for boiled eggs"
```

The commit is successful.
Now add **another line** to the file with the next step of the recipe and check the status of the **working tree**:
```
echo "10. Transfer eggs to ice water or run cold water over them">> recipe.txt
```

Oops, another mistake occurred — the added step should be **7**, not **10**.  
No problem; you can revert this change to the **latest commit**.  
First, check the latest commit:
```
git log -n 1
```

This commit is exactly the one needed, so **restore** the changes to this version and verify that the working tree is **clean**:
```
git restore recipe.txt
```

The working tree is **clean** which means that our changes were undone, and the file was restored to the version of the **latest commit**.

What does the `git restore <file>` command do before staging changes?

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 Changes before Staging

Discarding Changes with git restore

Reverting to Staged Version

Reverting to the Latest Commit