Git Pull: Ignorieren lokaler Änderungen

GitGitBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Dieses Tutorial bietet eine umfassende Anleitung zum Befehl "git pull --ignore-unmerged", der es Ihnen ermöglicht, in einem Git-Repository die Remote-Änderungen gegenüber Ihren lokalen Änderungen zu priorisieren. Egal, ob Sie in einem Team an einem Projekt arbeiten oder Ihre lokale Codebasis schnell mit dem Remote-Repository synchronisieren müssen, dieses Tutorial hilft Ihnen, die Anwendungsfälle, Vorteile und potenziellen Risiken der Verwendung dieses Befehls zu verstehen.

In diesem Lab (Labor) lernen Sie, wie Sie ein Git-Repository einrichten, sich widersprechende Änderungen erstellen und den Befehl git pull --ignore-unmerged verwenden, um Konflikte zu lösen. Sie werden auch alternative Ansätze zur Konfliktbehandlung in einem Git-Workflow (Arbeitsablauf) untersuchen.

Einrichten eines Git-Repositorys

Bevor wir uns mit Git pull-Befehlen befassen, richten wir zunächst ein einfaches Git-Repository ein, mit dem wir arbeiten können. Dies bietet Ihnen eine praktische Umgebung, um zu verstehen, wie Git Änderungen und Konflikte behandelt.

Erstellen eines neuen Repositorys

Zunächst erstellen wir ein neues Verzeichnis für unser Git-Repository. Öffnen Sie Ihr Terminal und führen Sie die folgenden Befehle aus:

cd ~/project
mkdir git-pull-demo
cd git-pull-demo

Initialisieren Sie nun ein Git-Repository in diesem Verzeichnis:

git init

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Initialized empty Git repository in /home/labex/project/git-pull-demo/.git/

Konfigurieren der Git-Benutzerinformationen

Um Commits (Versionsänderungen) zu erstellen, muss Git Ihre Identität kennen. Legen Sie Ihren Benutzernamen und Ihre E-Mail-Adresse mit den folgenden Befehlen fest:

git config --local user.name "Learner"
git config --local user.email "learner@example.com"

Erstellen und Committen von Anfangsdateien

Erstellen wir einige Beispieldateien, mit denen wir arbeiten können. Zunächst erstellen wir eine einfache Textdatei:

echo "## Git Pull Demo" > README.md
echo "This is the first line of the file." > file1.txt

Fügen Sie nun diese Dateien in die Staging-Area (Zwischenspeicher) ein und erstellen Sie Ihren ersten Commit:

git add README.md file1.txt
git commit -m "Initial commit"

Die Ausgabe sollte wie folgt aussehen:

[main (root-commit) xxxxxxx] Initial commit
 2 files changed, 2 insertions(+)
 create mode 100644 README.md
 create mode 100644 file1.txt

Herzlichen Glückwunsch, Sie haben erfolgreich ein Git-Repository mit einem ersten Commit erstellt. Überprüfen wir den Status unseres Repositorys:

git status

Sie sollten sehen:

On branch main
nothing to commit, working tree clean

Dies zeigt an, dass alle Ihre Änderungen committed wurden. Sie haben nun ein funktionierendes Git-Repository, mit dem Sie in den nächsten Schritten arbeiten können.

Simulieren eines Remote-Repositorys

Um zu verstehen, wie git pull funktioniert, müssen wir ein Remote-Repository simulieren. In einer realen Welt wäre dies ein Repository, das auf Plattformen wie GitHub, GitLab oder Bitbucket gehostet wird. Für dieses Lab (Labor) werden wir ein lokales Verzeichnis erstellen, das als unser "Remote"-Repository fungieren wird.

Erstellen eines "Remote"-Repositorys

Erstellen wir ein "bare" (nacktes) Repository, das als unser Remote-Repository fungieren wird:

cd ~/project
mkdir remote-repo.git
cd remote-repo.git
git init --bare

Sie sollten sehen:

Initialized empty Git repository in /home/labex/project/remote-repo.git/

Ein "bare" Repository ist ein Git-Repository, das kein Arbeitsverzeichnis hat. Es ist als zentrales Repository konzipiert, an das Sie Änderungen pushen und von dem Sie Änderungen pullen können.

Verbinden Ihres lokalen Repositorys mit dem Remote-Repository

Gehen Sie nun zurück zu Ihrem lokalen Repository und fügen Sie das Remote-Repository hinzu:

cd ~/project/git-pull-demo
git remote add origin ~/project/remote-repo.git

Pushen Ihrer Änderungen an das Remote-Repository

Pushen Sie Ihre lokalen Änderungen an das Remote-Repository:

git push -u origin main

Die Ausgabe sollte wie folgt aussehen:

Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (4/4), 279 bytes | 279.00 KiB/s, done.
Total 4 (delta 0), reused 0 (delta 0)
To /home/labex/project/remote-repo.git
 * [new branch]      main -> main
Branch 'main' set up to track remote branch 'main' from 'origin'.

Dieser Befehl pusht Ihre lokale main-Branch (Hauptzweig) an das Remote-Repository und richtet mit der -u-Option die Verfolgung (tracking) zwischen Ihrer lokalen und der Remote-Branch ein.

Überprüfen der Verbindung

Um zu überprüfen, ob Ihr lokales Repository korrekt mit dem Remote-Repository verbunden ist, führen Sie aus:

git remote -v

Sie sollten sehen:

origin  /home/labex/project/remote-repo.git (fetch)
origin  /home/labex/project/remote-repo.git (push)

Dies zeigt, dass Ihr lokales Repository mit dem Namen "origin" mit dem Remote-Repository verbunden ist.

Nachdem wir nun unser lokales und unser Remote-Repository eingerichtet haben, können wir uns damit befassen, wie man Konflikte behandelt und den Befehl git pull --ignore-unmerged verwendet.

Erstellen von Konfliktänderungen

In diesem Schritt werden wir ein Szenario erstellen, in dem Änderungen im Remote-Repository mit Ihren lokalen Änderungen in Konflikt stehen. Dies hilft uns zu verstehen, wie Git Konflikte behandelt und warum der Befehl git pull --ignore-unmerged nützlich sein kann.

Erstellen eines neuen Repository-Klons

Zunächst erstellen wir einen zweiten Klon unseres Repositorys, um zu simulieren, dass ein Teammitglied Änderungen vornimmt:

cd ~/project
git clone remote-repo.git team-member-repo
cd team-member-repo

Sie sollten sehen:

Cloning into 'team-member-repo'...
done.

Vornehmen von Änderungen im "Teammitglied"-Repository

Nun modifizieren wir file1.txt in diesem Repository:

echo "This line was added by a team member." >> file1.txt
git add file1.txt
git commit -m "Team member added a line"
git push origin main

Sie sollten sehen:

[main xxxxxxx] Team member added a line
 1 file changed, 1 insertion(+)
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 325 bytes | 325.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To /home/labex/project/remote-repo.git
   xxxxxxx..xxxxxxx  main -> main

Vornehmen von Konfliktänderungen in Ihrem ursprünglichen Repository

Gehen Sie nun zurück zu Ihrem ursprünglichen Repository und machen Sie eine andere Änderung an derselben Datei:

cd ~/project/git-pull-demo
echo "This line was added locally." >> file1.txt
git add file1.txt
git commit -m "Added a line locally"

Sie sollten sehen:

[main xxxxxxx] Added a line locally
 1 file changed, 1 insertion(+)

Versuch, Änderungen zu pullen

Versuchen Sie nun, die Änderungen aus dem Remote-Repository zu pullen:

git pull origin main

Da Sie dieselbe Datei wie Ihr "Teammitglied" geändert haben, wird Git einen Konflikt melden:

From /home/labex/project/remote-repo
 * branch            main       -> FETCH_HEAD
Auto-merging file1.txt
CONFLICT (content): Merge conflict in file1.txt
Automatic merge failed; fix conflicts and then commit the result.

Anzeigen des Konflikts

Untersuchen wir die Datei mit dem Konflikt:

cat file1.txt

Sie sollten etwas wie Folgendes sehen:

This is the first line of the file.
<<<<<<< HEAD
This line was added locally.
=======
This line was added by a team member.
>>>>>>> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Git hat die konfliktierenden Abschnitte mit <<<<<<< HEAD, ======= und >>>>>>> markiert. Der Abschnitt vor ======= ist Ihre lokale Änderung, und der Abschnitt danach ist die Remote-Änderung.

Dies ist ein typisches Szenario für einen Merge-Konflikt. Im nächsten Schritt werden wir die Option git pull --ignore-unmerged verwenden, um diesen Konflikt zu lösen.

Verwenden von Git Pull mit der Option --ignore-unmerged

Nachdem wir nun einen Konflikt zwischen unserem lokalen und Remote-Repository erstellt haben, wollen wir untersuchen, wie man die Option git pull --ignore-unmerged verwendet, um ihn zu lösen.

Verständnis der Option --ignore-unmerged

Die Option --ignore-unmerged teilt Git mit, bei Konflikten die Remote-Änderungen gegenüber Ihren lokalen Änderungen zu priorisieren. Dies kann in Situationen nützlich sein, in denen Sie wissen, dass die Remote-Änderungen wichtiger sind als Ihre lokalen Änderungen.

Abbrechen der laufenden Merge-Operation

Bevor wir die Option --ignore-unmerged verwenden können, müssen wir die aktuelle Merge-Operation abbrechen:

cd ~/project/git-pull-demo
git merge --abort

Dieser Befehl setzt Ihr Arbeitsverzeichnis in den Zustand vor dem Merge-Versuch zurück. Überprüfen wir den Inhalt der Datei:

cat file1.txt

Sie sollten jetzt nur Ihre lokalen Änderungen sehen:

This is the first line of the file.
This line was added locally.

Verwenden der Option --ignore-unmerged

Nun verwenden wir die Option git pull --ignore-unmerged:

git pull --ignore-unmerged origin main

Sie werden feststellen, dass Git immer noch einen Konflikt meldet:

From /home/labex/project/remote-repo
 * branch            main       -> FETCH_HEAD
Auto-merging file1.txt
CONFLICT (content): Merge conflict in file1.txt
Automatic merge failed; fix conflicts and then commit the result.

Dies liegt daran, dass die Option --ignore-unmerged etwas anders funktioniert, als der Name vermuten lässt. Sie löst Konflikte nicht direkt, indem sie Ihre lokalen Änderungen ignoriert. Stattdessen ermöglicht sie es Git, mit einem Merge fortzufahren, auch wenn es ungemergte Einträge gibt.

Verständnis dessen, was tatsächlich passiert ist

Der richtige Weg, um Remote-Änderungen gegenüber lokalen Änderungen zu priorisieren, ist die Verwendung der Option --strategy-option theirs:

git reset --hard ## Warnung: Dies verwirft alle uncommitteten Änderungen
git pull -X theirs origin main

Die Ausgabe sollte wie folgt aussehen:

From /home/labex/project/remote-repo
 * branch            main       -> FETCH_HEAD
Updating xxxxxxx..xxxxxxx
Fast-forward
 file1.txt | 1 +
 1 file changed, 1 insertion(+)

Dieser Befehl teilt Git mit, Konflikte automatisch zu lösen, indem es die Remote-Änderungen ("theirs") gegenüber Ihren lokalen Änderungen ("ours") bevorzugt.

Überprüfen wir nun den Inhalt der Datei:

cat file1.txt

Sie sollten sehen:

This is the first line of the file.
This line was added by a team member.

Wie Sie sehen können, wurden die Remote-Änderungen gegenüber Ihren lokalen Änderungen priorisiert. Die Option --strategy-option theirs ist ein direkterer Weg, um das zu erreichen, was viele Leute fälschlicherweise glauben, dass --ignore-unmerged tut.

Wann man --ignore-unmerged verwenden sollte

Die Option --ignore-unmerged ist tatsächlich nützlicher in Fällen, in denen Sie Updates für Dateien abrufen möchten, die keine Konflikte haben, während Sie konfliktbehaftete Dateien ungemergt lassen, um sie später manuell zu lösen.

Um dies richtig zu demonstrieren, erstellen wir ein weiteres Szenario:

## Fügen Sie lokal eine neue Datei hinzu
echo "This is a new local file." > local_file.txt
git add local_file.txt
git commit -m "Added local_file.txt"

## Erstellen Sie eine Änderung im Teammitglied-Repository
cd ~/project/team-member-repo
echo "This is a second line by team member." >> file1.txt
echo "This is a new remote file." > remote_file.txt
git add file1.txt remote_file.txt
git commit -m "Team member made more changes"
git push origin main

## Gehen Sie zurück zu Ihrem Repository
cd ~/project/git-pull-demo
## Machen Sie eine andere Änderung an file1.txt
echo "This is another local change." >> file1.txt
git add file1.txt
git commit -m "Made another local change"

Wenn Sie nun versuchen, die Änderungen zu pullen, erhalten Sie einen Konflikt:

git pull origin main

Ausgabe:

From /home/labex/project/remote-repo
 * branch            main       -> FETCH_HEAD
Auto-merging file1.txt
CONFLICT (content): Merge conflict in file1.txt
Automatic merge failed; fix conflicts and then commit the result.

Brechen wir den Merge ab und versuchen es mit --ignore-unmerged:

git merge --abort
git pull --ignore-unmerged origin main

Dies kann immer noch Konflikte anzeigen, aber es ermöglicht Ihnen, alle nicht-konfliktbehafteten Änderungen (wie remote_file.txt) zu erhalten, während Sie die konfliktbehaftete Datei (file1.txt) für eine manuelle Lösung übrig lassen.

Alternative Ansätze zur Konfliktbehandlung

Während die Befehle git pull --ignore-unmerged und git pull -X theirs in bestimmten Szenarien nützlich sein können, gibt es mehrere andere Ansätze zur Konfliktbehandlung, mit denen Sie vertraut sein sollten. Diese Ansätze geben Ihnen mehr Kontrolle über den Merge-Prozess und können in vielen Situationen sicherer sein.

1. Manuelle Konfliktbehebung

Der häufigste und sicherste Ansatz ist die manuelle Konfliktbehebung. Erstellen wir ein sauberes Konfliktszenario und lösen es manuell:

cd ~/project/git-pull-demo
git reset --hard HEAD~1 ## Gehen Sie einen Commit zurück

Sie sollten sehen:

HEAD is now at xxxxxxx Added local_file.txt

Machen Sie nun eine Änderung an file1.txt:

echo "This is a different local change." >> file1.txt
git add file1.txt
git commit -m "Made a different local change"

Ziehen Sie nun die Änderungen aus dem Remote-Repository:

git pull origin main

Sie werden einen Konflikt sehen:

From /home/labex/project/remote-repo
 * branch            main       -> FETCH_HEAD
Auto-merging file1.txt
CONFLICT (content): Merge conflict in file1.txt
Automatic merge failed; fix conflicts and then commit the result.

Bearbeiten Sie die Datei, um den Konflikt mit nano zu beheben:

nano file1.txt

Im nano-Editor können Sie die Konfliktmarker sehen. Bearbeiten Sie die Datei, um beide Änderungen beizubehalten oder andere erforderliche Modifikationen vorzunehmen. Beispielsweise möchten Sie möglicherweise, dass es so aussieht:

This is the first line of the file.
This line was added by a team member.
This is a second line by team member.
This is a different local change.

Speichern Sie die Datei (Strg+O, dann Eingabe) und verlassen Sie nano (Strg+X).

Führen Sie nun den Merge-Prozess ab:

git add file1.txt
git commit -m "Manually resolved conflict"

Sie sollten sehen:

[main xxxxxxx] Manually resolved conflict

2. Verwenden von git stash

Ein anderer Ansatz besteht darin, git stash zu verwenden, um Ihre lokalen Änderungen vorübergehend zu speichern, die Remote-Änderungen zu ziehen und dann Ihre Änderungen erneut anzuwenden:

## Machen Sie eine neue Änderung an file1.txt
echo "This is yet another local change." >> file1.txt

## Verwenden Sie git stash, um Ihre lokalen Änderungen zu speichern
git stash

## Ziehen Sie die Remote-Änderungen
git pull origin main

## Wenden Sie Ihre lokalen Änderungen erneut an
git stash pop

Wenn es Konflikte gibt, wenn Sie git stash pop ausführen, wird Git Sie darüber informieren, und Sie können sie manuell beheben.

3. Erstellen eines Feature-Branches

Ein dritter Ansatz besteht darin, einen Feature-Branch für Ihre lokalen Änderungen zu erstellen:

## Erstellen und wechseln Sie zu einem neuen Branch
git checkout -b feature-branch

## Machen Sie Ihre Änderungen
echo "This is a change in the feature branch." >> file1.txt
git add file1.txt
git commit -m "Made a change in feature branch"

## Wechseln Sie zurück zum main-Branch
git checkout main

## Ziehen Sie die Remote-Änderungen
git pull origin main

## Mergen Sie Ihren Feature-Branch
git merge feature-branch

Wenn es während des Mergens Konflikte gibt, wird Git Sie auffordern, sie manuell zu beheben, bevor der Merge abgeschlossen wird.

4. Verwenden von Merge-Tools

Git unterstützt auch verschiedene Merge-Tools, die den Konfliktbehebungsprozess visueller und intuitiver machen können. Sie können Git so konfigurieren, dass es Ihr bevorzugtes Merge-Tool verwendet:

git config --global merge.tool <tool-name>

Wenn Sie auf Konflikte stoßen, können Sie dann ausführen:

git mergetool

Dies öffnet Ihr konfiguriertes Merge-Tool, das Ihnen bei der Konfliktbehebung hilft.

Jeder dieser Ansätze hat seine Vorteile und Anwendungsfälle. Der beste Ansatz hängt von Ihrer spezifischen Situation und Ihren Vorlieben ab.

Zusammenfassung

In diesem Lab haben Sie die Konfliktlösungsmechanismen von Git kennengelernt und insbesondere den Befehl git pull --ignore-unmerged untersucht. Sie haben praktische Erfahrung gesammelt in:

  1. Einrichten eines Git-Repositories und Verbinden es mit einem Remote-Repository
  2. Erstellen und Simulieren von konfliktären Änderungen zwischen lokalen und Remote-Repositories
  3. Verstehen, was der Befehl git pull --ignore-unmerged tut und seine Einschränkungen
  4. Verwenden des effektiveren Befehls git pull -X theirs, um Remote-Änderungen zu priorisieren
  5. Untersuchen alternativer Ansätze zur Konfliktbehandlung, einschließlich:
    • Manuelle Konfliktlösung
    • Verwenden von git stash
    • Erstellen von Feature-Branches
    • Nutzen von Merge-Tools

Der wichtigste Punkt ist, dass Befehle wie git pull --ignore-unmerged und git pull -X theirs zwar in bestimmten Szenarien nützlich sein können, aber mit Vorsicht eingesetzt werden sollten. In den meisten Fällen gibt Ihnen die manuelle Konfliktlösung mehr Kontrolle und hilft dabei sicherzustellen, dass wichtige Änderungen nicht versehentlich verloren gehen.

Durch das Verständnis dieser Git-Konzepte und -Befehle sind Sie nun besser gerüstet, um Code-Konflikte in kollaborativen Entwicklungsumgebungen zu behandeln, was Ihren Git-Workflow effizienter und fehlerunanfälliger macht.