Git & GitHub Professional Workflow · Lezione

Rebase e merge a confronto

Confronti rebase e merge e impari quando utilizzare ciascuno dei due per ottenere una cronologia pulita e lineare.

Rebase e merge a confronto è una lezione Git & GitHub Professional Workflow gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Git & GitHub Professional Workflow, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Git & GitHub Professional Workflow include 4 lezioni in totale.

Merge o rebase? La scelta

Quando lavora con Git, spesso si accorge che il suo branch diverge da un altro, ad esempio il branch feature da main.

Come si integrano queste modifiche? Git offre due strategie principali: merge e rebase. Entrambe consentono l'integrazione, ma lo fanno in modi fondamentalmente diversi, producendo cronologie del progetto differenti.

Merge: unire le cronologie

Il merge è il modo predefinito di Git per integrare le modifiche. Quando si integra un branch in un altro, Git prende il contenuto del branch di origine e lo combina con quello del branch di destinazione.

La caratteristica principale del merge è che crea un nuovo commit di merge. Questo commit ha due commit padre e mostra esplicitamente che due cronologie divergenti sono state riunite. Conserva la cronologia esatta di entrambi i branch.

Eseguire un merge con Git

Vediamo un semplice merge. Creeremo un branch feature, aggiungeremo un commit e poi lo integreremo nuovamente in main.

git init my_merge_project
cd my_merge_project
echo "Initial content" > file.txt
git add .
git commit -m "Initial commit"

git branch feature
git checkout feature
echo "Feature A" >> feature.txt
git add .
git commit -m "Add feature A"

git checkout main
echo "Main update" >> main.txt
git add .
git commit -m "Update main"

git merge feature

git log --oneline --graph

Merge: vantaggi e svantaggi

Il merge è semplice e sicuro per i branch condivisi, ma può creare una cronologia "disordinata".

Vantaggi:
Conserva la cronologia esatta dei commit.
È non distruttivo e non riscrive i commit esistenti.
È semplice da usare e comprendere.
Svantaggi:
Può creare una cronologia "rumorosa", con molti commit di merge.
Il grafo può apparire complesso quando vengono integrati molti branch.

Rebase: riscrivere la cronologia

Il rebase è un'alternativa al merge che integra le modifiche spostando o combinando una sequenza di commit su un nuovo commit di base. Invece di creare un commit di merge, riscrive la cronologia del progetto.

In pratica, i commit del branch delle funzionalità vengono "riprodotti" sopra l'ultimo commit del branch di destinazione, dando l'impressione che il lavoro sia iniziato da lì. Si ottiene così una cronologia lineare, senza commit di merge aggiuntivi.

Eseguire un rebase con Git

Ora proviamo lo stesso scenario con il rebase. Eseguiremo il rebase del branch feature su main.

Noti come il commit del branch feature venga riapplicato sopra l'ultimo commit di main; quindi un merge fast-forward fa puntare main a quel commit.

git init my_rebase_project
cd my_rebase_project
echo "Initial content" > file.txt
git add .
git commit -m "Initial commit"

git branch feature
git checkout feature
echo "Feature B" >> feature.txt
git add .
git commit -m "Add feature B"

git checkout main
echo "Main update 2" >> main.txt
git add .
git commit -m "Update main 2"

git checkout feature
git rebase main

git checkout main
git merge feature

git log --oneline --graph

Rebase: vantaggi e svantaggi

Il rebase crea una cronologia pulita, ma comporta un'importante avvertenza riguardo ai branch condivisi.

Vantaggi:
Crea una cronologia del progetto pulita e lineare.
Rende più semplice consultare e comprendere la cronologia dei commit.
Consente di riordinare i commit (eseguire squash o modificarne l'ordine) prima dell'integrazione.
Svantaggi:
Riscrive la cronologia dei commit.
Può essere rischioso se usato su commit già inviati a un repository remoto condiviso (pubblico).

Merge e rebase: confronto

Ecco un breve riepilogo delle differenze principali:

Merge:
Crea un nuovo commit di merge.
Conserva la cronologia completa ed esatta.
È non distruttivo.
Il grafo può essere complesso.
Rebase:
Riscrive la cronologia, senza creare un commit di merge.
Produce una cronologia lineare.
È distruttivo (modifica gli ID dei commit).
Il grafo è molto pulito.

Scegliere la strategia

Quindi, quando si dovrebbe usare l'una o l'altra strategia?

Usi il merge quando:
Lavora su branch pubblici o condivisi, ad esempio main e develop.
Deve conservare la cronologia esatta del progetto.
Vuole mostrare esplicitamente quando sono state unite cronologie divergenti.
Usi il rebase quando:
Lavora sul suo branch privato delle funzionalità prima di eseguirne il push.
Vuole una cronologia pulita e lineare.
Vuole riordinare i commit del branch delle funzionalità, ad esempio eseguendo squash o modificandone l'ordine, prima dell'integrazione.

La regola d'oro: non esegua mai il rebase di commit già inviati a un repository remoto condiviso! Riscrivere la cronologia condivisa può causare seri problemi ai collaboratori.

Verifica rapida: merge o rebase?

Consideri le caratteristiche delle due principali strategie di integrazione di Git.

Riepilogo: merge e rebase

In questa lezione abbiamo analizzato i due modi fondamentali di Git per integrare le modifiche: merge e rebase.

Il merge unisce le cronologie con un nuovo commit di merge, conservando tutti i commit originali.
Il rebase riscrive la cronologia, creando un flusso lineare spostando i commit.

Scelga con attenzione in base al workflow del team e ricordi la regola d'oro: non esegua mai il rebase della cronologia pubblica! Questa conoscenza è fondamentale per mantenere un workflow Git pulito e collaborativo.

Domande Frequenti

La lezione «Rebase e merge a confronto» è gratuita?

Sì — il testo completo di «Rebase e merge a confronto» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Git & GitHub Professional Workflow, passa a CoddyKit PRO. Il corso Git & GitHub Professional Workflow include 4 lezioni in totale.

Cosa imparerò in «Rebase e merge a confronto»?

Confronti rebase e merge e impari quando utilizzare ciascuno dei due per ottenere una cronologia pulita e lineare. Eserciti Git & GitHub Professional Workflow con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Git & GitHub Professional Workflow?

Non è richiesta alcuna esperienza precedente. Git & GitHub Professional Workflow su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Rebase e merge a confronto»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Git & GitHub Professional Workflow?

Sì. Ogni lezione Git & GitHub Professional Workflow include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Git & GitHub Professional Workflow