So überprüfen Sie, ob eine Datei von Git ignoriert wird

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl git check-ignore verwenden, um festzustellen, ob eine Datei von Git ignoriert wird. Sie erstellen eine .gitignore-Datei, fügen ihr Muster hinzu und verwenden dann git check-ignore, um zu überprüfen, welche Dateien ignoriert werden und warum.

Sie werden auch untersuchen, wie verschiedene Muster in der .gitignore-Datei beeinflussen, welche Dateien vom Tracking ausgeschlossen werden, und so ein tieferes Verständnis dafür gewinnen, wie Git ignorierten Dateien umgeht.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/SetupandConfigGroup(["Setup and Config"]) git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/SetupandConfigGroup -.-> git/git("Show Version") git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/status("Check Status") git/BasicOperationsGroup -.-> git/clean("Clean Workspace") git/BranchManagementGroup -.-> git/checkout("Switch Branches") subgraph Lab Skills git/git -.-> lab-560027{{"So überprüfen Sie, ob eine Datei von Git ignoriert wird"}} git/add -.-> lab-560027{{"So überprüfen Sie, ob eine Datei von Git ignoriert wird"}} git/status -.-> lab-560027{{"So überprüfen Sie, ob eine Datei von Git ignoriert wird"}} git/clean -.-> lab-560027{{"So überprüfen Sie, ob eine Datei von Git ignoriert wird"}} git/checkout -.-> lab-560027{{"So überprüfen Sie, ob eine Datei von Git ignoriert wird"}} end

Ausführen von `git check-ignore` für eine Datei

In diesem Schritt lernen wir, wie man den Befehl git check-ignore verwendet. Dieser Befehl ist sehr nützlich, um zu verstehen, warum Git bestimmte Dateien oder Verzeichnisse ignoriert. Er hilft Ihnen, Ihre .gitignore-Datei zu debuggen.

Zunächst stellen wir sicher, dass wir uns in unserem Projektverzeichnis befinden. Öffnen Sie Ihr Terminal und geben Sie ein:

cd ~/project/my-time-machine

Jetzt erstellen wir eine Datei, die wir erwarten, dass Git sie ignoriert. Wir erstellen eine Datei namens temp.log. Oft werden Log-Dateien in Git-Repositories ignoriert.

echo "This is a temporary log file." > temp.log

Als Nächstes erstellen wir eine .gitignore-Datei und fügen ein Muster hinzu, um .log-Dateien zu ignorieren.

echo "*.log" > .gitignore

Jetzt können wir git check-ignore verwenden, um zu sehen, ob Git temp.log ignoriert.

git check-ignore temp.log

Wenn Git die Datei ignoriert, gibt der Befehl das Muster aus der .gitignore-Datei aus, das der Datei entspricht. Sie sollten eine Ausgabe ähnlich dieser sehen:

.gitignore:1:*.log	temp.log

Diese Ausgabe sagt uns, dass die Datei temp.log ignoriert wird, weil das Muster *.log in Zeile 1 der .gitignore-Datei übereinstimmt.

Wenn die Datei nicht ignoriert würde, würde der Befehl keine Ausgabe liefern.

Das Verständnis von git check-ignore ist entscheidend für die effektive Verwaltung der Dateien Ihres Projekts. Es verhindert, dass Sie versehentlich Dateien in Ihr Repository einchecken, die Sie nicht dort haben möchten, wie temporäre Dateien, Build-Artefakte oder sensible Konfigurationsdateien.

Überprüfen von `.gitignore`-Mustern

In diesem Schritt werden wir untersuchen, wie verschiedene Muster in der .gitignore-Datei beeinflussen, welche Dateien ignoriert werden. Die .gitignore-Datei verwendet spezifische Muster, um Git mitzuteilen, welche Dateien oder Verzeichnisse vom Tracking ausgeschlossen werden sollen.

Stellen Sie sicher, dass Sie sich immer noch im Verzeichnis ~/project/my-time-machine befinden.

Fügen wir einige weitere Dateien hinzu und ändern wir unsere .gitignore-Datei, um zu sehen, wie verschiedene Muster funktionieren.

Zunächst erstellen wir einige neue Dateien:

mkdir build
echo "This is a build artifact." > build/output.txt
echo "Another log file." > error.log
echo "A temporary file." > temp.dat
echo "A configuration file." > config.ini

Jetzt bearbeiten wir die .gitignore-Datei, um weitere Muster hinzuzufügen. Hierfür können wir den nano-Editor verwenden.

nano .gitignore

Im nano-Editor sollten Sie *.log sehen. Fügen Sie die folgenden Zeilen darunter hinzu:

build/
*.dat
config.ini

Ihre .gitignore-Datei sollte jetzt so aussehen:

*.log
build/
*.dat
config.ini

Drücken Sie Ctrl + X, dann Y und Enter, um die Datei zu speichern und nano zu verlassen.

Jetzt verwenden wir git check-ignore mit der Option -v, um zu sehen, welches Muster welche Datei ignoriert. Die Option -v liefert ausführliche Ausgabe und zeigt das übereinstimmende Muster und die Quelldatei (in diesem Fall .gitignore).

git check-ignore -v temp.log error.log build/output.txt temp.dat config.ini

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

.gitignore:1:*.log	temp.log
.gitignore:1:*.log	error.log
.gitignore:2:build/	build/output.txt
.gitignore:3:*.dat	temp.dat
.gitignore:4:config.ini	config.ini

Diese Ausgabe bestätigt, dass:

temp.log und error.log durch das Muster *.log ignoriert werden.
build/output.txt ignoriert wird, weil das gesamte Verzeichnis build/ ignoriert wird.
temp.dat durch das Muster *.dat ignoriert wird.
config.ini durch das Muster config.ini ignoriert wird.

Das Verständnis dieser Muster ist unerlässlich, um Ihr Repository sauber zu halten und sich nur auf die Dateien zu konzentrieren, die Sie verfolgen möchten.

Testen von nicht ignorierten Dateien

In diesem Schritt verwenden wir git check-ignore, um zu bestätigen, dass Dateien, die von .gitignore nicht ignoriert werden, keine Ausgabe erzeugen. Dies hilft Ihnen, Ihr Verständnis davon zu festigen, wie der Befehl funktioniert und wie Sie überprüfen können, dass Git die Dateien verfolgt, die Sie es auch sollen.

Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project/my-time-machine befinden.

Wir haben bereits die Datei message.txt aus einem vorherigen Lab. Diese Datei ist nicht in unserer .gitignore-Datei aufgeführt, also sollte Git sie nicht ignorieren.

Lassen Sie uns git check-ignore auf message.txt anwenden:

git check-ignore message.txt

Wie erwartet sollte dieser Befehl keine Ausgabe erzeugen. Dies zeigt an, dass message.txt von keinem Muster in Ihrer .gitignore-Datei oder anderen Ignorierregeln ignoriert wird.

Jetzt erstellen wir eine weitere Datei, die wir nicht ignorieren möchten:

echo "This file should be tracked." > important_file.txt

Und überprüfen ihren Ignorierstatus:

git check-ignore important_file.txt

Wieder sollten Sie keine Ausgabe sehen, was bestätigt, dass important_file.txt nicht ignoriert wird.

Schließlich verwenden wir git status, um zu sehen, wie Git diese Dateien wahrnimmt.

git status

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	new file:   .gitignore

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

nothing added to commit but untracked files present (use "git add" to track)

Beachten Sie, dass important_file.txt und message.txt unter "Untracked files" (nicht verfolgte Dateien) aufgeführt sind. Dies bedeutet, dass Git sie erkennt, aber derzeit ihre Änderungen nicht verfolgt. Die ignorierten Dateien (temp.log, error.log, build/output.txt, temp.dat, config.ini) sind hier nicht aufgeführt, weil Git ausdrücklich angewiesen wurde, sie zu ignorieren.

Dieser Schritt verstärkt das Konzept, dass git check-ignore ein Werkzeug zur Überprüfung von Ignorierregeln ist und dass Dateien, die nicht von Ignorierregeln erfasst werden, in git status als "nicht verfolgt" erscheinen, bis Sie sie ausdrücklich mit git add zum Tracking hinzufügen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl git check-ignore verwendet, um festzustellen, ob eine bestimmte Datei von Git ignoriert wird. Wir haben das Erstellen einer .gitignore-Datei, das Hinzufügen von Mustern zu dieser Datei und das Verwenden von git check-ignore geübt, um zu überprüfen, dass die beabsichtigten Dateien tatsächlich ignoriert werden. Die Ausgabe von git check-ignore hat uns geholfen, zu verstehen, welches Muster in der .gitignore-Datei dazu führt, dass eine Datei ignoriert wird.

Wir haben auch untersucht, wie verschiedene Muster in der .gitignore-Datei beeinflussen, welche Dateien ignoriert werden. Indem wir verschiedene Dateien erstellt und die .gitignore-Datei mit verschiedenen Mustern geändert haben, haben wir ein besseres Verständnis dafür gewonnen, wie Git diese Muster interpretiert, um Dateien und Verzeichnisse vom Tracking auszuschließen. Dieses Wissen ist unerlässlich für die effektive Verwaltung der Dateien, die in einem Git-Repository enthalten sind.