Come ignorare file e directory in Git con .gitignore

Introduzione

Spesso, quando si lavora su un progetto che utilizza Git, è necessario escludere file o directory specifici dall'invio al repository remoto.

Il file .gitignore viene utilizzato per specificare quali file non tracciati devono essere ignorati da Git.

File .gitignore

I file ignorati sono generalmente file specifici della piattaforma o file creati automaticamente dai sistemi di compilazione. Alcuni esempi comuni includono:

File di runtime come log, lock, cache o file temporanei.
File con informazioni riservate, come password o chiavi API.
Codice compilato, come .class o .o.
Directory delle dipendenze, come /vendor o /node_modules.
Directory di compilazione, come ad esempio /public, /out o /dist.
File di sistema come .DS_Store o Thumbs.db
File di configurazione di IDE o dell'editor di testo .

Un file .gitignore è un file di testo semplice in cui ogni riga contiene un modello da ignorare per file o directory.

.gitignore usa schemi di globbing per abbinare nomi di file e caratteri wildcard. Se hai file o directory contenenti un modello wildcard, puoi usare una singola barra rovesciata (\) come carattere di escape.

Commenti

Le righe che iniziano con un segno di cancelletto (#) sono commenti e vengono ignorate. Le righe vuote possono essere utilizzate per migliorare la leggibilità del file e per raggruppare le relative linee di modelli.

Slash

Il simbolo della barra (/) rappresenta un separatore di directory. La barra all'inizio di un modello è relativa alla directory in cui risiede .gitignore.

Se il modello inizia con una barra, corrisponde ai file e alle directory solo nella root del repository.

Se il modello non inizia con una barra, corrisponde a file e directory in qualsiasi directory o sottodirectory.

Se il modello termina con una barra, corrisponde solo alle directory. Quando una directory viene ignorata, vengono ignorati anche tutti i suoi file e le sue sottodirectory.

Nomi di file letterali

Il modello più semplice è un nome file letterale senza caratteri speciali.

Pattern	Example matches
`/access.log`	`access.log`
`access.log`	`access.log` `logs/access.log` `var/logs/access.log`
`build/`	`build`

Simboli Wildcard

* - Il simbolo dell'asterisco corrisponde a zero o più caratteri.

Pattern	Example matches
`*.log`	`error.log` `logs/debug.log` `build/logs/error.log`

**- Due simboli di asterisco adiacenti corrispondono a qualsiasi file o zero o più directory. Quando seguito da una barra ( /), corrisponde solo alle directory.

Pattern	Example matches
`logs/**`	Matches anything inside the `logs` directory.
`**/build`	`var/build` `pub/build` `build`
`foo/**/bar`	`foo/bar` `foo/a/bar` `foo/a/b/c/bar`

? - Il punto interrogativo corrisponde a qualsiasi singolo carattere.

Pattern	Example matches
`access?.log`	`access0.log` `access1.log` `accessA.log`
`foo??`	`fooab` `foo23` `foo0s`

Parentesi quadre

[...]- Corrisponde a uno qualsiasi dei caratteri racchiusi tra parentesi quadre. Quando due caratteri sono separati da un trattino - indica un intervallo di caratteri. L'intervallo include tutti i caratteri che si trovano tra quei due caratteri. Gli intervalli possono essere alfabetici o numerici.

Se il primo carattere che segue [ è un punto esclamativo (!), il modello corrisponde a qualsiasi carattere tranne quelli dell'insieme specificato.

Pattern	Example matches
`*.[oa]`	`file.o` `file.a`
`*.[!oa]`	`file.s` `file.1` `file.0`
`access.[0-2].log`	`access.0.log` `access.1.log` `access.2.log`
`file.[a-c].out`	`file.a.out` `file.b.out` `file.c.out`
`file.[a-cx-z].out`	`file.a.out` `file.b.out` `file.c.out` `file.x.out` `file.y.out` `file.z.out`
`access.[!0-2].log`	`access.3.log` `access.4.log` `access.Q.log`

Pattern negativi

Un modello che inizia con un punto esclamativo (!) annulla (re-include) qualsiasi file che viene ignorato dal modello precedente. L'eccezione a questa regola è quella di includere nuovamente un file se la sua directory padre è esclusa.

Pattern	Example matches
`*.log` `!error.log`	`error.log` or `logs/error.log` will not be ignored

Esempio

Di seguito è riportato un esempio di come .gitignore potrebbe apparire:

# Ignore the node_modules directory
node_modules/

# Ignore Logs
logs
*.log

# Ignore the build directory
/dist

# The file containing environment variables 
.env

# Ignore IDE specific files
.idea/
.vscode/
*.sw*

File .gitignore Locale

Un file locale .gitignore viene generalmente inserito nella directory principale del repository. Tuttavia, è possibile creare più file .gitignore in diverse sottodirectory nel proprio repository. I modelli nei file .gitignore sono abbinati rispetto alla directory in cui risiede il file.

I pattern definiti nei file che risiedono in directory di livello inferiore (sottodirectory) hanno la precedenza su quelli nelle directory di livello superiore.

I file locali .gitignore sono condivisi con altri sviluppatori e devono contenere schemi utili per tutti gli altri utenti del repository.

Regole personali

I pattern specifici per il proprio repository locale e che non devono essere distribuiti ad altri repository, devono essere impostati nel file .git/info/exclude.

Ad esempio, è possibile utilizzare questo file per ignorare i file generati dagli strumenti di progetto personali.

File .gitignore Globale

Git ti consente anche di creare un file globale .gitignore, dove puoi definire le regole di ignorare per ogni repository Git sul tuo sistema locale.

Il file può essere nominato come preferisci e archiviato in qualsiasi posizione. Il posto più comune per conservare questo file è la home directory. Dovrai creare manualmente il file e configurare Git per usarlo.

Ad esempio, per impostare ~/.gitignore_global come file Git globale da ignorare, si dovrebbe fare quanto segue:

Crea il file:

touch ~/.gitignore_global

Aggiungi il file alla configurazione di Git:

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

Apri il file con il tuo editor di testo e aggiungi le tue regole.

Le regole globali sono particolarmente utili per ignorare determinati file che non si desidera mai eseguire il commit, ad esempio file con informazioni riservate o file eseguibili compilati.

Ignorare un file sottoposto a commit

I file nella copia di lavoro possono essere tracciati o non tracciati.

Per ignorare un file che è stato precedentemente sottoposto a commit, è necessario procedere con il comando unstage e rimuovere il file dall'indice, quindi aggiungere una regola per il file in .gitignore:

git rm --cached filename

L'opzione --cached permette di non cancellare il file dall'albero di lavoro ma solo di rimuoverlo dall'indice.

Per rimuovere ricorsivamente una directory, utilizzare l'opzione -r:

git rm --cached filename

Se si desidera rimuovere il file sia dall'indice che dal filesystem locale, omettere l'opzione --cached.

Quando si eliminano i file in modo ricorsivo, utilizzare l'opzione -n che eseguirà un "ciclo di prova" e mostrerà quali file verranno eliminati:

git rm -r -n directory

File .gitignore di debug

A volte può essere difficile determinare il modello per cui un file specifico viene ignorato, soprattutto quando si utilizzano più file .gitignore o schemi complessi. In questo caso risulta utile il comando git check-ignore con l'opzione -v che permette di visualizzare i dettagli sul modello di corrispondenza.

Ad esempio, per verificare il modello per cui il file www/yarn.lock viene ignorato, è necessario eseguire:

git check-ignore -v www/yarn.lock

L'output mostra il percorso del file gitignore, il numero della linea corrispondente e il modello effettivo.

www/.gitignore:31:/yarn.lock	www/yarn.lock

Il comando accetta anche più di un nome file come argomenti e il file non deve esistere nel tuo albero di lavoro.

Visualizzare tutti i file ignorati

Il comando status con l'opzione --ignored visualizza un elenco di tutti i file ignorati:

git status --ignored

Conclusione

Il file .gitignore consente di escludere i file dal controllo nel repository. Il file che contiene schemi globbing che descrivono quali file e directory deve essere ignorato.

gitignore.io è un servizio online che ti consente di generare file .gitignore per il tuo sistema operativo, linguaggio di programmazione o IDE.