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

Soms worden er wijzigingen aangebracht in de **werkmap**, maar besluit je deze wijzigingen te negeren voordat je ze staged.  
Hier worden methoden onderzocht om wijzigingen in **Git** ongedaan te maken voordat ze aan de staging area worden toegevoegd.

## Wijzigingen ongedaan maken met git restore
Het commando `git restore` is een veelzijdig hulpmiddel om wijzigingen in de **werkmap** ongedaan te maken. Om wijzigingen in aangepaste bestanden ongedaan te maken voordat ze worden gestaged, gebruik je het volgende commando:

```bash
git restore <file>
```
Waarbij `<file>` de **naam** van het bestand of het **pad ten opzichte van de projectmap** is. Dit commando zet het opgegeven bestand terug naar de versie die is **gestaged**. Als de staging area leeg is, wordt het bestand teruggezet naar de versie in de **laatste commit**.


## Terugzetten naar de gestagede versie

Maak eerst een nieuw bestand aan met de naam `recipe.txt` met daarin een eenvoudig **recept voor gekookte eieren** via het `echo`-commando:
```
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
```

Voeg nu dit bestand toe en wijzig het door een extra regel toe te voegen met de volgende stap van het recept:
```
git add recipe.txt
```

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

Oeps, de **verkeerde operator** is gebruikt — `>` (die het bestand overschrijft) in plaats van `>>` (die een nieuwe regel toevoegt).
Controleer voor het herstellen de **status** van de werkmap en de staging area:
```
git status
```

Zoals je kunt zien, is de initiële versie van het bestand **gestaged**, dus herstel het bestand naar deze versie en controleer opnieuw de **status** van de werkmap en de staging area:
```
git restore recipe.txt
```

Zoals je kunt zien, is onze werkboom nu **schoon**, dus de wijzigingen zijn ongedaan gemaakt en het bestand is teruggezet naar de **gestage** versie.


## Terugkeren naar de laatste commit

Maak eerst een commit van het bestand `recipe.txt`:
```
git commit -m "Add a file with a simple recipe for boiled eggs"
```

De commit is geslaagd.
Voeg nu **nog een regel** toe aan het bestand met de volgende stap van het recept en controleer de status van de **werkboom**:
```
echo "10. Transfer eggs to ice water or run cold water over them">> recipe.txt
```

Oeps, er is weer een fout gemaakt — de toegevoegde stap moet **7** zijn, niet **10**.  
Geen probleem; je kunt deze wijziging terugdraaien naar de **laatste commit**.  
Controleer eerst de laatste commit:
```
git log -n 1
```

Deze commit is precies degene die nodig is, dus **herstel** de wijzigingen naar deze versie en controleer dat de werkmap **schoon** is:
```
git restore recipe.txt
```

De werkdirectory is **schoon**, wat betekent dat onze wijzigingen zijn teruggedraaid en het bestand is hersteld naar de versie van de **laatste commit**.

Wat doet het commando `git restore <file>` voordat wijzigingen worden gestaged?

Git is het meest populaire versiebeheersysteem dat door miljoenen ontwikkelaars wereldwijd wordt gebruikt. Of u nu een ervaren ontwikkelaar bent of een beginner, deze cursus voorziet u van de kennis en vaardigheden die nodig zijn om uw softwareprojecten efficiënt te beheren, samen te werken met anderen en de kunst van versiebeheer te beheersen.

Eerst geven we een overzicht van versiebeheersystemen in het algemeen. Vervolgens bespreken we Git en behandelen we de basisprincipes van het aanmaken van een repository en het aanbrengen van wijzigingen daarin.

Nu is het tijd om meer geavanceerde interactie met Git te bespreken, wat je efficiëntie zal verhogen en je meer vertrouwd zal maken met enkele van de gangbare Git-workflows.

Als versiebeheersysteem biedt Git de mogelijkheid om wijzigingen ongedaan te maken wanneer dat nodig is. Ontdek de technieken in Git om niet-gestage wijzigingen in de werkmap, gestage wijzigingen en zelfs commits terug te draaien of te overschrijven.

Branches in Git zijn uiterst nuttig bij samenwerking met anderen, het oplossen van bugs of het ontwikkelen van specifieke functionaliteiten in uw project. Laten we zonder verder oponthoud ingaan op alle nuances van het werken met branches.

Wijzigingen Ongedaan Maken Vóór Het Toevoegen Aan De Staging Area

Wijzigingen ongedaan maken met git restore

Terugzetten naar de gestagede versie

Terugkeren naar de laatste commit