Summary  
This chapter explains how to merge code branches in Git, detailing fast-forward and three-way merge strategies for integrating divergent commit histories and resolving conflicts.

General domain of usage  
Version control

## Comprensione della fusione dei branch
In Git, **fusione** è il processo di integrazione delle modifiche da un branch a un altro. Il caso d'uso più comune è la fusione dei branch **feature** nel branch **main** (ad esempio, `main` o `master`). Questo garantisce che le ultime funzionalità e correzioni di bug siano incorporate nel codice principale.


## Flusso di lavoro base per la fusione

Per prima cosa, visualizzazione degli ultimi due commit.
Ricorda che sei attualmente sul branch `feature/new-feature`.
```
git log -n 2
```

Come puoi vedere, il branch `master` è un commit **indietro**.
Prima di unire, è necessario **passare** al branch in cui verranno integrati i cambiamenti.
Passa al branch `master` e visualizza i due commit più recenti su di esso:
```
git checkout master
```

Il branch `master` è effettivamente un commit indietro rispetto al branch **feature**.
Per unirli, utilizzare il comando `git merge` e specificare il branch da unire al branch **corrente**.
Ad esempio, per unire il branch `feature/new-feature` in `master`, eseguire:
```
git merge feature/new-feature
```

Il messaggio visualizzato dopo l'esecuzione del comando contiene la seguente dicitura: `Fast-forward`, che indica che è stata eseguita una fusione **fast-forward**.


Nota

Esplorerai i due tipi di merge più avanti in questo capitolo.
Prima di ciò, visualizza gli ultimi due commit:
```
git log -n 2
```

Sei ancora sul branch `master`, ma ora è aggiornato con il branch **feature**, con **entrambi** i branch che puntano allo stesso commit.


**HEAD** punta ancora al branch `master` perché eri su questo branch durante l'esecuzione del merge.


## Tipi di merge

Esistono due tipi di operazioni di merge in Git:

* **Merge fast-forward**;
* **Merge a tre vie**.

### Merge fast-forward

Il merge che hai eseguito è un **merge fast-forward**, come indicato nel messaggio.
Questo tipo si verifica quando **tutti** i commit del branch attualmente selezionato sono presenti anche nel branch che viene unito, il che significa che le loro storie dei commit **non divergono**.

Consulta la seguente illustrazione per chiarimenti:


Con questo tipo di merge, il puntatore del branch selezionato viene semplicemente aggiornato all'ultimo commit.


### Merge a tre vie 
Tuttavia, se la cronologia dei branch si è **diversa**, ovvero dopo un certo commit comune sono stati effettuati nuovi commit separatamente su ciascun branch, viene eseguito un merge **a tre vie**. 

Il termine "a tre vie" si riferisce alle **tre versioni** coinvolte nel merge:

* La versione del **antenato comune più recente** (commit);
* La versione dell'ultimo commit nel branch corrente (**HEAD**); 
* La versione dell'**ultimo commit** nel branch che viene unito.

Osserva la seguente illustrazione di questo tipo di merge:


Ecco come funziona un merge a tre vie:

1. Git identifica le modifiche apportate su ciascun branch dopo il **più recente antenato comune**;
2. Se ogni branch ha modifiche in file diversi o in parti diverse dello stesso file, Git **unirà automaticamente** le modifiche combinandole nel commit risultante;
3. Altrimenti si verificherà un **conflitto di merge**.



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.

Fusione dei Rami

Comprensione della fusione dei branch

Flusso di lavoro base per la fusione

Tipi di merge

Merge fast-forward

Merge a tre vie