Come usare .gitignore: un’introduzione pratica con esempi

Sintassi di .gitignore

Come accennato, i file .gitignore contengono pattern che vengono confrontati con i nomi dei file nel tuo repository per determinare se debbano essere ignorati o meno.

Sintassi di base

Alla base, il file .gitignore è composto da righe, ognuna delle quali rappresenta un pattern da ignorare. I pattern possono corrispondere a:

• File specifici
• Tipi di file
• Directory 

Il file supporta anche i commenti, che si aggiungono iniziando una riga con #, e le righe vuote per migliorare la leggibilità.

Ecco una panoramica della struttura di base:

• Ignorare un file specifico: puoi elencare direttamente il nome del file per ignorarlo.

secrets.txt

• Ignorare un’intera directory: aggiungendo uno / alla fine del nome della directory, puoi ignorare tutto ciò che contiene.

logs/

• Ignorare tutti i file di un certo tipo: i jolly (*) possono essere usati per ignorare tutti i file con una specifica estensione.

*.py

• Negazione: puoi usare ! per negare un pattern e tracciare esplicitamente determinati file o directory che altrimenti verrebbero ignorati.

*.txt  # Ignores all .txt files
!readme.txt  # Except for readme.txt

Come creare e usare un file .gitignore

Creare e usare .gitignore è piuttosto semplice. In questa sezione ti guiderò attraverso i passaggi.

Creare un file .gitignore

Passaggio 1: vai alla radice del repository. Il file .gitignore si trova di solito nella directory radice di un progetto Git. Apri il terminale o la riga di comando e spostati nella directory radice del tuo repository Git:

cd /path/to/your/repo

Passaggio 2: crea il file .gitignore. Una volta nella directory radice, crea il file .gitignore usando un qualsiasi editor di testo o eseguendo un comando nel terminale, ad esempio:

touch .gitignore

Passaggio 3: aggiungi i pattern al file. Apri il file .gitignore in un editor di testo e aggiungi i pattern necessari per ignorare file o directory. Ogni riga rappresenta un pattern diverso.

Ecco un esempio di file .gitignore comunemente usato in un progetto di base:

# Ignore node_modules and dependency directories
node_modules/
vendor/

# Ignore build artifacts
dist/
build/
*.log

# Ignore system-generated files
.DS_Store
Thumbs.db

# Ignore environment and secret files
.env
config.json

Dopo aver aggiunto i pattern necessari, salva il file. D’ora in poi Git ignorerà automaticamente questi file quando metti in stage o esegui commit delle modifiche.

Passaggio 4: esegui il commit del file nel repository. È importante eseguire il commit del file .gitignore nel repository in modo che tutti i collaboratori usino le stesse regole di esclusione. Questo garantisce coerenza nel progetto per tutte le persone coinvolte.

git add .gitignore
git commit -m "Add .gitignore file"
git push

Una volta eseguito il commit del file .gitignore, stabilisci regole di esclusione condivise per tutto il team.

Vuoi padroneggiare push e pull in Git? Impara a sincronizzare il tuo lavoro con i repositori remoti in questo tutorial su git push e pull.

Best practice per usare .gitignore

Creare un file .gitignore è un passaggio semplice per mantenere pulito un repository Git, ma ci sono diverse best practice da seguire per gestirlo in modo efficace nel tempo.

Usa un .gitignore globale

Per gli sviluppatori che lavorano su più progetti, ci sono file specifici che potresti voler escludere da ogni repository, indipendentemente dal tipo di progetto.

Invece di aggiungerli al .gitignore di ciascun progetto, puoi configurare un .gitignore globale che si applica a tutti i repository sul tuo sistema.

Per configurare un file .gitignore globale:

• Crea un file .gitignore_global:

touch ~/.gitignore_global

• Aggiungi pattern per i file che vuoi ignorare globalmente, ad esempio:

.DS_Store
*.log
/.vscode/
/.idea/

• Imposta Git per usare il .gitignore globale:

git config --global core.excludesfile ~/.gitignore_global

Sfrutta i template esistenti

Invece di creare da zero un file .gitignore per ogni nuovo progetto, puoi sfruttare template .gitignore preconfigurati per linguaggi, framework o ambienti specifici.

Una delle migliori risorse per questi template è il repository ufficiale .gitignore di GitHub, dove puoi trovare file .gitignore pensati per centinaia di linguaggi di programmazione e framework.

Rivedi regolarmente il .gitignore

Man mano che i progetti evolvono, nuovi file e directory potrebbero dover essere inclusi nel file .gitignore. È importante rivedere e aggiornare periodicamente il file per riflettere lo stato attuale dei tuoi progetti.

Alcuni scenari in cui potresti dover aggiornare il file .gitignore includono:

• Adozione di nuovi strumenti o librerie che generano file aggiuntivi (ad es., passaggio a un nuovo sistema di build).
• Refactoring o riorganizzazione delle directory, che può produrre nuovi file da escludere.
• Rimozione di file o directory obsoleti che non fanno più parte del progetto.

Risoluzione dei problemi con .gitignore

Anche dopo aver configurato un file .gitignore, potresti imbatterti in situazioni in cui determinati file vengono tracciati o i pattern non sembrano funzionare come previsto. Questa sezione copre due aree comuni di troubleshooting e come risolverle.

File già confermati in tracking 

Il file .gitignore non si applica retroattivamente ai file già confermati. 

Se aggiungi un pattern a .gitignore dopo che certi file sono già stati confermati, Git continuerà a tracciarli anche se corrispondono al pattern nel file .gitignore.

Per interrompere il tracking di file già confermati, segui questi passaggi:

• Rimuovi i file dal tracking di Git: usa il comando git rm per rimuoverli dal repository mantenendoli nella tua working directory.

git rm --cached <file_or_directory_name>

• Esegui il commit delle modifiche: dopo aver rimosso i file dal tracking di Git, esegui il commit delle modifiche per assicurarti che i file non facciano più parte della cronologia del controllo versione.

git commit -m "Stop tracking ignored files"

• Esegui il push delle modifiche al repository remoto: infine, esegui il push delle modifiche al repository remoto per assicurarti che i file non siano più tracciati.

git push

Dopo questi passaggi, Git smetterà di tracciare i file. Il file confermato sarà ancora nella tua working directory ma verrà ignorato dai commit futuri in base ai tuoi pattern nel .gitignore.

Verificare che i pattern funzionino 

A volte potresti notare che determinati file che ti aspettavi venissero ignorati compaiono comunque nello status di Git o risultano tracciati. 

Segui questi passaggi per assicurarti che i tuoi pattern in .gitignore funzionino correttamente:

• Controlla lo stato dei file: usa il comando git status per vedere quali file sono tracciati da Git. Questo ti aiuterà a verificare se i file ignorati sono ancora elencati.

git status

• Assicurati che il pattern sia corretto: ricontrolla la sintassi dei tuoi pattern in .gitignore per accertarti che siano formattati correttamente. Ad esempio:
• Assicurati di usare il percorso di directory corretto (relativo alla radice del repository).
• Aggiungi uno / per indirizzare directory specifiche ed evitare di tracciare tutti i file con nomi simili.

• Aggiorna la cache: se hai aggiornato di recente il tuo file .gitignore e le modifiche non vengono applicate, è possibile che Git stia mantenendo la cache precedente. Per aggiornarla, esegui il seguente comando:

git rm -r --cached .
git add .
git commit -m "Refresh .gitignore"

• Controlla le eccezioni: a volte un pattern specifico in .gitignore può essere sovrascritto da un pattern più specifico altrove nel file. Rivedi le tue regole per assicurarti che non ci siano pattern in conflitto.

Cerchi un riferimento rapido a Git? Tieni i comandi essenziali a portata di mano con questo cheat sheet di Git.

Conclusione

Un file .gitignore può sembrare piccolo, ma svolge un ruolo enorme nel mantenere il tuo repository Git pulito e gestibile. Ignorando i file non necessari—come dipendenze, artefatti di build e file generati dal sistema—mantieni il progetto organizzato e privo di ingombro.

In questo tutorial hai imparato a creare un file .gitignore, ad aggiungere pattern e ad applicare le best practice per mantenere efficiente il tuo repo. Con queste competenze eviterai grattacapi con il controllo versione e renderai la collaborazione più fluida per tutto il team.

Se vuoi approfondire le tue competenze con Git, dai un’occhiata a Git Fundamentals per un percorso di apprendimento strutturato. Puoi anche esplorare corsi pratici come Foundations of Git e Introduction to GitHub Concepts per costruire una solida comprensione del controllo versione e dei flussi di lavoro collaborativi!