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.
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.
- La cartella non è un repository:
git statusrispondefatal. git init -b maincrea l'album e dà il nomemainal branch.- Metto sul set tutti e due i file e scatto.
I comandi.
cd progetto
git init -b main
git status
git add .
git commit -m "Primo commit: l'elenco degli oggetti smarriti"
git statusDopo 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 cleanQui 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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add . e git commit senza git init | fatal: not a git repository: non c'è nessun album. Il primo errore interrompe tutto | test_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.txt | Nel commit c'è un file solo, e regole.txt resta Untracked | test_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 nome | test_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.
git statusmostra due filemodified, tutti e due sulla scrivania.- Metto sul set solo
avvisi.txt, per nome. - Scatto: la foto prende il set.
promemoria.txtè rimasto dov'era.
I comandi.
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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add . e git commit | Il punto mette sul set tutti e due i file: la nota a metà finisce nell'album | test_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 risultato | test_nel_commit_nuovo_solo_gli_avvisi, test_il_promemoria_resta_modificato_sulla_scrivania |
git add avvisi.txt e basta | Il file è sul set, ma la foto non è stata scattata: nell'album non c'è niente di nuovo | test_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.
git statusmostra due file sul set:oggetti.txt(giusto) econtatti-privati.txt(nuovo, sbagliato).git restore --stagedtoglie dal set il file privato. Il file non si tocca: torna sulla scrivania, e siccome è nuovo diventaUntracked.- Controllo: sul set c'è solo
oggetti.txt. - Scatto.
I comandi.
cd progetto
git status
git restore --staged contatti-privati.txt
git status
git commit -m "Aggiunge la borsa nera"
git statusAll'inizio:
On branch main
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: contatti-privati.txt
modified: oggetti.txtDopo 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.txtIl disegno.
Passo per passo.
| Comando | Scrivania | Set | Album |
|---|---|---|---|
| (all'inizio) | contatti-privati.txt nuovo, oggetti.txt modificato | tutti e due | 1 commit |
git restore --staged contatti-privati.txt | contatti-privati.txt nuovo | oggetti.txt | 1 commit |
git commit -m "…" | contatti-privati.txt nuovo | vuoto | 2 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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git commit -m "…" subito, senza guardare | Sul set c'erano due file: finiscono tutti e due nella foto | test_nel_commit_nuovo_solo_gli_oggetti, test_i_contatti_restano_sulla_scrivania_fuori_da_git |
git restore contatti-privati.txt | Senza --staged il comando guarda la scrivania, che è già uguale al set: non succede niente, e il file resta sul set | test_nel_commit_nuovo_solo_gli_oggetti, test_i_contatti_restano_sulla_scrivania_fuori_da_git |
git rm -f contatti-privati.txt | Lo toglie dal set, ma cancella anche il file dalla scrivania: le note di Nadia sono perse | test_i_contatti_restano_sulla_scrivania_fuori_da_git |
4 · La modifica da buttare
In italiano.
git statusmostra due filemodified, tutti e due sulla scrivania.git diff avvisi.txtconferma: la riga aggiunta è quella sbagliata.git restore avvisi.txt: il file torna com'era nell'ultima foto.- Il turno nuovo è giusto: lo metto sul set e scatto.
I comandi.
cd progetto
git status
git restore avvisi.txt
git add turni.txt
git commit -m "Aggiunge il turno di notte di Sergio"
git statusPrima di buttare, guarda cosa butti:
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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git commit -a -m "…" | Prende anche l'avviso falso: ora è nell'album, per sempre | test_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 fotografare | test_un_commit_nuovo_sopra_quello_di_sergio, test_nel_commit_nuovo_solo_i_turni |
git add turni.txt e git commit, senza restore | Il commit è giusto, ma l'avviso falso resta sulla scrivania: pronto a finire nel prossimo commit | test_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.
git diffmostra due pezzi, ognuno con la sua riga@@: l'ombrello in alto, lo zaino in basso.git add -p oggetti.txt: al primo pezzo rispondoy(sul set), al secondon(resta sulla scrivania).- Primo commit: contiene solo l'ombrello.
- La modifica rimasta è ormai l'unica:
git add oggetti.txtla prende tutta. Secondo commit.
I comandi.
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 --onelineI pezzi, come li mostra git diff: i due @@ sono i due pezzi.
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 2Qui i due pezzi sono lontani, quindi Git li separa da solo: non serve il tasto s dell'esempio D.
Il disegno.
Passo per passo.
| Comando | Scrivania | Set | Album |
|---|---|---|---|
| (all'inizio) | oggetti.txt con ombrello e zaino ritirato | vuoto | 1 commit |
git add -p (y, n) | oggetti.txt con lo zaino ritirato, ancora da scattare | oggetti.txt con l'ombrello | 1 commit |
git commit -m "…ombrello" | oggetti.txt con lo zaino ritirato | vuoto | 2 commit |
git add oggetti.txt | pulita | oggetti.txt con lo zaino ritirato | 2 commit |
git commit -m "…zaino" | pulita | vuoto | 3 commit |
Alla fine il log:
5dab37c Segna come ritirato lo zaino verde
3fd78d4 Aggiunge l'ombrello blu
35d5ced Primo commit: l'elenco degli oggetti smarritiPuoi scegliere anche l'ordine opposto (n al primo pezzo, y al secondo): il test accetta tutte e due.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
git add oggetti.txt e un solo git commit | Il file intero va sul set: le due modifiche finiscono in una foto sola | test_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 solo | test_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 ferma | Il primo commit è giusto, ma la seconda modifica resta sulla scrivania | test_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.
git statusmostra due blocchi: sul set ci sonoavvisi.txtescale-mobili.txt; sulla scrivania ci sonoscale-mobili.txteturni.txt.- Domanda 1: i file sul set sono 2.
- Domanda 2: solo sulla scrivania, e non sul set, c'è
turni.txt. - Domanda 3: in tutti e due i posti c'è
scale-mobili.txt: una parte della modifica è sul set, un'altra (la riga scritta dopo ilgit add) è ancora sulla scrivania. git commit, senza altro: la foto prende il set. La riga nuova discale-mobili.txte il turno restano sulla scrivania.
I comandi.
cd progetto
git status
git diff
git diff --staged
git commit -m "Aggiunge l'avviso del tornello e la scala 2"
git statusrisposte.txt:
domanda 1: 2
domanda 2: turni.txt
domanda 3: scale-mobili.txtgit 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.txtgit diff (la scrivania) e git diff --staged (il set) dicono quali righe:
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, depositodiff --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.
| Comando | Scrivania | Set | Album |
|---|---|---|---|
| (all'inizio) | scale-mobili.txt con la scala 3, turni.txt | avvisi.txt, scale-mobili.txt con la scala 2 | 1 commit |
git commit -m "…" | scale-mobili.txt con la scala 3, turni.txt | vuoto | 2 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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Domanda 1: 3 | Conta tutti i file cambiati, non quelli sul set | test_domanda_1_quanti_file_sono_sul_set |
Domanda 2: scale-mobili.txt, domanda 3: turni.txt | Il set e la scrivania scambiati: turni.txt non è mai stato sul set | test_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 foto | test_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.