Come rimuovere file dai repository Git senza rompere il tuo progetto

Rimuovere file in Git non è sempre così semplice come sembra. Elimini un file dal tuo sistema, ma non significa che sia sparito dal repository. Potrebbe esistere ancora nella cronologia o, peggio, finire committato per errore, come un file di configurazione o una chiave API.

In questa guida imparerai a rimuovere file da Git. Partiremo da comandi di base come git rm, poi passeremo a metodi più avanzati come la pulizia dei file non tracciati e la modifica della cronologia dei commit.

Prerequisiti

Prima di rimuovere file con Git, assicuriamoci che tutto sia configurato correttamente.

Per prima cosa, verifica se Git è installato. Apri il terminale ed esegui:

git --version

Se vedi un numero di versione, sei a posto. 

Se vedi un numero di versione, sei a posto.

Puoi anche installare una GUI per Git come GitHub Desktop, Sourcetree o GitKraken se preferisci un'interfaccia visiva. Ma in questa guida userò la riga di comando (Git Bash).

Assicurati di avere i permessi per apportare modifiche al repository, soprattutto se fai parte di un team o lavori con un repo remoto come GitHub o GitLab.

Nota: alcune azioni di rimozione file non possono essere annullate. Quindi è una buona idea fare un backup del progetto o almeno ricontrollare lo stato del tuo repo prima di eseguire qualsiasi comando che elimini file.

Fatto questo, iniziamo.

Rimozione di base dei file in Git

Ci sono diversi modi per rimuovere file in Git, a seconda di ciò che vuoi fare. Vediamo alcune opzioni comuni:

Usare git rm

Il comando git rm rimuove i file dal tuo repository Git. Quando lo esegui, succedono due cose:

• Git rimuove il file dalla tua working directory
• Prepara (staging) quella modifica per il prossimo commit

Ma Git non si limita a cancellare il file. Registra l'eliminazione nella cronologia. Una volta effettuato il commit, il file è ufficialmente rimosso dal progetto.

git rm file1.txt

Puoi rimuovere un file, molti file o un gruppo di file usando i caratteri jolly. 

Per esempio, per rimuovere tutti i file di log:

git rm *.log

Questo dice a Git di rimuovere ogni file nella cartella che termina con .log. Puoi confermare la modifica usando:

git status

Elimina più file con un solo comando git rm. Immagine dell'autore.

Vuoi rimuovere tutti i file dentro una cartella ma non la cartella stessa? Usa:

git rm temp/*

Questo elimina ogni file dentro la cartella temp senza eliminare la cartella stessa.

Git aggiunge anche alcuni controlli di sicurezza. Se un file ha modifiche non ancora committate, Git non lo eliminerà a meno che tu non lo forzi. Quindi usa questo solo se sei sicuro che quelle modifiche possano essere scartate:

git rm -f

Per rimuovere un'intera cartella e tutto ciò che contiene, aggiungi il flag -r:

git rm -r testfolder

Questo rimuove testfolder e tutti i file al suo interno.

Ora, per effettuare il commit della modifica, esegui il seguente comando:

git commit -m "removed log files”

Opzioni chiave di git rm

Ecco le opzioni più comuni che userai con git rm:

1. <filename>

Questo è l'uso di base. Elenca semplicemente i file che vuoi rimuovere:

git rm file1.txt file2.txt

git rm *.txt

(Qui, * significa tutto. Corrisponde a qualsiasi nome file che termina con .txt.)

2. --cached

Questo rimuove il file dal repository ma lo lascia sul tuo computer. Mettiamo che io abbia aggiunto per sbaglio un file sensibile come config.env. Non lo voglio nel repo, ma mi serve ancora sulla mia macchina. Quindi eseguirei:

git rm --cached config.env

Qui, git rm lo eliminerebbe dal repository e dalla working directory. E --cached lo rende non tracciato da Git (così non verrà pushato), ma lo lascia fisicamente al suo posto.

Per evitare che venga aggiunto di nuovo, aggiungilo a .gitignore:

echo config.env >> .gitignore

3. -r

Sta per ricorsivo. Invece di un file, elimina ricorsivamente la directory e il suo contenuto. Senza questo, Git ti darà un errore se provi a rimuovere una cartella.

git rm -r <folder-name>

Qui ho creato una cartella chiamata testfolder e due file al suo interno: a.txt e b.txt. Poi eseguo il seguente comando:

git rm -r testfolder

Questo ha rimosso la cartella insieme a tutti i contenuti e ai file al suo interno

4. --dry-run

Se non sei sicuro di cosa succederà rimuovendo un file, usa git rm con l'opzione --dry-run così:

git rm --dry-run <filename>

È un modo sicuro per vedere in anteprima cosa verrà rimosso. 

Oppure, se stai ripulendo file non tracciati e vuoi ricontrollare cosa verrà rimosso, usa:

git clean -n

Questo mostrerà solo cosa eliminerebbe il comando.

Analisi comparativa dei workflow

C'è più di un modo per rimuovere un file in Git. I metodi possono sembrare uguali, ma non si comportano allo stesso modo.

git rm vs eliminazione manuale

Prendiamo un file chiamato file.txt. Diciamo che non mi serve più.

Un modo per rimuoverlo è eliminarlo direttamente dal sistema.

Su Linux, macOS o Git Bash:

rm file.txt

Su Windows (prompt dei comandi): 

del file.txt

Questo elimina il file dalla tua cartella. Ma Git ancora non lo sa. Quindi devi dire manualmente a Git che il file è stato rimosso:

git add file.txt

Questo prepara (stage) l'eliminazione in modo che sia inclusa nel prossimo commit.

Se hai eliminato diversi file e non li ricordi tutti, puoi eseguire:

git add -u

Questo prepara tutti i file tracciati che sono stati modificati o eliminati. Non includerà i file non tracciati.

Ora effettua il commit della modifica:

git commit -m "Remove file.txt"

Se usi git rm, gestisce tutto in un solo passaggio. Elimina il file e prepara subito la modifica:

git rm file.txtgit commit -m "Remove file.txt"

Non c'è bisogno di eseguire git add separatamente. È più pulito e non rischi di dimenticare di mettere in stage l'eliminazione.

In breve:

• L'eliminazione manuale richiede passaggi extra per assicurarti che Git rilevi la modifica.
• Se dimentichi di mettere in stage l'eliminazione, Git pensa ancora che il file esista, il che può causare confusione nei commit o nei merge.
• git rm è più pulito e sicuro quando vuoi rimuovere intenzionalmente file tracciati.

Ripristinare file eliminati in Git

E se elimini un file e poi ti accorgi che ti serve ancora? Nessun problema. Git ti offre diversi modi per recuperarlo, a seconda di quando noti l'errore.

Se non hai ancora fatto il commit:

Mettiamo che tu abbia eliminato il file ma non abbia ancora fatto il commit della modifica. Puoi ripristinarlo dall'ultimo commit così: 

git restore file.txt

Questo riporta il file nella tua working directory dall'ultimo commit.

Se hai già committato l'eliminazione:

Va bene anche così. Per prima cosa, trova l'ultimo commit in cui il file esisteva ancora:

git log -- file.txt

Scorri il log e copia l'hash del commit in cui il file era ancora presente. Poi esegui:

git checkout <commit hash> -- file.txt

Nelle versioni più vecchie di Git, potevi usare il comando qui sopra. Questo comando ripristina un file da uno specifico commit, ma poteva anche cambiare branch.

A partire da Git 2.23, è stato diviso in due comandi più chiari:

• git switch (per cambiare branch)
• git restore (per ripristinare file)

Se vuoi solo ripristinare un file da un commit, usa:

git restore --source=<commit-hash> --file.txt

Questo preleva il file da quel commit e lo rimette nella tua working directory.

Se non sei sicuro di quando il file è stato eliminato:

Magari hai fatto un sacco di modifiche e non ricordi quando è sparito il file. In questo caso, usa git reflog o reference log: 

git reflog

Questo mostra una cronologia completa dei tuoi commit, checkout, reset e tutto il resto.

Ma git reflog è solo locale e non funziona sui remoti. Se lavori con un repo remoto, è meglio usare git log -- file.txt per tracciare la cronologia di quel file.

Una volta trovato il punto in cui il file esisteva ancora, ripristinalo usando git checkout o git restore come prima.

Correggere file mancanti in Git

A volte i file vengono eliminati direttamente dal sistema—magari tramite un file explorer, un comando rm da terminale o anche per errore. Quando succede, Git non ripulisce automaticamente. Invece, contrassegna quei file come mancanti e aspetta che tu gestisca correttamente la rimozione.

Vediamo come affrontare questa situazione, passo dopo passo.

Passo 1: verifica i file mancanti

Esegui questo nella cartella del progetto:

git status

Se Git dice che un file è deleted, significa che è sparito dal tuo sistema, ma la modifica non è ancora in stage.

Passo 2: metti in stage l'eliminazione 

Per dire a Git di mettere in stage tutte le modifiche (inclusi i file eliminati), esegui:

git add -A

• git add -A = mette in stage tutte le modifiche (nuovi, modificati, eliminati).
• git add -u = mette in stage modificati + eliminati, ma non i nuovi file.

Questo mette in stage tutte le modifiche ai file: nuovi, modificati ed eliminati. Poi effettua il commit:

git commit -m "Removed missing files"

Questo è il modo più sicuro per ripulire perché cattura ogni modifica in un solo colpo.

Passo 3: fai push sul remoto 

Se lavori con un repository remoto, fai push del commit:

git push origin <branch-name>

Sostituisci <branch-name> con il branch di lavoro, come main o dev.

Passo 4: in alternativa

Mettiamo che tu abbia eliminato manualmente un mucchio di file, magari per errore o durante una pulizia. Git pensa ancora che quei file esistano finché non gli dici il contrario.

Se non vuoi rimuoverli uno per uno con git rm, c'è un modo più veloce per ripulire.

Esegui questo comando nel terminale:

git ls-files --deleted -z | xargs -0 git rm

Ecco cosa fa:

• git ls-files --deleted elenca tutti i file che Git sta tracciando ma che ora risultano mancanti.
• xargs -0 git rm passa quei nomi di file a git rm e li rimuove dall'indice di Git.

È molto utile quando lavori su un progetto grande e vuoi ripulire rapidamente.

Nota: ho ricevuto questo messaggio perché non ci sono file tracciati attualmente mancanti sul tuo disco.

Rimozione avanzata di file in Git

Ora che abbiamo visto le basi, vediamo situazioni più avanzate in cui rimuovere un file da Git non è così semplice come eseguire git rm. Sono casi in cui sono coinvolti dati sensibili o in cui bisogna ripulire con attenzione file non tracciati.

Rimuovere dati sensibili da Git

A volte un file con dati privati, come chiavi API o password, viene committato per errore. Eliminarlo normalmente non basta. Perché Git mantiene una cronologia completa, e il file esiste ancora nei commit precedenti.

Per cancellarlo completamente, puoi usare il comando git filter-repo: git filter-repo (consigliato)

È un'alternativa più nuova e migliore a filter-branch. È più veloce, sicura e facile da usare.

Per prima cosa, installalo (ti serviranno Python e pip):

pip install git-filter-repo

Poi esegui:

git filter-repo --path hide.txt --invert-paths

Questo rimuove il file hide.txt da ogni commit nella cronologia del tuo repo.

Per confermare, esegui:

git log --all -- supersecrets.txt

Se il file è sparito, aggiungilo a .gitignore così non viene tracciato di nuovo:

echo hide.txt >> .gitignore

Se lavori in team, pulisci la cronologia riscritta e forza il push delle modifiche:

git push origin --force --all

Poi avvisa i tuoi colleghi. Dovranno riclonare o resettare le copie locali per evitare errori.

Pulire i file non tracciati con git clean

Facciamo chiarezza:

• I file tracciati sono nella cronologia di Git. Per rimuoverli, usa git rm, poi fai il commit.
• I file non tracciati non sono affatto in Git. Possono accumularsi e appesantire il progetto.

Per eliminare file o cartelle non tracciati, usa git clean.

Ecco le opzioni più utili:

git clean -n     # Show which untracked files will be removedgit clean -nd    # Show which untracked folders will be removedgit clean -fd    # Delete all untracked files and folders. It is destructive.

Qui:

• -n significa solo anteprima.
• -f significa eliminazione forzata.
• -d include le cartelle nella pulizia.

Nota: git clean non tocca i file tracciati. Ma eliminerà qualsiasi cosa non tracciata, anche file che intendevi tenere. Quindi usa sempre prima -n per vedere cosa rimuoverà.

Rimozione file in GitHub e strumenti GUI

Finora abbiamo usato principalmente la riga di comando. Ma non tutti lavorano così ed è assolutamente ok. Alcuni sviluppatori usano strumenti visivi lavorando direttamente in GitHub.

Vediamo quindi come funziona l'eliminazione dei file nell'interfaccia web di GitHub e in altri strumenti GUI, e come si confronta con la riga di comando.

Eliminare file sul sito GitHub

Se lavori nell'interfaccia browser di GitHub, puoi eliminare file senza usare il terminale.

Ecco come funziona nell'interfaccia 2025:

1. Apri il file che vuoi eliminare.
2. Clicca sui tre puntini nell'angolo in alto a destra.
3. Scegli Delete file dal menu a discesa.

GitHub mostrerà quindi una casella per il messaggio di commit. Aggiungi un breve messaggio come:

Delete practice.py

Puoi anche scrivere una descrizione facoltativa.

Poi scegli come salvare la modifica:

• Fai il commit direttamente sul branch main
• Oppure crea un nuovo branch e apri una pull request (consigliato per i flussi di lavoro in team)

Clicca Commit changes e GitHub rimuoverà il file e salverà l'eliminazione come un commit, proprio come fa git rm dalla riga di comando.

Eliminare file con strumenti Git GUI

Se usi una GUI per Git come GitHub Desktop, Sourcetree o Tower, il processo è altrettanto semplice:

1. Elimina il file nel file explorer o all'interno dell'app.
2. L'app mostra l'eliminazione sotto “Changes” o “File Status”.
3. Rivedi, metti in stage e fai il commit della modifica.

Ogni strumento ha un aspetto leggermente diverso, ma il flusso è simile: tracci le modifiche in modo visivo e fai commit quando sei pronto.

Buone pratiche per piattaforma

Ecco uno sguardo rapido a come funziona l'eliminazione dei file sulle diverse piattaforme e quando ognuna è più utile:

• GitHub (Web): utile per correzioni rapide e piccoli aggiornamenti. Evitalo per grandi pulizie o file sensibili. 
• Strumenti Git GUI: ottimi per il lavoro quotidiano. Facile vedere le modifiche e fare commit in sicurezza. 
• Riga di comando: la più flessibile e potente. Ideale per attività avanzate come modifiche massicce o riscritture della cronologia. 

Buone pratiche per la rimozione di file in Git

Rimuovere file in Git può sembrare semplice, ma un passo falso può rompere il codice. Ecco alcuni consigli pratici che uso per assicurarmi che le eliminazioni siano sicure e controllate, soprattutto in progetti condivisi o a lungo termine.

Verifica sempre prima di eliminare

Prima di rimuovere un file, prenditi un minuto per confermare cosa fa:

• Esegui git status per vedere se è in stage o modificato.
• Usa git log -- <filename> per controllarne la cronologia dei commit.

Questo controllo rapido mi risparmia ore di recupero in seguito.

Usa commit atomici

Un commit atomico significa un commit per ogni modifica logica.

Per esempio, se sto eliminando file inutilizzati, faccio il commit solo di quelle eliminazioni, separatamente dalle modifiche al codice.

Ecco perché è molto utile:

• Il debug è più semplice. Strumenti come git bisect funzionano meglio quando i commit sono piccoli e focalizzati.
• La cronologia dei commit rimane pulita e chiara.
• Le code review sono più veloci.

Collabora con attenzione sulle riscritture della cronologia

Riscrivere la cronologia con strumenti come git filter-repo influenza tutti nel tuo team. Per evitare caos:

• Comunica prima di riscrivere branch condivisi.
• Usa git push --force con cautela perché riscrive la cronologia remota.
• Dì ai colleghi di riclonare o resettare i repo locali dopo.

Usa --dry-run prima di comandi distruttivi

Prima di eseguire un comando che elimina file, testalo sempre:

git clean -n

Questo mostra cosa verrebbe eliminato senza cancellare nulla. Ecco perché secondo me dovresti sempre farlo: 

• Ti evita di rimuovere file che in realtà vuoi tenere.
• È una rete di sicurezza, soprattutto in progetti grandi dove un singolo errore potrebbe cancellare log o file generati.

Combina git rm --cached con .gitignore

Se hai committato per sbaglio qualcosa che non dovrebbe stare nel repo (come un file di config o dei log), risolvi in due passaggi:

1. Smetti di tracciare il file:```git rm --cached <filename>

git rm --cached <filename>

Questo dice a Git di smettere di tracciare il file ma lo lascia sul tuo computer.

1. Aggiungilo a .gitignore:

echo <filename> >> .gitignore

Ecco perché è utile:

• Tiene fuori dal repo file sensibili o locali (come .env, .log o node_modules).
• Evita disordine nella cronologia di Git.
• Le modifiche future a quei file non genereranno più cambiamenti in Git.

Casi limite in Git: staging e cartelle vuote

A volte la rimozione dei file non va come previsto. Potresti mettere in stage il file sbagliato o avere problemi con cartelle vuote. 

Ecco come gestisco i casi limite più comuni.

Togliere dallo stage un file senza rimuovere le modifiche

Mettiamo che io esegua git add . e metta in stage per errore un file che non volevo. Non voglio perdere le modifiche—voglio solo toglierlo dallo stage.

Per sistemare, eseguo:

git reset HEAD <filename>

Questo toglie il file dallo stage ma mantiene le modifiche.

Per verificare, uso:

git status

Ora il file dovrebbe risultare "modified" invece di "staged".

Mantenere cartelle vuote nel repo

Per impostazione predefinita, Git ignora le cartelle vuote. Se provo a fare commit di una cartella senza file al suo interno, Git la salta.

Ma a volte voglio mantenere quella cartella nel repo, ad esempio per futuri log o upload. La soluzione comune è aggiungere un file segnaposto chiamato .gitkeep.

Ecco come:

touch logs/.gitkeepgit add logs/.gitkeepgit commit -m "Keep logs folder in the repo"

Questo rende la cartella "non vuota", così Git la traccia.

Nota: .gitkeep non è integrato in Git. È solo una convenzione. Puoi chiamare il file come vuoi, ma .gitkeep indica agli altri a cosa serve.

Risoluzione dei problemi nella rimozione di file Git

Ecco alcuni problemi comuni che mi sono capitati rimuovendo file in Git e come risolverli.

Il file appare ancora nel repository remoto

Hai eliminato il file, fatto il commit, ma è ancora sul repo remoto. Forse hai dimenticato di fare push.

Quindi assicurati di eseguire:

git push origin <branch-name>

Controlla anche:

• Sei sul branch corretto?
• Il tuo commit includeva davvero l'eliminazione del file?

Problemi con i submodule

I submodule sono repository Git dentro altri repository Git. Non si comportano come normali cartelle.

Se stai eliminando file dentro un submodule:

• Entra nella cartella del submodule
• Fai commit e push delle modifiche dall'interno di quel submodule

Se stai rimuovendo completamente il submodule:

• Elimina la cartella del submodule
• Rimuovi i riferimenti in .gitmodules e .git/config

Stato HEAD distaccato (detached)

In Git, HEAD di solito punta al branch corrente. Ma a volte punta a uno specifico commit: si chiama HEAD distaccato.

Succede se:

• Fai checkout di un commit tramite hash
• Passi a un tag
• Fai checkout di un branch remoto senza impostarlo come tracciato

Controlla lo stato:

git status

Se vedi:

HEAD detached at <commit-hash>

Non sei su un branch e qualsiasi nuova modifica potrebbe andare persa quando cambi.

Ecco come puoi risolvere: 

Se hai fatto modifiche e vuoi mantenerle, esegui:

git checkout -b <new-branch-name>

Questo mette il tuo lavoro su un nuovo branch e lo salva.

Se hai già committato le modifiche e vuoi spostarle su un altro branch più tardi, fai così:

git checkout -b temp-branch          # from detached HEADgit checkout main                    # or another target branchgit merge temp-branch

Se non hai fatto modifiche e vuoi solo uscire dall'HEAD distaccata, esegui:

git checkout <branch-name> 

Fatto. La tua HEAD ora è riattaccata e tutto torna normale.

Errori di permessi o di stato

A volte Git non riesce a eliminare un file, di solito su Windows. Può succedere se:

• Il file è aperto in un altro programma
• Git non ha i permessi per aggiornarlo

Ecco come risolvere:

• Chiudi tutte le app che usano il file
• Riavvia il terminale come Amministratore (su Windows)

Problemi di merge o rebase

Se vedi errori come:

• you are not currently on a branch
• merge conflict

Probabilmente sei nel mezzo di un merge o di un rebase.

Per terminare un rebase dopo aver risolto i conflitti:

git rebase --continue

Per annullare completamente rebase o merge:

git reset --merge

Questo ripristina il repo a com'era prima dell'inizio del merge.

Vuoi buttare via tutte le modifiche locali e resettare la working directory? 

Prova questo:

git restore .

Questo riporta tutti i file al loro stato dell'ultimo commit.

Considerazioni finali 

Quando rimuovi file in Git, è facile sbagliare se non stai attento. Un piccolo errore può portare a problemi più grandi: codice rotto, lavoro perso o confusione nel team. Per questo, prendi un attimo per ricontrollare quello che stai facendo.

Usa il comando giusto per la situazione. Se non sei sicuro di cosa farà, testalo prima con una dry run. E se lavori con altri, assicurati che tutti siano allineati.

Git può fare molto di più che eliminare file. Puoi eliminare branch,  annullare errori usando reset e revert o vedere esattamente cosa è cambiato con git diff. Più impari, più il tuo flusso di lavoro diventa fluido.

Fai un passo alla volta. È così che si diventa bravi in queste cose.