Summary  
This chapter explains how to amend the most recent Git commit—either by modifying its commit message or by staging and including additional changes—effectively overwriting the previous commit.  

General domain of usage  
Version control in software development

Durante lo sviluppo, non è raro rendersi conto che una modifica già confermata necessita di **modifiche** o di **informazioni aggiuntive**. Git offre strumenti potenti per **modificare** i commit, consentendo agli sviluppatori di:
* Raffinare i messaggi di commit;
* Aggiungere ulteriori modifiche, oppure suddividere e unire commit.

## Modifica del messaggio dell'ultimo commit
La forma più semplice di **modifica** di un commit consiste nel cambiare il suo messaggio. Se si desidera modificare il messaggio dell'ultimo commit, utilizzare il seguente comando:

```bash
git commit --amend -m "New and improved commit message"
```
L'ultimo commit verrà quindi **sovrascritto** con il nuovo messaggio.

In alternativa, è possibile eseguire semplicemente il comando `git commit --amend` senza il flag `-m`. Questo comando apre il **text editor predefinito** con il messaggio del commit precedente. Modificare il messaggio, salvare e chiudere l'editor per aggiornare il commit.

Ora modifica il messaggio dell'ultimo commit nel repository.
Per prima cosa, visualizza l'**ultimo** commit:
```
git log -n 1
```

Il messaggio del commit è accettabile, ma può essere migliorato specificando che il file aggiunto è un **file di testo**.
Verificare che la **working tree** e la **staging area** siano vuote:
```
git status
```

Come puoi vedere, la working tree è pulita e la staging area è vuota, quindi ora modifica il messaggio dell'ultimo commit:
```
git commit --amend -m "Add a text file with a simple recipe for boiled eggs"
```

Quindi confermare che l'ultimo commit è stato **sovrascritto** visualizzando i due commit più recenti:
```
git log -n 2
```

C'è solo un commit con l'aggiunta del file `recipe.txt`, quindi l'ultimo commit è stato effettivamente sovrascritto.


## Aggiunta di modifiche all'ultimo commit
Per **aggiungere modifiche** all'ultimo commit, prima aggiungere le modifiche all'area di staging utilizzando `git add`. Poi eseguire il comando `git commit --amend`:
```bash
git commit --amend -m "New commit message"
```
Quando si esegue `git commit --amend`, le modifiche in staging vengono **committate** e il commit precedente viene **sovrascritto** con il nuovo messaggio.
È anche possibile omettere il flag `-m` per modificare il messaggio in un editor di testo.

Ora aggiungere alcune modifiche al commit **più recente**.
Per prima cosa, aggiungere una nuova riga al file recipe con il prossimo passaggio, quindi controllare lo stato della **working tree** e dell'**area di staging**:
```
echo "7. Transfer eggs to ice water or run cold water over them." >> recipe.txt
```

Ora aggiungere il file all'area di staging e **sovrascrivere** l'ultimo commit con le nuove modifiche:
```
git add recipe.txt
```

```
git commit --amend -m "Add a text file with a simple recipe for boiled eggs"
```

Infine, visualizzare i due commit più recenti per verificare che l'ultimo commit sia stato **sovrascritto**:
```
git log -n 2
```

C'è un solo commit con l'aggiunta del file `recipe.txt`, quindi l'ultimo commit è stato effettivamente **sovrascritto**.


Quale comando permette di modificare il messaggio dell'ultimo commit Git?

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.

Modifica dei Commit

Modifica del messaggio dell'ultimo commit

Aggiunta di modifiche all'ultimo commit