Vai al contenuto
code-to-code

Apro l'indice…

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

Git2. Il giro di ogni giornop. 41

Il giro di ogni giorno, le soluzioni

Il ragionamento, i comandi, le trappole

Per ogni missione, sempre lo stesso ordine: in italiano → i comandi → le trappole. Per le più difficili, anche il passo per passo.

La tua strada è diversa ma i test sono verdi? Va bene: il test guarda lo stato finale, non i comandi. Confronta il ragionamento, non le parole. E leggi comunque le trappole: alcune sembrano giuste e non lo sono.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

git-giro-di-ogni-giorno-soluzioni.zip31 KB

Lo zip delle soluzioni ha, accanto a ogni prepara.sh, un soluzione.sh: bash prepara.sh && bash soluzione.sh fa la missione al posto tuo.


La palestra

1 · Il primo commit

In italiano.

  1. La cartella non è un repository: git status risponde fatal.
  2. git init -b main crea l'album e dà il nome main al branch.
  3. Metto sul set tutti e due i file e scatto.

I comandi.

Terminale
cd progetto
git init -b main
git status
git add .
git commit -m "Primo commit: l'elenco degli oggetti smarriti"
git status

Dopo git init -b main, git status dice che i due file sono nuovi:

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        oggetti.txt
        regole.txt

nothing added to commit but untracked files present (use "git add" to track)

E dopo il commit:

[main (root-commit) 5803443] Primo commit: l'elenco degli oggetti smarriti
 2 files changed, 5 insertions(+)
 create mode 100644 oggetti.txt
 create mode 100644 regole.txt
On branch main
nothing to commit, working tree clean

Qui git add . va bene: i due file sono proprio quelli che vuoi, e git status te lo ha appena confermato. Scrivere git add oggetti.txt regole.txt funziona uguale.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
git add . e git commit senza git initfatal: not a git repository: non c'è nessun album. Il primo errore interrompe tuttotest_la_cartella_e_diventata_un_repository, test_il_branch_si_chiama_main, test_il_commit_ha_tutti_e_due_i_file, test_la_scrivania_e_pulita
git init -b main, poi git add oggetti.txtNel commit c'è un file solo, e regole.txt resta Untrackedtest_il_commit_ha_tutti_e_due_i_file, test_la_scrivania_e_pulita
git init -b master (o git init su un computer che parte da master)Funziona tutto, ma il branch ha un altro nometest_il_branch_si_chiama_main

La terza è la più subdola: nessun errore. Per questo il capitolo scrive sempre -b main. Se te ne accorgi dopo, git branch -M main rinomina il branch.


2 · Un file solo

In italiano.

  1. git status mostra due file modified, tutti e due sulla scrivania.
  2. Metto sul set solo avvisi.txt, per nome.
  3. Scatto: la foto prende il set.
  4. promemoria.txt è rimasto dov'era.

I comandi.

Terminale
cd progetto
git status
git add avvisi.txt
git commit -m "Aggiunge l'avviso della scala mobile"
git status
[main 5b809c4] Aggiunge l'avviso della scala mobile
 1 file changed, 1 insertion(+)
On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   promemoria.txt

no changes added to commit (use "git add" and/or "git commit -a")

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
git add . e git commitIl punto mette sul set tutti e due i file: la nota a metà finisce nell'albumtest_nel_commit_nuovo_solo_gli_avvisi, test_il_promemoria_resta_modificato_sulla_scrivania
git commit -a -m "…"-a prende tutti i file già seguiti e cambiati, senza passare dal set: stesso risultatotest_nel_commit_nuovo_solo_gli_avvisi, test_il_promemoria_resta_modificato_sulla_scrivania
git add avvisi.txt e bastaIl file è sul set, ma la foto non è stata scattata: nell'album non c'è niente di nuovotest_un_commit_nuovo_sopra_quello_di_sergio, test_nel_commit_nuovo_solo_gli_avvisi, test_il_promemoria_resta_modificato_sulla_scrivania

git commit -a è una scorciatoia: salta il set. Finché non hai chiaro cosa c'è dove, non usarla.


3 · Giù dal set

In italiano.

  1. git status mostra due file sul set: oggetti.txt (giusto) e contatti-privati.txt (nuovo, sbagliato).
  2. git restore --staged toglie dal set il file privato. Il file non si tocca: torna sulla scrivania, e siccome è nuovo diventa Untracked.
  3. Controllo: sul set c'è solo oggetti.txt.
  4. Scatto.

I comandi.

Terminale
cd progetto
git status
git restore --staged contatti-privati.txt
git status
git commit -m "Aggiunge la borsa nera"
git status

All'inizio:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   contatti-privati.txt
        modified:   oggetti.txt

Dopo git restore --staged contatti-privati.txt:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   oggetti.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        contatti-privati.txt

Il disegno.

inizio git status se un file è sul set per sbaglio sì: git restore --staged contatti-privati.txt passo git commit passo git status finegit statusun file è sul setper sbagliogit restore --stagedcontatti-privati.txtgit commitgit statusfinenosì
Togliere un file dal set

Passo per passo.

ComandoScrivaniaSetAlbum
(all'inizio)contatti-privati.txt nuovo, oggetti.txt modificatotutti e due1 commit
git restore --staged contatti-privati.txtcontatti-privati.txt nuovooggetti.txt1 commit
git commit -m "…"contatti-privati.txt nuovovuoto2 commit

Lo stesso git status dice come fare: sotto Changes to be committed c'è la riga (use "git restore --staged <file>..." to unstage).

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
git commit -m "…" subito, senza guardareSul set c'erano due file: finiscono tutti e due nella fototest_nel_commit_nuovo_solo_gli_oggetti, test_i_contatti_restano_sulla_scrivania_fuori_da_git
git restore contatti-privati.txtSenza --staged il comando guarda la scrivania, che è già uguale al set: non succede niente, e il file resta sul settest_nel_commit_nuovo_solo_gli_oggetti, test_i_contatti_restano_sulla_scrivania_fuori_da_git
git rm -f contatti-privati.txtLo toglie dal set, ma cancella anche il file dalla scrivania: le note di Nadia sono persetest_i_contatti_restano_sulla_scrivania_fuori_da_git

4 · La modifica da buttare

In italiano.

  1. git status mostra due file modified, tutti e due sulla scrivania.
  2. git diff avvisi.txt conferma: la riga aggiunta è quella sbagliata.
  3. git restore avvisi.txt: il file torna com'era nell'ultima foto.
  4. Il turno nuovo è giusto: lo metto sul set e scatto.

I comandi.

Terminale
cd progetto
git status
git restore avvisi.txt
git add turni.txt
git commit -m "Aggiunge il turno di notte di Sergio"
git status

Prima di buttare, guarda cosa butti:

diff
diff --git a/avvisi.txt b/avvisi.txt
index e47641e..e43d5b1 100644
--- a/avvisi.txt
+++ b/avvisi.txt
@@ -1,2 +1,3 @@
 Ponte Ciclo: l'ascensore B è in manutenzione fino a mercoledì.
 Ponte Ciclo: i tornelli 3 e 4 si aprono con il badge del personale.
+Ponte Ciclo: domani la stazione resta chiusa tutto il giorno.

Dopo git restore avvisi.txt, git status mostra solo turni.txt:

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   turni.txt

no changes added to commit (use "git add" and/or "git commit -a")

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
git commit -a -m "…"Prende anche l'avviso falso: ora è nell'album, per sempretest_nel_commit_nuovo_solo_i_turni, test_l_avviso_sbagliato_non_c_e_piu
git restore .Il punto butta tutte le modifiche, anche il turno giusto: poi git commit non ha niente da fotografaretest_un_commit_nuovo_sopra_quello_di_sergio, test_nel_commit_nuovo_solo_i_turni
git add turni.txt e git commit, senza restoreIl commit è giusto, ma l'avviso falso resta sulla scrivania: pronto a finire nel prossimo committest_l_avviso_sbagliato_non_c_e_piu, test_la_scrivania_e_pulita

La seconda è la più pericolosa: git restore . non chiede conferma e quello che butta non torna. Con il nome del file, butti solo quel file.


5 · Due cose in un file

In italiano.

  1. git diff mostra due pezzi, ognuno con la sua riga @@: l'ombrello in alto, lo zaino in basso.
  2. git add -p oggetti.txt: al primo pezzo rispondo y (sul set), al secondo n (resta sulla scrivania).
  3. Primo commit: contiene solo l'ombrello.
  4. La modifica rimasta è ormai l'unica: git add oggetti.txt la prende tutta. Secondo commit.

I comandi.

Terminale
cd progetto
git diff
git add -p oggetti.txt        # y al primo pezzo, n al secondo
git commit -m "Aggiunge l'ombrello blu"
git add oggetti.txt
git commit -m "Segna come ritirato lo zaino verde"
git log --oneline

I pezzi, come li mostra git diff: i due @@ sono i due pezzi.

diff
diff --git a/oggetti.txt b/oggetti.txt
index 9f956b7..da3dbe1 100644
--- a/oggetti.txt
+++ b/oggetti.txt
@@ -1,5 +1,6 @@
 OGGETTI SMARRITI · LARGO LISTA
 ------------------------------
+ombrello blu · trovato a Largo Lista, banco 2
 guanto rosso · trovato sul binario 1
 borsa nera · trovata sul treno M16
 cappello di lana · trovato alla biglietteria
@@ -7,5 +8,5 @@ bicicletta pieghevole · trovata all'uscita nord
 libro di cucina · trovato sulla scala mobile
 sciarpa a righe · trovata sul treno M12
 telefono spento · trovato sulla panchina
-zaino verde · in custodia
+zaino verde · ritirato
 chiavi con portachiavi · trovate al tornello 2

Qui i due pezzi sono lontani, quindi Git li separa da solo: non serve il tasto s dell'esempio D.

Il disegno.

inizio git add -p oggetti.txt per ogni pezzo se è l'ombrello sì: y, va sul set no: n, resta fuori passo git commit per l'ombrello passo git add oggetti.txt passo git commit per lo zaino finegit add -p oggetti.txtper ogni pezzoè l'ombrellon, resta fuoriy, va sul setgit commit per l'ombrellogit add oggetti.txtgit commit per lo zainofinenosìfiniti
Due commit da un file

Passo per passo.

ComandoScrivaniaSetAlbum
(all'inizio)oggetti.txt con ombrello e zaino ritiratovuoto1 commit
git add -p (y, n)oggetti.txt con lo zaino ritirato, ancora da scattareoggetti.txt con l'ombrello1 commit
git commit -m "…ombrello"oggetti.txt con lo zaino ritiratovuoto2 commit
git add oggetti.txtpulitaoggetti.txt con lo zaino ritirato2 commit
git commit -m "…zaino"pulitavuoto3 commit

Alla fine il log:

5dab37c Segna come ritirato lo zaino verde
3fd78d4 Aggiunge l'ombrello blu
35d5ced Primo commit: l'elenco degli oggetti smarriti

Puoi scegliere anche l'ordine opposto (n al primo pezzo, y al secondo): il test accetta tutte e due.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
git add oggetti.txt e un solo git commitIl file intero va sul set: le due modifiche finiscono in una foto solatest_due_commit_nuovi_in_fila_sopra_quello_di_nadia, test_ogni_commit_ha_una_modifica_sola
git add -p con y a tutte e due le domandeÈ come git add: tutto sul set, un commit solotest_due_commit_nuovi_in_fila_sopra_quello_di_nadia, test_ogni_commit_ha_una_modifica_sola
git add -p (y, n) e git commit, e poi ci si fermaIl primo commit è giusto, ma la seconda modifica resta sulla scrivaniatest_due_commit_nuovi_in_fila_sopra_quello_di_nadia, test_ogni_commit_ha_una_modifica_sola, test_la_scrivania_e_pulita

L'ultima si evita con l'abitudine: dopo ogni commit, git status. Se non è pulito, chiediti perché.


6 · Cosa è cambiato

In italiano.

  1. git status mostra due blocchi: sul set ci sono avvisi.txt e scale-mobili.txt; sulla scrivania ci sono scale-mobili.txt e turni.txt.
  2. Domanda 1: i file sul set sono 2.
  3. Domanda 2: solo sulla scrivania, e non sul set, c'è turni.txt.
  4. Domanda 3: in tutti e due i posti c'è scale-mobili.txt: una parte della modifica è sul set, un'altra (la riga scritta dopo il git add) è ancora sulla scrivania.
  5. git commit, senza altro: la foto prende il set. La riga nuova di scale-mobili.txt e il turno restano sulla scrivania.

I comandi.

Terminale
cd progetto
git status
git diff
git diff --staged
git commit -m "Aggiunge l'avviso del tornello e la scala 2"
git status

risposte.txt:

domanda 1: 2
domanda 2: turni.txt
domanda 3: scale-mobili.txt

git status all'inizio:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   avvisi.txt
        modified:   scale-mobili.txt

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   scale-mobili.txt
        modified:   turni.txt

git diff (la scrivania) e git diff --staged (il set) dicono quali righe:

diff
diff --git a/scale-mobili.txt b/scale-mobili.txt
index 7cf8979..683266d 100644
--- a/scale-mobili.txt
+++ b/scale-mobili.txt
@@ -1,2 +1,3 @@
 Scala 1: in servizio.
 Scala 2: ferma fino a giovedì.
+Scala 3: in revisione.
diff --git a/turni.txt b/turni.txt
index 23d9553..bae807c 100644
--- a/turni.txt
+++ b/turni.txt
@@ -1,2 +1,3 @@
 06:00-14:00 Sergio Colombo, M12
 14:00-22:00 Nadia Russo, M14
+22:00-06:00 Sergio Colombo, deposito
diff
diff --git a/avvisi.txt b/avvisi.txt
index 6a1381d..6b536ac 100644
--- a/avvisi.txt
+++ b/avvisi.txt
@@ -1 +1,2 @@
 Ponte Ciclo: l'ascensore B è in manutenzione fino a mercoledì.
+Ponte Ciclo: il tornello 4 è fuori servizio.
diff --git a/scale-mobili.txt b/scale-mobili.txt
index 20978aa..7cf8979 100644
--- a/scale-mobili.txt
+++ b/scale-mobili.txt
@@ -1 +1,2 @@
 Scala 1: in servizio.
+Scala 2: ferma fino a giovedì.

Passo per passo.

ComandoScrivaniaSetAlbum
(all'inizio)scale-mobili.txt con la scala 3, turni.txtavvisi.txt, scale-mobili.txt con la scala 21 commit
git commit -m "…"scale-mobili.txt con la scala 3, turni.txtvuoto2 commit

Dopo il commit, git status mostra ancora quello che non era sul set:

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   scale-mobili.txt
        modified:   turni.txt

no changes added to commit (use "git add" and/or "git commit -a")

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Domanda 1: 3Conta tutti i file cambiati, non quelli sul settest_domanda_1_quanti_file_sono_sul_set
Domanda 2: scale-mobili.txt, domanda 3: turni.txtIl set e la scrivania scambiati: turni.txt non è mai stato sul settest_domanda_2_il_file_solo_sulla_scrivania, test_domanda_3_il_file_sul_set_e_sulla_scrivania
git commit -a -m "…"-a prende tutto quello che è cambiato: anche i turni e la scala 3 entrano nella fototest_il_commit_ha_quello_che_era_sul_set, test_le_modifiche_nuove_restano_sulla_scrivania

La prima trappola ha una morale: git status elenca i file con due blocchi, e un file può stare in tutti e due.