emanuelegori/guida-git-https

Fork 0

Table of Contents

02 - Staging e Commit

git add

Sintassi
Spiegazione
Esempi pratici
Opzioni comuni
Note

git commit

Sintassi
Spiegazione
Esempi pratici
Best Practices - Messaggi Commit
Opzioni comuni
Note

git status

Sintassi
Spiegazione
Esempi pratici
Quando usare git status
Opzioni comuni
Note

git diff

Sintassi
Spiegazione
Esempi pratici
Output diff spiegato
Opzioni comuni
Note

git rm

Sintassi
Spiegazione
Esempi pratici
Workflow corretto per rimuovere file
Opzioni comuni
Note

git mv

Sintassi
Spiegazione
Esempi pratici
Workflow completo rinomina
Confronto: git mv vs mv manuale
Opzioni comuni
Note

🔗 Collegamenti
📝 Riepilogo comandi

02 - Staging e Commit

Comandi per preparare e salvare le modifiche nel repository.

`git add`

Sintassi

git add <file>
git add <directory>
git add [opzioni]

Spiegazione

Aggiunge file all'area di staging (index), preparandoli per il commit. I file "staged" sono pronti per essere salvati nella cronologia.

Esempi pratici

Aggiungere un singolo file:

git add README.md

Aggiungere tutti i file modificati:

git add .

Aggiunge tutti i file nella directory corrente e sottodirectory.

Aggiungere tutti i file del repository:

git add -A
# oppure
git add --all

Aggiunge file modificati, nuovi e rimossi ovunque nel repository.

Aggiungere solo file modificati (non nuovi):

git add -u
# oppure
git add --update

Aggiungere file con pattern:

git add *.py          # Tutti i file Python
git add src/*.js      # Tutti i JS in src/
git add docs/**/*.md  # Tutti i MD in docs/ ricorsivamente

Aggiungere interattivamente:

git add -p file.txt
# oppure
git add --patch file.txt

Ti chiede per ogni "hunk" (blocco di modifiche) se aggiungerlo o no.

Opzioni comuni

Opzione	Descrizione
`.`	Tutto dalla directory corrente
`-A`, `--all`	Tutto il repository
`-u`, `--update`	Solo file già tracciati
`-p`, `--patch`	Aggiunta interattiva
`-n`, `--dry-run`	Simula senza aggiungere
`-f`, `--force`	Forza aggiunta file ignorati

Note

Staging è reversibile con git reset
Puoi fare staging parziale dello stesso file
File in .gitignore non vengono aggiunti (usa -f per forzare)

`git commit`

Sintassi

git commit -m "messaggio"
git commit [opzioni]

Spiegazione

Salva le modifiche staged nella cronologia del repository. Ogni commit crea uno snapshot permanente con hash univoco.

Esempi pratici

Commit con messaggio:

git commit -m "Aggiungi funzione login utente"

Commit con messaggio multi-riga:

git commit -m "Fix bug autenticazione" -m "Corregge validazione token JWT scaduti"

Commit aprendo editor per messaggio lungo:

git commit

Si apre l'editor configurato (vim/nano) per scrivere messaggio dettagliato.

Commit di tutti i file modificati (senza git add):

git commit -a -m "Aggiorna documentazione"
# oppure
git commit -am "Aggiorna documentazione"

⚠️ Funziona solo per file già tracciati, NON aggiunge file nuovi.

Modificare ultimo commit:

git commit --amend -m "Messaggio corretto"

Sostituisce l'ultimo commit. Utile per:

Correggere messaggio
Aggiungere file dimenticati (fai git add prima)

Commit vuoto (senza modifiche):

git commit --allow-empty -m "Trigger CI pipeline"

Best Practices - Messaggi Commit

❌ Messaggi cattivi:

git commit -m "fix"
git commit -m "update"
git commit -m "changes"
git commit -m "asdasd"

✅ Messaggi buoni:

git commit -m "Fix: corregge errore validazione email"
git commit -m "Feat: aggiungi autenticazione OAuth"
git commit -m "Docs: aggiorna README con setup Docker"
git commit -m "Refactor: migliora performance query database"

Formato consigliato:

Tipo: breve descrizione (max 50 caratteri)

Spiegazione dettagliata del perché e del come.
Puoi andare a capo e scrivere più righe.

- Punto 1
- Punto 2

Closes #123

Tipi comuni:

Feat: nuova funzionalità
Fix: correzione bug
Docs: documentazione
Style: formattazione (senza cambi logica)
Refactor: ristrutturazione codice
Test: aggiunta test
Chore: manutenzione, configurazione

Opzioni comuni

Opzione	Descrizione
`-m "msg"`	Messaggio inline
`-a`, `--all`	Commit tutti i file modificati
`--amend`	Modifica ultimo commit
`--allow-empty`	Permette commit vuoti
`-v`, `--verbose`	Mostra diff nel messaggio
`--no-verify`	Salta hook pre-commit

Note

Ogni commit ha hash SHA-1 univoco
Non modificare commit già pushati (problemi collaborazione)
Commit spesso, push meno spesso

`git status`

Sintassi

git status
git status [opzioni]

Spiegazione

Mostra lo stato del repository: file modificati, staged, non tracciati, branch corrente, stato rispetto al remote.

Esempi pratici

Status completo:

git status

Output esempio:

On branch main
Your branch is up to date with 'origin/main'.

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   src/app.py

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:   README.md

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

Status compatto:

git status -s
# oppure
git status --short

Output esempio:

M  src/app.py      # Staged (verde)
 M README.md       # Modified not staged (rosso)
?? config.ini      # Untracked (rosso)

Legenda:

?? = file non tracciato
M = modificato
A = aggiunto
D = eliminato
R = rinominato
Prima colonna = staged
Seconda colonna = working directory

Status con info branch:

git status -sb
# oppure
git status --short --branch

Quando usare git status

Prima di ogni operazione importante:

# Prima di commit
git status

# Prima di pull
git status

# Prima di cambio branch
git status

# Quando non ricordi cosa hai modificato
git status

Opzioni comuni

Opzione	Descrizione

Note

Comando safe, non modifica nulla
Usa spesso, anche 10+ volte al giorno
Aiuta a capire cosa succede nel repo

`git diff`

Sintassi

git diff [opzioni] [<commit>] [--] [<path>]

Spiegazione

Mostra le differenze tra varie versioni di file. Essenziale per vedere cosa è cambiato prima di fare commit.

Esempi pratici

Differenze working directory vs staged:

git diff

Mostra modifiche NON ancora in staging.

Differenze staged vs ultimo commit:

git diff --staged
# oppure
git diff --cached

Mostra cosa verrà committato.

Differenze working directory vs ultimo commit:

git diff HEAD

Differenze su file specifico:

git diff README.md
git diff --staged src/app.py

Differenze tra due commit:

git diff abc123 def456

Differenze tra branch:

git diff main develop
git diff main..develop  # equivalente

Differenze con remote:

git diff origin/main
git diff main origin/main

Statistiche modifiche:

git diff --stat

Output:

 README.md   | 10 +++++-----
 src/app.py  |  5 +++--
 2 files changed, 8 insertions(+), 7 deletions(-)

Differenze solo nomi file:

git diff --name-only
git diff --name-status  # con tipo modifica

Differenze con context limitato:

git diff -U1  # 1 riga di context invece di 3

Differenze ignorando whitespace:

git diff -w
# oppure
git diff --ignore-all-space

Output diff spiegato

diff --git a/README.md b/README.md
index abc123..def456 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Guida Git
 
 ## Setup
 
-Vecchia riga
+Nuova riga
 
 Riga non modificata

--- file vecchio
+++ file nuovo
- riga rimossa (rosso)
+ riga aggiunta (verde)
@@ posizione modifiche

Opzioni comuni

Opzione	Descrizione
`--staged`	Diff di staging
`--stat`	Statistiche
`--name-only`	Solo nomi file
`--name-status`	Nomi + tipo modifica
`-w`	Ignora whitespace
`-U<n>`	Context lines (default 3)
`--color-words`	Diff parola per parola

Note

Diff non modifica file, solo visualizza
Utile prima di git add e git commit
Combina con less: git diff | less

`git rm`

Sintassi

git rm <file>
git rm [opzioni] <file>

Spiegazione

Rimuove file dal repository Git. Elimina sia dal working directory che dall'index (staging).

Esempi pratici

Rimuovere file:

git rm file-obsoleto.txt
git commit -m "Rimuovi file obsoleto"

Rimuovere file solo dall'index (mantieni in working directory):

git rm --cached config.ini

Utile per file che non dovrebbero essere tracciati (aggiungi a .gitignore).

Rimuovere directory:

git rm -r vecchia-cartella/

Rimuovere file già eliminati manualmente:

# Hai fatto: rm file.txt
# Git non sa della rimozione
git rm file.txt
# oppure
git add file.txt  # funziona anche per rimozioni!

Forzare rimozione file modificati:

git rm -f file-modificato.txt

⚠️ Usa con cautela, perdi modifiche non committate.

Workflow corretto per rimuovere file

# 1. Rimuovi con git rm (NON rm normale)
git rm vecchio-file.txt

# 2. Verifica
git status

# 3. Commit rimozione
git commit -m "Rimuovi file non più necessario"

# 4. Push
git push origin main

Opzioni comuni

Opzione	Descrizione
`--cached`	Rimuovi solo da index
`-r`	Rimuovi directory ricorsivamente
`-f`, `--force`	Forza rimozione
`-n`, `--dry-run`	Simula senza rimuovere

Note

git rm ≠ rm (sistema operativo)
git rm fa staging automatico della rimozione
Per disfare: git restore --staged file poi git restore file

`git mv`

Sintassi

git mv <origine> <destinazione>

Spiegazione

Rinomina o sposta file mantenendo la cronologia Git. Equivale a: mv + git rm + git add.

Esempi pratici

Rinominare file:

git mv vecchio-nome.txt nuovo-nome.txt
git commit -m "Rinomina file per maggiore chiarezza"

Spostare file in altra directory:

git mv app.py src/app.py

Spostare directory:

git mv vecchia-dir/ nuova-dir/

Rinominare con maiuscole/minuscole (case-sensitive):

# Problema: README.md → readme.md (Git potrebbe non rilevare su filesystem case-insensitive)
# Soluzione:
git mv README.md temp.md
git mv temp.md readme.md

Workflow completo rinomina

# 1. Sposta/rinomina con git mv
git mv src/old-name.py src/new-name.py

# 2. Verifica
git status
# Output: renamed: src/old-name.py -> src/new-name.py

# 3. Commit
git commit -m "Rename: migliora naming del modulo"

# 4. Push
git push origin main

Confronto: git mv vs mv manuale

❌ Modo sbagliato (confusionario):

mv file.txt nuovo-file.txt
git rm file.txt
git add nuovo-file.txt

✅ Modo corretto:

git mv file.txt nuovo-file.txt

Opzioni comuni

Opzione	Descrizione
`-f`, `--force`	Forza spostamento
`-n`, `--dry-run`	Simula

Note

git mv mantiene cronologia del file
Git è smart: riconosce rename anche se usi mv + git add/rm
Utile per refactoring con cronologia pulita

🔗 Collegamenti

Precedente: ← Comandi Repository
Prossimo: Branching e Merging →
Indice: ← Torna all'indice

📝 Riepilogo comandi

# ADD
git add file.txt                # File specifico
git add .                       # Tutto dalla directory corrente
git add -A                      # Tutto il repository
git add -p                      # Interattivo

# COMMIT
git commit -m "messaggio"       # Commit con messaggio
git commit -am "messaggio"      # Add + commit file tracciati
git commit --amend              # Modifica ultimo commit

# STATUS
git status                      # Status completo
git status -s                   # Status compatto

# DIFF
git diff                        # Working vs staged
git diff --staged               # Staged vs commit
git diff HEAD                   # Working vs commit
git diff main develop           # Tra branch

# RM
git rm file.txt                 # Rimuovi file
git rm --cached file.txt        # Rimuovi solo da Git
git rm -r directory/            # Rimuovi directory

# MV
git mv old.txt new.txt          # Rinomina file
git mv file.txt dir/file.txt    # Sposta file