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

A volte si possono modificare i file nell’**albero di lavoro** ma decidere di scartare tali modifiche prima di aggiungerle all’area di staging.  
Ora vengono illustrate le modalità per annullare le modifiche in **Git** prima che vengano aggiunte all’area di staging.

## Scartare modifiche con git restore
Il comando `git restore` è uno strumento versatile per scartare le modifiche nell’**albero di lavoro**. Per annullare le modifiche nei file modificati prima dello staging, è possibile utilizzare questo comando nel modo seguente:

```bash
git restore <file>
```
Dove `<file>` rappresenta il **nome** dei file o il loro **percorso relativo alla directory del progetto**. Questo comando ripristina il file specificato alla versione che è **in staging**. Se l’area di staging è vuota, il file viene ripristinato alla versione presente nell’**ultimo commit**.


## Ripristino alla versione in staging

Per prima cosa, creare un nuovo file chiamato `recipe.txt` contenente una semplice **ricetta per uova sode** utilizzando il comando `echo`:
```
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
```

Ora aggiungere questo file e modificarlo aggiungendo un'altra riga con il prossimo passaggio della ricetta:
```
git add recipe.txt
```

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

Ops, è stato utilizzato **l'operatore sbagliato** — `>` (che sovrascrive il file) invece di `>>` (che aggiunge una nuova riga).
Prima di correggere, controllare lo **stato** dell'albero di lavoro e dell'area di staging:
```
git status
```

Come puoi vedere, la versione iniziale del file è **in stage**, quindi ripristina il file a questa versione e controlla nuovamente lo **stato** dell'area di lavoro e dell'area di stage:
```
git restore recipe.txt
```

Come puoi vedere, il nostro working tree è ora **pulito**, quindi le modifiche sono state annullate e il file è stato ripristinato alla versione **staged**.


## Ripristino all'ultimo commit

Per prima cosa, eseguire il commit della creazione del file `recipe.txt`:
```
git commit -m "Add a file with a simple recipe for boiled eggs"
```

Il commit è stato eseguito con successo.
Ora aggiungere **un'altra riga** al file con il passo successivo della ricetta e controllare lo stato dell'**albero di lavoro**:
```
echo "10. Transfer eggs to ice water or run cold water over them">> recipe.txt
```

Ops, è stato commesso un altro errore — il passaggio aggiunto dovrebbe essere **7**, non **10**.  
Nessun problema; è possibile annullare questa modifica tornando all'**ultimo commit**.  
Per prima cosa, controllare l'ultimo commit:
```
git log -n 1
```

Questo commit è esattamente quello necessario, quindi **ripristinare** le modifiche a questa versione e verificare che la working tree sia **pulita**:
```
git restore recipe.txt
```

L'albero di lavoro è **pulito**, il che significa che le modifiche sono state annullate e il file è stato ripristinato alla versione dell'**ultimo commit**.

Cosa fa il comando `git restore <file>` prima di mettere in stage le modifiche?

Git è il sistema di controllo versione più diffuso, utilizzato da milioni di sviluppatori in tutto il mondo. Che tu sia uno sviluppatore esperto o un principiante, questo corso ti fornirà le conoscenze e le competenze necessarie per gestire in modo efficiente i tuoi progetti software, collaborare con altri e padroneggiare l'arte del controllo versione.

Per prima cosa, forniremo una panoramica generale dei sistemi di controllo versione. Successivamente discuteremo di Git e apprenderemo le basi della creazione di un repository e delle modifiche ad esso.

Ora è il momento di approfondire interazioni più avanzate con Git, che aumenteranno la tua efficienza e ti renderanno più familiare con alcuni dei flussi di lavoro Git più comuni.

In quanto sistema di controllo versione, Git consente di annullare le modifiche quando necessario; è quindi il momento di scoprire le tecniche in Git per ripristinare le modifiche non tracciate nell'area di lavoro, le modifiche in stage e persino annullare o sovrascrivere i commit.

I rami in Git sono estremamente utili quando si collabora con altri, si correggono bug o si sviluppano determinate funzionalità nel proprio progetto. Senza ulteriori indugi, esploriamo tutte le sfumature del lavoro con i rami.

Annullare le Modifiche Prima dello Staging

Scartare modifiche con git restore

Ripristino alla versione in staging

Ripristino all'ultimo commit