Il grafo, esercizi spiegati
Cinque disegni, una riga alla volta
- 20 minuti di lettura
Cinque scenari, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi la storia, prendi un foglio e disegna. Poi rispondi alla domanda, prima di aprire la risposta.
- In italiano: cosa è successo, a parole.
- Passo per passo: dove stanno HEAD e le etichette dopo ogni comando.
- Cosa portiamo a casa: la regola da ricordare.
Qui non serve il terminale: bastano un foglio e una matita. Se vuoi una prova, gli output veri che trovi in pagina vengono da Git, lanciato in una cartella di prova con commit vuoti chiamati C1, C2…: stesso disegno, in verticale.
Un'avvertenza: in ogni scenario i commit si chiamano C1, C2, C3… nell'ordine in cui nascono. Il commit di merge, quando c'è, prende il numero dopo.
A · Un branch appena nato
Lucia Ferri fa due commit su main. Poi crea il branch capodanno (git switch -c capodanno) e non fa altro.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Quanti commit ci sono? Dove punta capodanno? Dove sta HEAD?
C1 ◀── C2 ◀── main
▲
capodanno ◀── HEADDue commit, e capodanno punta allo stesso commit di main: C2. HEAD sta su capodanno.
In italiano. Creare un branch non scatta nessuna foto: attacca una seconda etichetta sul commit dove sei, e ti sposta lì. Per questo main e capodanno stanno sullo stesso post-it.
Passo per passo.
| Comando | HEAD | main | capodanno | Commit nuovi |
|---|---|---|---|---|
git commit (due volte) | main | C2 | non c'è | C1, C2 |
git switch -c capodanno | capodanno | C2 | C2 | nessuno |
Git è d'accordo. I due branch hanno lo stesso commit, e la stella davanti a capodanno dice dov'è HEAD:
$ git log --oneline --graph --all --decorate
* 675326a (HEAD -> capodanno, main) C2
* 809eea0 C1
$ git branch
* capodanno
mainCosa portiamo a casa. Un branch è un'etichetta: nasce gratis, e all'inizio non ha niente di diverso dal branch da cui parte.
B · Il branch che avanza
Lucia fa due commit su main, poi crea il branch ascensore e ci fa due commit. Infine torna su main (git switch main).
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Dove punta main? Dove punta ascensore? Dove sta HEAD?
C1 ◀── C2 ◀── main ◀── HEAD
▲
└── C3 ◀── C4 ◀── ascensoremain è ancora su C2, ascensore è su C4, HEAD è sopra main.
In italiano. I due commit nuovi sono nati mentre HEAD stava su ascensore (regola 3): quindi si è mosso solo ascensore. main è rimasto dov'era. Poi git switch main ha spostato soltanto HEAD: i commit non si toccano.
Passo per passo.
| Comando | HEAD | main | ascensore | Commit nuovi |
|---|---|---|---|---|
git commit (due volte) | main | C2 | non c'è | C1, C2 |
git switch -c ascensore | ascensore | C2 | C2 | nessuno |
git commit (due volte) | ascensore | C2 | C4 | C3, C4 |
git switch main | main | C2 | C4 | nessuno |
Il terminale lo mostra con main più in basso. Da main non si vedono C3 e C4, ma restano nell'album, perché ascensore li raggiunge:
$ git log --oneline --graph --all --decorate
* 3d2d180 (ascensore) C4
* 47bf00a C3
* 675326a (HEAD -> main) C2
* 809eea0 C1Cosa portiamo a casa. Il commit nuovo nasce dove sta HEAD. Cambiare branch non sposta nessun commit: sposta solo HEAD.
C · Il salto in avanti
Parti dalla storia di prima. Lucia, che è su main, unisce ascensore: git merge ascensore.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Nasce un commit di merge? Dove punta main alla fine?
C1 ◀── C2 ◀── C3 ◀── C4 ◀── main ◀── HEAD
▲
ascensoreNo, e main va a finire su C4.
In italiano. Chi riceve è main, ed è fermo su C2: da quando è nato ascensore, main non ha fatto commit. Non c'è niente da cucire, la storia è una riga sola. Regola 5: Git sposta l'etichetta main su C4 e basta. Nessun commit nuovo.
Passo per passo.
| Comando | HEAD | main | ascensore | Commit nuovi |
|---|---|---|---|---|
| (all'inizio) | main | C2 | C4 | — |
git merge ascensore | main | C4 | C4 | nessuno |
Git lo dice con il suo nome, Fast-forward, e lo si vede dalle due etichette sullo stesso commit:
$ git merge ascensore
Updating 675326a..3d2d180
Fast-forward
$ git log --oneline --graph --all --decorate
* 3d2d180 (HEAD -> main, ascensore) C4
* 47bf00a C3
* 675326a C2
* 809eea0 C1(Qui, con commit vuoti, Git non elenca nessun file. Con file veri ci sarebbe anche l'elenco dei file cambiati.)
Cosa portiamo a casa. Prima di disegnare un merge, chiediti: chi riceve è andato avanti? Se no, l'etichetta salta. Se sì, nasce un commit.
D · Due strade e un merge
Il tabellone ha tre commit (C1, C2, C3). Lucia crea notte e ci fa un commit, C4: la corsa delle 6:36. Marta torna su main e fa un commit, C5: l'avviso dell'ascensore. Poi, da main, unisce notte.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Nasce un commit nuovo? Che numero ha? Quali sono i suoi genitori? Dove punta notte?
C1 ◀── C2 ◀── C3 ◀── C5 ◀── C6 ◀── main ◀── HEAD
▲ │
└── C4 ◀──────┘
▲
notteSì: C6, con due genitori, C5 e C4. notte resta su C4.
In italiano. Dopo la nascita di notte, main è andato avanti (C5). Le due storie si sono divise e Git non può spostare un'etichetta e basta. Crea un commit di merge, C6, con due frecce: una verso C5 (dove stava main), una verso C4 (dove sta notte). Regola 4. Il commit di merge è un commit come gli altri: prende il numero dopo.
Passo per passo.
| Comando | HEAD | main | notte | Commit nuovi |
|---|---|---|---|---|
| (all'inizio) | main | C3 | non c'è | C1, C2, C3 |
git switch -c notte + commit | notte | C3 | C4 | C4 |
git switch main + commit | main | C5 | C4 | C5 |
git merge notte | main | C6 | C4 | C6 (genitori C5 e C4) |
Nel terminale il commit di merge si riconosce perché le due linee, |\ e |/, si dividono e si ricongiungono. E dentro il commit, Git scrive due righe parent:
$ git log --oneline --graph --all --decorate
* 0920aa1 (HEAD -> main) Merge branch 'notte'
|\
| * c5ea134 (notte) Aggiunge la corsa delle 6:36
* | 14c50cb Aggiunge l'avviso dell'ascensore
|/
* b12df3f Aggiunge gli orari del mattino
* 1ece7ce Aggiunge le fermate della Linea Menta
* 5c2c617 Primo commit: il README del tabellone
$ git cat-file -p HEAD | head -3
tree 8a19873f1d237ffe8d50c17faed51def88bd66db
parent 14c50cbc4d5628a54601342860cbbaecb7f59c5e
parent c5ea134f7a8e136cdbc1ac3b67741c5b7583214dCosa portiamo a casa. Due strade che si ricongiungono sono sempre un commit con due genitori. E si è mosso solo main: notte non ha cambiato posto.
E · Il commit sbagliato
Ernesto Pozzi fa un commit su main, poi crea il branch orari-sabato e ci fa due commit: il primo, C2, ha un orario sbagliato; il secondo, C3, lo corregge. Torna su main, unisce il branch e lo cancella (git branch -d orari-sabato).
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Quanti commit si raggiungono da main alla fine? C2, quello sbagliato, c'è ancora?
C1 ◀── C2 ◀── C3 ◀── main ◀── HEADTre commit, e C2 c'è ancora.
In italiano. Il merge è un salto in avanti: main si sposta su C3. Poi git branch -d toglie l'etichetta orari-sabato. Solo l'etichetta: i commit restano, e main ora li raggiunge. Quanto a C2, l'errore non è sparito: regola 1, un commit non si cancella. La correzione è un commit nuovo sopra di lui.
Passo per passo.
| Comando | HEAD | main | orari-sabato | Commit nuovi |
|---|---|---|---|---|
git commit | main | C1 | non c'è | C1 |
git switch -c orari-sabato + due commit | orari-sabato | C1 | C3 | C2, C3 |
git switch main + git merge orari-sabato | main | C3 | C3 | nessuno |
git branch -d orari-sabato | main | C3 | cancellata | nessuno |
$ git branch -d orari-sabato
Deleted branch orari-sabato (was 400e987).
$ git log --oneline --graph --all --decorate
* 400e987 (HEAD -> main) C3 corregge
* a7369d6 C2 sbagliato
* 809eea0 C1Cosa portiamo a casa. branch -d toglie un'etichetta, non i commit. E per correggere un errore non si cancella: si scatta una foto nuova.