git clean

Cosa fa git clean

Il comando git clean rimuove i file non tracciati dalla directory di lavoro. Un file non tracciato è un file che esiste sul disco ma che Git non sta ancora seguendo, ovvero non è mai stato aggiunto con git add e non è presente nell'indice.

Questo distingue git clean dagli altri comandi per annullare le modifiche:

• git reset sposta la punta del branch e può rimuovere dalla staging area le modifiche tracciate.
• git checkout ripristina i file tracciati a uno stato precedente.
• git clean elimina i file che Git non traccia affatto.

Insieme coprono l'intero albero di lavoro: reset/checkout gestiscono i contenuti tracciati e in staging, clean gestisce tutto il resto. Un uso tipico è eliminare gli artefatti di build, i file generati o i residui di esperimenti, così da ripartire da una copia pulita dell'albero sottoposto a commit.

git clean è irreversibile. Elimina i file direttamente dal file system, senza spostarli in un'area recuperabile come lo stash. Non esiste un'operazione di annullamento per git clean. Esegui sempre un'anteprima con un dry run (-n) prima.

L'esempio seguente configura un repository con un elemento tracciato e diversi elementi non tracciati per mostrare la distinzione:

Configurare un repository di esempio

mkdir test_directory
cd test_directory/
git init .
#Initialized empty Git repository in /Users/kev/code/test_directory/.git/
echo "tracked file" > ./test_tracked_file
git add ./test_tracked_file
echo "untracked" > ./test_untracked_file
mkdir ./test_untracked_dir && touch ./test_untracked_dir/file
git status
#On branch master
#No commits yet
#Changes to be committed:
#  (use "git rm --cached <file>..." to unstage)
#        new file:   test_tracked_file
#Untracked files:
#  (use "git add <file>..." to include in what will be committed)
#        test_untracked_dir/
#        test_untracked_file

Dopo aver eseguito questo codice hai un repository nuovo con un file in staging, test_tracked_file, più un file non tracciato (test_untracked_file) e una directory non tracciata (test_untracked_dir). git status li mostra in sezioni separate, esattamente la distinzione di cui git clean tiene conto. Tutto ciò che segue opera su questo repository.

Perché è richiesto il force

Esegui il comando senza opzioni e Git rifiuta:

git clean
#fatal: clean.requireForce defaults to true and neither -i, -n, nor -f given; refusing to clean

Poiché l'eliminazione è permanente, Git non viene eseguito a meno che tu non utilizzi esplicitamente -f (force), -n (dry run) o -i (interactive). Puoi modificare il valore predefinito con l'impostazione git config clean.requireForce, ma lasciarlo attivo è la scelta più sicura.

Opzioni e utilizzo comuni

Il comportamento di git clean è controllato quasi interamente da un insieme di flag brevi, che si combinano liberamente.

-n: dry run (anteprima)

Il flag -n (o --dry-run) elenca ciò che verrebbe rimosso senza eliminare nulla. Rendilo il tuo primo passo predefinito.

git clean -n
#Would remove test_untracked_file

L'output nomina test_untracked_file. Nota che la directory non tracciata non è elencata, perché per impostazione predefinita git clean ignora le directory (vedi -d di seguito).

-f: forza l'eliminazione

Il flag -f (o --force) esegue effettivamente l'eliminazione. È obbligatorio a meno che clean.requireForce non sia impostato su false.

git clean -f
#Removing test_untracked_file

test_untracked_file è ora eliminato; un successivo git status non lo elenca più. Per impostazione predefinita git clean -f agisce su ogni file non tracciato nella directory corrente. I file corrispondenti a .gitignore vengono lasciati intatti a meno che non si aggiunga -x (di seguito).

Per limitare l'operazione a una posizione specifica, passa un percorso:

git clean -f path/to/dir

-d: include le directory non tracciate

Per impostazione predefinita git clean salta le directory non tracciate. Aggiungi -d per rimuoverle anch'esse. Combinalo con -n per un'anteprima, poi con -f per confermare:

git clean -dn
#Would remove test_untracked_dir/
#Would remove test_untracked_file
git clean -df
#Removing test_untracked_dir/
#Removing test_untracked_file

Con -d il dry run elenca ora anche la directory oltre al file non tracciato, e l'esecuzione forzata rimuove entrambi, eliminando la directory e tutto il suo contenuto.

-x: include i file ignorati

Normalmente git clean rispetta .gitignore. Il flag -x gli dice di eliminare anche i file ignorati, come node_modules/, l'output di build o cartelle dell'editor come .idea/. Questa opzione è potente e facile da usare con rimpianto, quindi esegui sempre prima un dry run.

git clean -xn
#Would remove .idea/
#Would remove build/

-x si combina con gli altri flag. La combinazione seguente elimina in un'unica operazione i file non tracciati, le directory non tracciate e i file ignorati, equivalente a "ripristina questo checkout esattamente a ciò che è stato sottoposto a commit":

git clean -xdf

Riferimento rapido

Modalità interattiva

Se non sei sicuro di cosa dovrebbe essere rimosso, esegui git clean in modalità interattiva con il flag -i. È il modo più sicuro per pulire un albero di lavoro disordinato, perché nulla viene eliminato fino alla tua conferma. L'esempio seguente aggiunge anche -d in modo da includere le directory. Git mostra gli elementi candidati e poi un prompt What now> con sei comandi:

git clean -di
#Would remove the following items:
#  test_untracked_dir/ test_untracked_file
#*** Commands ***
#    1: clean                2: filter by pattern    3: select by numbers
#    4: ask each             5: quit                 6: help
#What now>

Ecco cosa fa ciascun comando.

6 — help. Digita 6 per stampare una descrizione di ogni comando:

What now> 6
#clean               - start cleaning files and directories
#filter by pattern   - exclude items from deletion
#select by numbers   - select items to be deleted by numbers
#ask each            - confirm each deletion (like "rm -i")
#quit                - stop cleaning
#help                - this screen
#?                   - help for prompt selection

1 — clean. Elimina gli elementi attualmente elencati, poi esce:

What now> 1
#Removing test_untracked_dir/
#Removing test_untracked_file

2 — filter by pattern. Permette di escludere elementi tramite glob. Qui il pattern *_file rimuove test_untracked_file dall'elenco di eliminazione, lasciando in coda solo la directory:

What now> 2
#test_untracked_dir/ test_untracked_file
#Input ignore patterns>> *_file
#test_untracked_dir/

3 — select by numbers. Raffina l'elenco per numero di elemento anziché per pattern. Git numera ogni candidato e tu digiti quelli da mantenere:

What now> 3
#           1: test_untracked_dir/  2: test_untracked_file
#Select items to delete>>

4 — ask each. Scorre ogni candidato con un prompt y/N, come rm -i. Rispondi N per mantenere un elemento:

What now> 4
#Remove test_untracked_dir/ [y/N]? N
#Remove test_untracked_file [y/N]? N

5 — quit. Esce dalla modalità interattiva senza eliminare nulla:

What now> 5
#Bye.

git clean vs. stash e reset

git clean agisce solo sui file non tracciati, quindi usalo quando vuoi scartare il lavoro piuttosto che salvarlo. Se potresti voler recuperare le modifiche in seguito, preferisci una di queste alternative:

• git stash — mette da parte le modifiche tracciate (e, con -u, i file non tracciati) così puoi ripristinarle in seguito. Reversibile.
• git reset — sposta la punta del branch e rimuove dalla staging area o scarta le modifiche tracciate.
• git checkout — ripristina i file tracciati al loro stato sottoposto a commit.

Un reset completo comune di un albero di lavoro consiste nel combinare reset per i contenuti tracciati e clean per quelli non tracciati:

git reset --hard   # discard tracked changes
git clean -xdf     # remove untracked and ignored files

Dopo questi due comandi la directory di lavoro corrisponde esattamente all'ultimo commit, senza file residui di alcun tipo.

Esercitazione