Git
Ignorare file e cartelle

introduzione

Ignorare file e directory con un file .gitignore

Puoi fare in modo che Git ignori determinati file e directory, ovvero li escluda dal tracciamento di Git, creando uno o più file .gitignore nel tuo repository.

Nei progetti software, .gitignore contiene in genere un elenco di file e / o directory generati durante il processo di creazione o in fase di esecuzione. Le voci nel file .gitignore possono includere nomi o percorsi che puntano a:

1. risorse temporanee come cache, file di registro, codice compilato, ecc.
2. file di configurazione locali che non dovrebbero essere condivisi con altri sviluppatori
3. file contenenti informazioni segrete, come password di accesso, chiavi e credenziali

Quando vengono create nella directory di livello superiore, le regole si applicano in modo ricorsivo a tutti i file e sottodirectory in tutto il repository. Quando vengono creati in una sottodirectory, le regole si applicano a quella specifica directory e alle sue sottodirectory.

Quando un file o una directory viene ignorata, non sarà:

1. monitorato da Git
2. segnalato da comandi come git status o git diff
3. messo in scena con comandi come git add -A

Nel caso insolito che è necessario ignorare i file tracciati, prestare particolare attenzione. Vedi: Ignora i file che sono già stati impegnati in un repository Git .

Esempi

Ecco alcuni esempi generici di regole in un file .gitignore , basato su modelli di file glob :

# Lines starting with `#` are comments.

# Ignore files called 'file.ext'
file.ext

# Comments can't be on the same line as rules!
# The following line ignores files called 'file.ext # not a comment'
file.ext # not a comment 

# Ignoring files with full path.
# This matches files in the root directory and subdirectories too.
# i.e. otherfile.ext will be ignored anywhere on the tree.
dir/otherdir/file.ext
otherfile.ext

# Ignoring directories
# Both the directory itself and its contents will be ignored.
bin/
gen/

# Glob pattern can also be used here to ignore paths with certain characters.
# For example, the below rule will match both build/ and Build/
[bB]uild/

# Without the trailing slash, the rule will match a file and/or
# a directory, so the following would ignore both a file named `gen`
# and a directory named `gen`, as well as any contents of that directory
bin
gen

# Ignoring files by extension
# All files with these extensions will be ignored in
# this directory and all its sub-directories.
*.apk
*.class

# It's possible to combine both forms to ignore files with certain
# extensions in certain directories. The following rules would be
# redundant with generic rules defined above.
java/*.apk
gen/*.class

# To ignore files only at the top level directory, but not in its
# subdirectories, prefix the rule with a `/`
/*.apk
/*.class

# To ignore any directories named DirectoryA 
# in any depth use ** before DirectoryA
# Do not forget the last /, 
# Otherwise it will ignore all files named DirectoryA, rather than directories
**/DirectoryA/
# This would ignore 
# DirectoryA/
# DirectoryB/DirectoryA/ 
# DirectoryC/DirectoryB/DirectoryA/
# It would not ignore a file named DirectoryA, at any level

# To ignore any directory named DirectoryB within a 
# directory named DirectoryA with any number of 
# directories in between, use ** between the directories
DirectoryA/**/DirectoryB/
# This would ignore 
# DirectoryA/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryW/DirectoryB/

# To ignore a set of files, wildcards can be used, as can be seen above.
# A sole '*' will ignore everything in your folder, including your .gitignore file.
# To exclude specific files when using wildcards, negate them.
# So they are excluded from the ignore list:
!.gitignore 

# Use the backslash as escape character to ignore files with a hash (#)
# (supported since 1.6.2.1)
\#*#

La maggior parte dei file .gitignore sono standard in varie lingue, quindi per iniziare, ecco un insieme di file .gitignore di esempio elencati per lingua da cui clonare o copiare / modificare nel progetto. In alternativa, per un nuovo progetto si può considerare la generazione automatica di un file di avviamento utilizzando uno strumento online .

Altre forme di .gitignore

.gitignore file .gitignore sono destinati al commit come parte del repository. Se si desidera ignorare determinati file senza applicare le regole di ignoranza, ecco alcune opzioni:

• Modifica il file .git/info/exclude (usando la stessa sintassi di .gitignore ). Le regole saranno globali nell'ambito del repository;
• Imposta un file gitignore globale che applicherà le regole di ignoranza a tutti i tuoi repository locali:

Inoltre, puoi ignorare le modifiche locali ai file tracciati senza modificare la configurazione git globale con:

• git update-index --skip-worktree [<file>...] : per modifiche locali minori
• git update-index --assume-unchanged [<file>...] : per file pronti per la produzione, non modificabili a monte

Vedi maggiori dettagli sulle differenze tra questi ultimi flag e la documentazione di git update-index per ulteriori opzioni.

Pulizia dei file ignorati

Puoi usare git clean -X per ripulire i file ignorati:

git clean -Xn #display a list of ignored files
git clean -Xf #remove the previously displayed files

Nota: -X (cappucci) pulisce solo i file ignorati. Usa -x (senza maiuscole) per rimuovere anche i file non tracciati.

Vedi la documentazione git clean per maggiori dettagli.

Vedi il manuale di Git per maggiori dettagli.

Eccezioni in un file .gitignore

Se ignori i file utilizzando un pattern ma hai delle eccezioni, aggiungi un punto esclamativo (!) All'eccezione. Per esempio:

*.txt
!important.txt

L'esempio sopra indica a Git di ignorare tutti i file con estensione .txt tranne i file con nome important.txt .

Se il file si trova in una cartella ignorata, NON puoi ri-includerlo così facilmente:

folder/
!folder/*.txt

In questo esempio tutti i file .txt nella cartella rimarrebbero ignorati.

Il modo giusto è ri-includere la cartella stessa su una riga separata, quindi ignorare tutti i file nella folder con * , infine ri-includere il file *.txt nella folder , come segue:

!folder/
folder/*
!folder/*.txt

Nota : per i nomi di file che iniziano con un punto esclamativo, aggiungere due punti esclamativi o uscire con il carattere \ :

!!includethis
\!excludethis

Un file .gitignore globale

Per fare in modo che Git ignori determinati file in tutti i repository, puoi creare un .gitignore globale con il seguente comando nel tuo terminale o prompt dei comandi:

$ git config --global core.excludesfile <Path_To_Global_gitignore_file>

Git ora userà questo in aggiunta al file .gitignore di ciascun repository. Le regole per questo sono:

• Se il file .gitignore locale include esplicitamente un file mentre il globale .gitignore ignora, il file .gitignore locale ha la priorità (il file sarà incluso)
• Se il repository è clonato su più macchine, allora il globale .gigignore deve essere caricato su tutte le macchine o almeno includerlo, poiché i file ignorati verranno .gigignore al repository mentre il PC con il global .gitignore non lo aggiornerà . Questo è il motivo per cui un .gitignore repository specifico è un'idea migliore di quella globale se il progetto viene elaborato da un team

Questo file è un buon posto per mantenere ignori specifici della piattaforma, della macchina o dell'utente, ad es. OSX .DS_Store , Windows Thumbs.db o Vim *.ext~ e *.ext.swp ignora se non si desidera mantenere quelli nel repository . Quindi un membro del team che lavora su OS X può aggiungere tutti .DS_STORE e _MACOSX (che in realtà è inutile), mentre un altro membro del team su Windows può ignorare tutti i thumbs.bd

Ignora i file che sono già stati impegnati in un repository Git

Se hai già aggiunto un file al tuo repository Git e ora vuoi smettere di seguirlo (in modo che non sia presente in future commit), puoi rimuoverlo dall'indice:

git rm --cached <file>

Questo rimuoverà il file dal repository e impedirà che ulteriori tracce vengano tracciate da Git. L'opzione --cached farà in modo che il file non venga cancellato fisicamente.

Nota che i contenuti aggiunti in precedenza del file saranno ancora visibili tramite la cronologia di Git.

Tieni presente che se qualcun altro preleva dal repository dopo aver rimosso il file dall'indice, la sua copia verrà eliminata fisicamente .

Puoi far credere a Git che la versione di directory di lavoro del file sia aggiornata e leggere invece la versione dell'indice (ignorando così le modifiche) con il bit " skip worktree ":

git update-index --skip-worktree <file>

La scrittura non è influenzata da questo bit, la sicurezza del contenuto è ancora la priorità principale. Non perderete mai i vostri preziosi cambiamenti ignorati; d'altra parte questo bit è in conflitto con la memorizzazione: per rimuovere questo bit, usare

git update-index --no-skip-worktree <file>

A volte è erroneamente consigliato mentire a Git e presumere che il file sia immutato senza esaminarlo. A prima vista sembra ignorare qualsiasi ulteriore modifica al file, senza rimuoverlo dal suo indice:

git update-index --assume-unchanged <file>

Ciò costringerà git a ignorare qualsiasi modifica apportata al file (tieni presente che se si apportano modifiche a questo file o se lo si archivia, le modifiche ignorate andranno perse )

Se vuoi che git "ripensi" a questo file, esegui il seguente comando:

git update-index --no-assume-unchanged <file>

Verifica se un file è ignorato

Il comando git check-ignore riporta su file ignorati da Git.

È possibile passare nomi di file sulla riga di comando e git check-ignore elencherà i nomi file che vengono ignorati. Per esempio:

$ cat .gitignore
*.o
$ git check-ignore example.o Readme.md
example.o

Qui, solo i file * .o sono definiti in .gitignore, quindi Readme.md non è elencato nell'output di git check-ignore .

Se vuoi vedere la riga di cui .gitignore è responsabile per ignorare un file, aggiungi -v al comando git check-ignore:

$ git check-ignore -v example.o Readme.md
.gitignore:1:*.o        example.o

Da Git 1.7.6 in poi è anche possibile utilizzare lo git status --ignored per vedere i file ignorati. Puoi trovare maggiori informazioni al riguardo nella documentazione ufficiale o in Ricerca di file ignorati da .gitignore .

Ignorare i file nelle sottocartelle (più file gitignore)

Supponiamo di avere una struttura di repository come questa:

examples/
    output.log
src/
    <files not shown>
    output.log
README.md

output.log nella directory output.log è valido e richiesto per il progetto per ottenere una comprensione mentre quello al di sotto di src/ viene creato durante il debug e non deve essere nella cronologia o parte del repository.

Esistono due modi per ignorare questo file. È possibile posizionare un percorso assoluto nel file .gitignore directory principale della directory di lavoro:

# /.gitignore
src/output.log

In alternativa, puoi creare un file .gitignore nella directory src/ e ignorare il file relativo a questo .gitignore :

# /src/.gitignore
output.log

Ignorare un file in qualsiasi directory

Per ignorare un file foo.txt in qualsiasi directory devi solo scrivere il suo nome:

foo.txt # matches all files 'foo.txt' in any directory

Se si desidera ignorare il file solo in una parte dell'albero, è possibile specificare le sottodirectory di una directory specifica con ** pattern:

bar/**/foo.txt # matches all files 'foo.txt' in 'bar' and all subdirectories

Oppure puoi creare un file .gitignore nella bar/ directory. Equivalente al precedente esempio sarebbe la creazione di file bar/.gitignore con questi contenuti:

foo.txt # matches all files 'foo.txt' in any directory under bar/

Ignora localmente i file senza applicare le regole di ignoranza

.gitignore ignora i file localmente, ma è destinato ad essere impegnato nel repository e condiviso con altri contributori e utenti. È possibile impostare un .gitignore globale, ma tutti i repository condivideranno tali impostazioni.

Se vuoi ignorare determinati file in un repository localmente e non rendere il file parte di alcun repository, modifica .git/info/exclude nel tuo repository.

Per esempio:

# these files are only ignored on this repo
# these rules are not shared with anyone
# as they are personal                                              
gtk_tests.py
gui/gtk/tests/*
localhost
pushReports.py
server/

Modelli con prefigura .gitignore

Se non si è sicuri delle regole da elencare nel file .gitignore o si desidera semplicemente aggiungere eccezioni generalmente accettate al progetto, è possibile scegliere o generare un file .gitignore :

• https://www.toptal.com/developers/gitignore
• https://github.com/github/gitignore

Molti servizi di hosting come GitHub e BitBucket offrono la possibilità di generare file .gitignore basati sui linguaggi di programmazione e sugli IDE che potresti utilizzare:

Ignorare le modifiche successive a un file (senza rimuoverlo)

A volte vuoi avere un file in Git ma ignorare le modifiche successive.

Dì a Git di ignorare le modifiche a un file o a una directory usando update-index :

git update-index --assume-unchanged my-file.txt

Il comando precedente indica a Git di assumere my-file.txt non è stato modificato e di non controllare o segnalare le modifiche. Il file è ancora presente nel repository.

Questo può essere utile per fornire valori predefiniti e consentire l'override dell'ambiente locale, ad esempio:

# create a file with some values in
cat <<EOF
MYSQL_USER=app
MYSQL_PASSWORD=FIXME_SECRET_PASSWORD
EOF > .env

# commit to Git
git add .env
git commit -m "Adding .env template"

# ignore future changes to .env
git update-index --assume-unchanged .env

# update your password
vi .env

# no changes!
git status

Ignorando solo parte di un file [stub]

A volte potresti voler avere modifiche locali in un file che non vuoi impegnare o pubblicare. Idealmente le impostazioni locali dovrebbero essere concentrate in un file separato che può essere inserito in .gitignore , ma a volte come soluzione a breve termine può essere utile avere qualcosa di locale in un file archiviato.

Puoi fare in modo che Git "non veda" quelle linee usando il filtro pulito. Non verranno nemmeno visualizzati in diff.

Supponiamo che qui sia snippet dal file file1.c :

struct settings s;
s.host = "localhost";
s.port = 5653;
s.auth = 1;
s.port = 15653; // NOCOMMIT
s.debug = 1; // NOCOMMIT
s.auth = 0; // NOCOMMIT

Non vuoi pubblicare linee NOCOMMIT ovunque.

Crea un filtro "nocommit" aggiungendolo al file di configurazione Git come .git/config :

[filter "nocommit"]
    clean=grep -v NOCOMMIT

Aggiungi (o crea) questo a .git/info/attributes o .gitmodules :

file1.c filter=nocommit

E le tue linee NOCOMMIT sono nascoste da Git.

Avvertenze:

• L'uso del filtro pulito rallenta l'elaborazione dei file, specialmente su Windows.
• La linea ignorata potrebbe scomparire dal file quando Git lo aggiorna. Può essere neutralizzato con un filtro sfumino, ma è più complicato.
• Non testato su Windows

Ignorare le modifiche nei file tracciati. [Stub]

.gitignore e .git/info/exclude funzionano solo per i file non tracciati.

Per impostare il flag di ignora su un file tracciato, utilizzare il comando update-index :

git update-index --skip-worktree myfile.c

Per ripristinare questo, utilizzare:

git update-index --no-skip-worktree myfile.c

Puoi aggiungere questo frammento al tuo git config globale per avere più comandi git hide , git unhide e git hidden :

[alias]
    hide   = update-index --skip-worktree
    unhide = update-index --no-skip-worktree
    hidden  = "!git ls-files -v | grep ^[hsS] | cut -c 3-"

Puoi anche usare l'opzione --assume-immutato con la funzione update-index

git update-index --assume-unchanged <file>

Se si desidera vedere nuovamente questo file per le modifiche, utilizzare

git update-index --no-assume-unchanged <file>

Quando viene specificato il flag --assume-unchanged, l'utente promette di non modificare il file e consente a Git di assumere che il file dell'albero di lavoro corrisponda a quanto registrato nell'indice.Git fallirà nel caso in cui debba modificare questo file nell'indice ad esempio durante la fusione in un commit; quindi, nel caso in cui il file presunto-non tracciato venga modificato a monte, sarà necessario gestire la situazione manualmente. L'attenzione si concentra sulle prestazioni in questo caso.

Mentre il flag --skip-worktree è utile quando si ordina a git di non toccare mai un file specifico perché il file verrà modificato localmente e non si desidera eseguire il commit accidentalmente delle modifiche (ad es. Configurazione / file di proprietà configurato per un particolare ambiente). Skip-worktree ha la precedenza su assume-immutato quando entrambi sono impostati.

Cancella i file già impegnati, ma inclusi in .gitignore

A volte capita che un file sia stato rintracciato da git, ma in un secondo momento è stato aggiunto a .gitignore, al fine di smettere di rintracciarlo. È uno scenario molto comune dimenticare di pulire questi file prima di aggiungerli a .gitignore. In questo caso, il vecchio file sarà ancora sospeso nel repository.

Per risolvere questo problema, è possibile eseguire una rimozione "a secco" di tutto nel repository, seguita dalla ri-aggiunta di tutti i file. Finché non hai modifiche in sospeso e il parametro --cached è passato, questo comando è abbastanza sicuro da eseguire:

# Remove everything from the index (the files will stay in the file system) 
$ git rm -r --cached .

# Re-add everything (they'll be added in the current state, changes included)
$ git add .

# Commit, if anything changed. You should see only deletions
$ git commit -m 'Remove all files that are in the .gitignore'

# Update the remote
$ git push origin master

Crea una cartella vuota

Non è possibile aggiungere e impegnare una cartella vuota in Git a causa del fatto che Git gestisce i file e allega loro la loro directory, che riduce i commit e migliora la velocità. Per aggirare questo, ci sono due metodi:

Metodo uno: .gitkeep

Un trucco per aggirare questo è usare un file .gitkeep per registrare la cartella per Git. Per fare ciò, basta creare la directory richiesta e aggiungere un file .gitkeep alla cartella. Questo file è vuoto e non ha alcuno scopo se non quello di registrare la cartella. Per fare ciò in Windows (che ha delle convenzioni sui nomi dei file scomode) basta aprire git bash nella directory ed eseguire il comando:

$ touch .gitkeep

Questo comando crea solo un file .gitkeep vuoto nella directory corrente

Metodo due: dummy.txt

Un altro hack per questo è molto simile a quanto sopra e gli stessi passi possono essere seguiti, ma invece di un .gitkeep , basta usare invece un dummy.txt . Questo ha il vantaggio di essere in grado di crearlo facilmente in Windows usando il menu contestuale. E puoi anche lasciare messaggi divertenti in essi. Puoi anche usare .gitkeep per tenere traccia della directory vuota. .gitkeep normalmente è un file vuoto che viene aggiunto per tracciare la directory vuota.

Ricerca di file ignorati da .gitignore

Puoi elencare tutti i file ignorati da git nella directory corrente con il comando:

git status --ignored

Quindi se abbiamo una struttura di repository come questa:

.git
.gitignore
./example_1
./dir/example_2
./example_2

... e .gitignore file contenente:

example_2

... che il risultato del comando sarà:

$ git status --ignored

On branch master

Initial commit

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

.gitignore
.example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/
example_2

Se si desidera elencare i file ricorsivamente ignorati nelle directory, è necessario utilizzare un parametro aggiuntivo - --untracked-files=all

Il risultato sarà simile a questo:

$ git status --ignored --untracked-files=all
On branch master

Initial commit

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

.gitignore
example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/example_2
example_2