Git
Dateien und Ordner ignorieren

Einführung

Ignorieren von Dateien und Verzeichnissen mit einer .gitignore-Datei

Sie können Git dazu veranlassen, bestimmte Dateien und Verzeichnisse zu ignorieren, d. .gitignore Sie von der Verfolgung durch Git auszuschließen, indem Sie eine oder mehrere .gitignore Dateien in Ihrem Repository erstellen.

In Softwareprojekten enthält .gitignore normalerweise eine Liste von Dateien und / oder Verzeichnissen, die während des Erstellungsprozesses oder zur Laufzeit generiert werden. Einträge in der .gitignore Datei können Namen oder Pfade enthalten, die auf .gitignore zeigen:

1. temporäre Ressourcen, z. B. Caches, Protokolldateien, kompilierter Code usw.
2. lokale Konfigurationsdateien, die nicht mit anderen Entwicklern gemeinsam genutzt werden dürfen
3. Dateien, die geheime Informationen enthalten, wie Anmeldekennwörter, Schlüssel und Anmeldeinformationen

Wenn sie im obersten Verzeichnis erstellt werden, gelten die Regeln für alle Dateien und Unterverzeichnisse des gesamten Repositorys rekursiv. Bei der Erstellung in einem Unterverzeichnis gelten die Regeln für dieses bestimmte Verzeichnis und dessen Unterverzeichnisse.

Wenn eine Datei oder ein Verzeichnis ignoriert wird, wird Folgendes nicht angezeigt:

1. von Git verfolgt
2. Wird von Befehlen wie git status oder git diff gemeldet
3. mit Befehlen wie git add -A inszeniert

In dem ungewöhnlichen Fall, dass Sie verfolgte Dateien ignorieren müssen, ist besondere Vorsicht geboten. Siehe: Ignorieren Sie Dateien, die bereits an ein Git-Repository übergeben wurden .

Beispiele

Hier einige allgemeine Beispiele für Regeln in einer .gitignore Datei, die auf Glob- .gitignore basieren:

# 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)
\#*#

Die meisten .gitignore Dateien sind standardmäßig in verschiedenen Sprachen .gitignore Um zu beginnen, werden hier .gitignore Beispiel- .gitignore Dateien nach Sprache aufgelistet, aus der .gitignore oder in Ihr Projekt kopiert / .gitignore werden kann . Alternativ können Sie für ein neues Projekt eine Starter-Datei mit einem Online-Tool automatisch generieren.

Andere Formen von .gitignore

.gitignore Dateien sollen als Bestandteil des Repositorys .gitignore werden. Wenn Sie bestimmte Dateien ignorieren möchten, ohne die Ignorierregeln festzulegen, haben Sie folgende Möglichkeiten:

• Bearbeiten Sie die Datei .gitignore .git/info/exclude (verwenden Sie dieselbe Syntax wie .gitignore ). Die Regeln sind global im Repository.
• Richten Sie eine globale Gitignore-Datei ein , die die Ignorierregeln auf alle Ihre lokalen Repositorys anwendet:

Außerdem können Sie lokale Änderungen an verfolgten Dateien ignorieren, ohne die globale Git-Konfiguration zu ändern:

• git update-index --skip-worktree [<file>...] : für geringfügige lokale Änderungen
• git update-index --assume-unchanged [<file>...] : für produktionsbereite, nicht veränderte Dateien im Upstream

Weitere Informationen zu den Unterschieden zwischen den letzteren Flags und der Dokumentation zum git update-index Weitere Optionen.

Ignorierte Dateien bereinigen

Sie können git clean -X um ignorierte Dateien zu bereinigen:

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

Hinweis: -X (Caps) bereinigt nur ignorierte Dateien. Verwenden Sie -x (keine Begrenzungen), um auch nicht protokollierte Dateien zu entfernen.

Weitere Informationen finden Sie in der Dokumentation zu git clean .

Weitere Informationen finden Sie im Git-Handbuch .

Ausnahmen in einer .gitignore-Datei

Wenn Sie Dateien mit einem Muster ignorieren, aber Ausnahmen haben, setzen Sie der Ausnahme ein Ausrufezeichen (!) Voran. Zum Beispiel:

*.txt
!important.txt

Das obige Beispiel weist Git an, alle Dateien mit der Erweiterung .txt außer Dateien mit der Bezeichnung important.txt zu ignorieren.

Wenn sich die Datei in einem ignorierten Ordner befindet, können Sie sie NICHT so einfach erneut einschließen:

folder/
!folder/*.txt

In diesem Beispiel würden alle TXT-Dateien im Ordner ignoriert.

Der richtige Weg ist, den Ordner selbst in eine separate Zeile einzufügen, dann alle Dateien im folder mit * ignorieren und schließlich den folder *.txt im folder wie folgt neu aufzunehmen:

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

Hinweis : Fügen Sie bei Dateinamen, die mit einem Ausrufezeichen beginnen, zwei Ausrufezeichen hinzu oder setzen Sie ein Escapezeichen mit dem Zeichen \ :

!!includethis
\!excludethis

Eine globale .gitignore-Datei

Damit Git bestimmte Dateien in allen Repositorys ignoriert, können Sie mit dem folgenden Befehl in Ihrem Terminal oder der Eingabeaufforderung einen globalen .gitignore erstellen :

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

Git wird dies nun zusätzlich zu der eigenen .gitignore- Datei jedes Repositorys verwenden. Regeln dafür sind:

• Wenn die lokale .gitignore Datei explizit eine Datei enthält, während der globale .gitignore ignoriert, hat der lokale .gitignore Priorität (die Datei wird eingeschlossen).
• Wenn das Repository auf mehreren Rechnern .gigignore muss der globale .gigignore auf allen Rechnern geladen oder zumindest eingeschlossen sein, da die ignorierten Dateien in den Repo .gitignore während der PC mit dem globalen .gitignore ihn nicht aktualisiert . Aus diesem Grund ist ein Repo-spezifischer .gitignore eine bessere Idee als eine globale, wenn das Projekt von einem Team bearbeitet wird

Diese Datei ist ein guter Ort, um plattform-, maschinen- oder benutzerspezifische Ignorierungen .DS_Store , z. B. OSX .DS_Store , Windows Thumbs.db oder Vim *.ext~ und *.ext.swp ignoriert, wenn Sie diese nicht im Repository behalten möchten . Ein unter OS X arbeitendes Teammitglied kann also alle .DS_STORE und _MACOSX (was eigentlich nutzlos ist), während ein anderes Teammitglied unter Windows alle thumbs.bd ignorieren thumbs.bd

Ignorieren Sie Dateien, die bereits an ein Git-Repository übergeben wurden

Wenn Sie bereits eine Datei zu Ihrem Git-Repository hinzugefügt haben und nun die Verfolgung beenden möchten (damit sie in zukünftigen Commits nicht vorhanden ist), können Sie sie aus dem Index entfernen:

git rm --cached <file>

Dies entfernt die Datei aus dem Repository und verhindert, dass weitere Änderungen von Git verfolgt werden. Die Option --cached sicher, dass die Datei nicht physisch gelöscht wird.

Beachten Sie, dass der zuvor hinzugefügte Inhalt der Datei weiterhin über den Git-Verlauf sichtbar ist.

Beachten Sie, dass, wenn jemand anderes aus dem Repository zieht, nachdem Sie die Datei aus dem Index entfernt haben, deren Kopie physisch gelöscht wird .

Sie können Git so tun, als ob die Version des Arbeitsverzeichnisses der Datei auf dem neuesten Stand ist, und stattdessen die Indexversion lesen (um Änderungen daran zu ignorieren) mit dem Bit " Skip Worktree ":

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

Das Schreiben wird durch dieses Bit nicht beeinflusst, die Inhaltssicherheit hat nach wie vor höchste Priorität. Sie werden niemals Ihre wertvollen, ignorierten Änderungen verlieren. Andererseits steht dieses Bit im Konflikt mit dem Einlagern: Um dieses Bit zu entfernen, verwenden Sie

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

Es wird manchmal fälschlicherweise empfohlen, Git anzulügen und davon auszugehen, dass die Datei unverändert bleibt, ohne sie zu untersuchen. Auf den ersten Blick sieht es so aus, als würden weitere Änderungen an der Datei ignoriert, ohne sie aus dem Index zu entfernen:

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

Dadurch wird git gezwungen, alle in der Datei vorgenommenen Änderungen zu ignorieren (bedenken Sie, dass Ihre ignorierten Änderungen verloren gehen , wenn Sie Änderungen an dieser Datei vornehmen oder sie speichern

Wenn Sie möchten, dass git sich erneut um diese Datei kümmert, führen Sie den folgenden Befehl aus:

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

Prüfen, ob eine Datei ignoriert wird

Der Befehl git check-ignore meldet Dateien, die von Git ignoriert werden.

Sie können Dateinamen über die Befehlszeile übergeben, und git check-ignore listet die ignorierten Dateinamen auf. Zum Beispiel:

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

Hier sind nur * .o-Dateien in .gitignore definiert, sodass Readme.md nicht in der Ausgabe von git check-ignore .

Wenn Sie sehen möchten, in welcher Zeile .gitignore eine Datei ignoriert, fügen Sie dem Befehl git check-ignore -v hinzu:

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

Ab Git 1.7.6 können Sie auch git status --ignored verwenden, um ignorierte Dateien git status --ignored . Weitere Informationen hierzu finden Sie in der offiziellen Dokumentation oder in Dateien suchen, die von .gitignore ignoriert werden .

Ignorieren von Dateien in Unterordnern (mehrere Gititore-Dateien)

Angenommen, Sie haben eine Repository-Struktur wie folgt:

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

output.log im Beispielverzeichnis ist gültig und erforderlich, damit das Projekt Verständnis output.log , während die output.log unterhalb von src/ während des Debuggens erstellt wird und nicht im Verlauf oder Teil des Repositorys enthalten sein sollte.

Es gibt zwei Möglichkeiten, diese Datei zu ignorieren. Sie können einen absoluten Pfad in die .gitignore Datei im Stammverzeichnis des Arbeitsverzeichnisses .gitignore :

# /.gitignore
src/output.log

Alternativ können Sie eine .gitignore Datei im Verzeichnis src/ erstellen und die Datei ignorieren, die relativ zu diesem .gitignore :

# /src/.gitignore
output.log

Eine Datei in einem beliebigen Verzeichnis ignorieren

Um eine Datei foo.txt in einem beliebigen Verzeichnis zu ignorieren, schreiben Sie einfach ihren Namen:

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

Wenn Sie die Datei nur in einem Teil der Baumstruktur ignorieren möchten, können Sie die Unterverzeichnisse eines bestimmten Verzeichnisses mit ** pattern angeben:

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

Sie können auch eine .gitignore Datei im Verzeichnis bar/ erstellen. Entspricht dem vorherigen Beispiel das Erstellen einer Datei bar/.gitignore mit folgendem Inhalt:

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

Dateien lokal ignorieren, ohne Regeln zu ignorieren

.gitignore ignoriert Dateien lokal, es soll jedoch an das Repository übergeben und mit anderen Mitwirkenden und Benutzern geteilt werden. Sie können einen globalen .gitignore , aber dann würden alle Ihre Repositorys diese Einstellungen gemeinsam nutzen.

Wenn Sie bestimmte Dateien in einem Repository lokal ignorieren und die Datei nicht zu einem Repository machen möchten, bearbeiten Sie .git/info/exclude in Ihrem Repository.

Zum Beispiel:

# 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/

Vorgefüllte .gitignore-Vorlagen

Wenn Sie nicht sicher sind, welche Regeln in Ihrer .gitignore Datei aufgeführt werden sollen, oder Sie nur allgemein akzeptierte Ausnahmen zu Ihrem Projekt hinzufügen möchten, können Sie eine .gitignore Datei auswählen oder generieren:

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

Viele Hosting-Services wie GitHub und BitBucket bieten die Möglichkeit, .gitignore Dateien basierend auf den verwendeten Programmiersprachen und IDEs zu generieren:

Nachfolgende Änderungen an einer Datei ignorieren (ohne sie zu entfernen)

Manchmal möchten Sie eine Datei in Git halten, spätere Änderungen jedoch ignorieren.

Weisen Sie Git an, Änderungen an einer Datei oder einem Verzeichnis mithilfe von update-index zu ignorieren:

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

Der obige Befehl weist Git an, davon auszugehen, dass my-file.txt nicht geändert wurde, und Änderungen nicht zu überprüfen oder zu melden. Die Datei ist noch im Repository vorhanden.

Dies kann nützlich sein, um Standardwerte bereitzustellen und Überschreibungen in der Umgebung zuzulassen, z.

# 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

Nur einen Teil einer Datei ignorieren [Stub]

Manchmal möchten Sie möglicherweise lokale Änderungen in einer Datei haben, die Sie nicht festlegen oder veröffentlichen möchten. Idealerweise sollten die lokalen Einstellungen in einer separaten Datei konzentriert sein, die in .gitignore platziert werden kann. .gitignore kann es jedoch kurzfristig hilfreich sein, etwas Lokales in einer eingecheckten Datei zu haben.

Sie können Git dazu bringen, diese Zeilen mit Hilfe des Clean-Filters "unsee" zu machen. Sie werden nicht einmal in Differenzen auftauchen.

Angenommen, hier ist ein Ausschnitt aus der Datei 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

Sie möchten NOCOMMIT Zeilen nicht überall veröffentlichen.

Erstellen Sie einen "nocommit" -Filter, indem Sie diesen zu der Git-Konfigurationsdatei wie .git/config hinzufügen:

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

Fügen Sie dies hinzu (oder erstellen Sie es) zu .git/info/attributes oder .gitmodules :

file1.c filter=nocommit

Und Ihre NOCOMMIT-Zeilen sind vor Git verborgen.

Vorsichtsmaßnahmen:

• Die Verwendung eines sauberen Filters verlangsamt die Verarbeitung von Dateien, insbesondere unter Windows.
• Die ignorierte Zeile verschwindet möglicherweise aus der Datei, wenn Git sie aktualisiert. Dem kann mit einem Wischfilter entgegengewirkt werden, er ist jedoch komplizierter.
• Nicht unter Windows getestet

Änderungen in verfolgten Dateien ignorieren. [Stub]

.gitignore und .git .git/info/exclude funktionieren nur für nicht protokollierte Dateien.

Verwenden Sie den Befehl update-index , um das Ignorierungsflag für eine verfolgte Datei festzulegen :

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

Um dies rückgängig zu machen, verwenden Sie:

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

Sie können diese Schnipsel zu Ihrem globalen hinzufügen git config - bequemer haben git hide , git unhide und git hidden Befehle ein :

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

Sie können auch die Option --assume-unverändert mit der Update-Index-Funktion verwenden

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

Wenn Sie diese Datei erneut auf die Änderungen überprüfen möchten, verwenden Sie

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

Wenn das Flag --assume-unverändert angegeben ist, verspricht der Benutzer, die Datei nicht zu ändern, und lässt Git von der Annahme ausgehen, dass die Arbeitsbaumdatei mit der im Index aufgezeichneten Datei übereinstimmt. Git schlägt fehl, falls diese Datei im Index geändert werden muss zB beim Zusammenführen in einem Commit; Wenn also die angenommene Datei nicht geändert wird, müssen Sie die Situation manuell behandeln. In diesem Fall liegt der Fokus auf der Leistung.

Das Flag --skip-worktree ist nützlich, wenn Sie git anweisen, eine bestimmte Datei nicht zu berühren, da die Datei lokal geändert wird und Sie nicht versehentlich die Änderungen festschreiben möchten (dh Konfigurations- / Eigenschaftendatei, die für eine bestimmte Datei konfiguriert ist Umgebung). Skip-Worktree hat Vorrang vor Annahmen, wenn beide gesetzt sind.

Löschen Sie bereits festgeschriebene Dateien, die jedoch in .gitignore enthalten sind

Manchmal kommt es vor, dass eine Datei von git verfolgt wurde, zu einem späteren Zeitpunkt jedoch zu .gitignore hinzugefügt wurde, um die Verfolgung zu beenden. Es ist ein sehr häufiges Szenario, dass Sie vergessen, solche Dateien vor dem Hinzufügen zu .gitignore zu bereinigen. In diesem Fall hängt die alte Datei immer noch im Repository.

Um dieses Problem zu beheben, könnte man im Repository "im Trockenlauf" entfernen und anschließend alle Dateien wieder hinzufügen. Solange Sie keine ausstehenden Änderungen haben und der Parameter --cached wird, ist die --cached dieses Befehls ziemlich sicher:

# 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

Erstellen Sie einen leeren Ordner

Es ist nicht möglich, einen leeren Ordner in Git hinzuzufügen und festzuschreiben, da Git Dateien verwaltet und ihr Verzeichnis an sie anfügt. Dies verringert die Festschreibung und erhöht die Geschwindigkeit. Um dies zu umgehen, gibt es zwei Methoden:

Methode eins: .gitkeep

Um dies zu .gitkeep , müssen Sie den Ordner für Git mit einer .gitkeep Datei registrieren. Erstellen Sie dazu einfach das erforderliche Verzeichnis und fügen .gitkeep dem Ordner eine .gitkeep Datei hinzu. Diese Datei ist leer und dient nur der Registrierung des Ordners. Öffnen Sie dazu in Windows (das unbequeme Dateinamenskonventionen hat) git bash im Verzeichnis und führen Sie den Befehl aus:

$ touch .gitkeep

Dieser Befehl erstellt eine leere .gitkeep Datei im aktuellen Verzeichnis

Methode zwei: dummy.txt

Ein weiterer Hack dafür ist dem obigen sehr ähnlich und die gleichen Schritte können befolgt werden, aber statt .gitkeep verwenden dummy.txt stattdessen eine dummy.txt . Dies hat den zusätzlichen Vorteil, dass es einfach in Windows mithilfe des Kontextmenüs erstellt werden kann. Und Sie können auch lustige Nachrichten hinterlassen. Sie können auch die .gitkeep Datei verwenden, um das leere Verzeichnis zu verfolgen. .gitkeep normalerweise eine leere Datei, die hinzugefügt wird, um das leere Verzeichnis zu verfolgen.

Dateien werden von .gitignore ignoriert

Sie können alle von git ignorierten Dateien im aktuellen Verzeichnis mit folgendem Befehl auflisten:

git status --ignored

Wenn wir also eine Repository-Struktur haben:

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

... und .gitignore-Datei mit:

example_2

... als Ergebnis des Befehls wird sein:

$ 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

Wenn Sie rekursiv ignorierte Dateien in Verzeichnissen --untracked-files=all möchten, müssen Sie den zusätzlichen Parameter - --untracked-files=all

Ergebnis sieht so aus:

$ 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