Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Git1. Il grafop. 6

Il grafo, esercizi spiegati

Cinque disegni, una riga alla volta

  • 20 minuti di lettura

Cinque scenari, dal più semplice. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi la storia, prendi un foglio e disegna. Poi rispondi alla domanda, prima di aprire la risposta.
  2. In italiano: cosa è successo, a parole.
  3. Passo per passo: dove stanno HEAD e le etichette dopo ogni comando.
  4. 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 ◀── HEAD

Due 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.

ComandoHEADmaincapodannoCommit nuovi
git commit (due volte)mainC2non c'èC1, C2
git switch -c capodannocapodannoC2C2nessuno

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
  main

Cosa 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 ◀── ascensore

main è 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.

ComandoHEADmainascensoreCommit nuovi
git commit (due volte)mainC2non c'èC1, C2
git switch -c ascensoreascensoreC2C2nessuno
git commit (due volte)ascensoreC2C4C3, C4
git switch mainmainC2C4nessuno

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 C1

Cosa 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
                     ▲
                     ascensore

No, 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.

ComandoHEADmainascensoreCommit nuovi
(all'inizio)mainC2C4—
git merge ascensoremainC4C4nessuno

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 ◀──────┘
                  ▲
                  notte

Sì: 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.

ComandoHEADmainnotteCommit nuovi
(all'inizio)mainC3non c'èC1, C2, C3
git switch -c notte + commitnotteC3C4C4
git switch main + commitmainC5C4C5
git merge nottemainC6C4C6 (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 c5ea134f7a8e136cdbc1ac3b67741c5b7583214d

Cosa 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 ◀── HEAD

Tre 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.

ComandoHEADmainorari-sabatoCommit nuovi
git commitmainC1non c'èC1
git switch -c orari-sabato + due commitorari-sabatoC1C3C2, C3
git switch main + git merge orari-sabatomainC3C3nessuno
git branch -d orari-sabatomainC3cancellatanessuno
$ 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 C1

Cosa portiamo a casa. branch -d toglie un'etichetta, non i commit. E per correggere un errore non si cancella: si scatta una foto nuova.