Die 20 besten Git-Interview-Fragen und -Antworten für alle Niveaus

Git-Interview-Fragen für Fortgeschrittene

10. Was ist ein Remote in Git?

Ein Remote ist ein Repository, das auf einem Server oder einem anderen Computer für die Zusammenarbeit und den Austausch von Code mit anderen gehostet wird. Es dient als zentraler Ort, an dem Entwickler ihre lokalen Änderungen pushen und Änderungen von anderen ziehen können.

Remotes werden in der Regel auf Hosting-Plattformen wie GitHub, GitLab oder Bitbucket eingerichtet. Sie ermöglichen eine verteilte Entwicklung und erleichtern die Teamarbeit, indem sie einen gemeinsamen Speicherort für die Speicherung und Synchronisierung des Projektcodes unter mehreren Mitwirkenden bieten.

11. Was ist der Unterschied zwischen git fetch und git pull?

Der Hauptunterschied zwischen git fetch und git pull liegt darin, was sie tun und wie sie das lokale Repository aktualisieren.

Der Befehl git fetch holt Änderungen aus einem entfernten Projektarchiv in das lokale Projektarchiv. Es aktualisiert die Remote-Tracking-Zweige (z.B. origin/master) im lokalen Repository, um den Zustand des Remote-Repository widerzuspiegeln, aber es aktualisiert nicht das Arbeitsverzeichnis und führt keine Änderungen im aktuellen Zweig zusammen. Das bedeutet, dass du nach dem Holen die Änderungen im entfernten Repository überprüfen kannst, ohne dass deine lokale Arbeit beeinträchtigt wird.

Der Befehl git pull ruft ebenfalls Änderungen aus einem entfernten Repository ab, geht aber noch einen Schritt weiter, indem er die Änderungen abruft und sie in einem Schritt in den aktuellen Zweig einfügt. Es führt im Wesentlichen einen Git Fetch und anschließend einen Git Merge durch, um die Änderungen aus dem entfernten Repository in den aktuellen Zweig zu übernehmen.

12. Wie macht man einen Commit rückgängig, der bereits gepusht und öffentlich gemacht wurde?

Mit dem Befehl git revert kannst du einen Commit rückgängig machen, der bereits gepusht und öffentlich gemacht wurde.

Du gehst wie folgt vor: Schritt für Schritt:

1. Identifiziere den Commit, zu dem du zurückkehren möchtest, indem du den Commit-Hash suchst. Dazu kannst du den Befehl git log verwenden, um die Commit-Historie einzusehen und den Commit-Hash zu finden, den du rückgängig machen willst.

2. Sobald du den Commit-Hash hast, kannst du mit dem Befehl git revert, gefolgt von dem Commit-Hash, einen neuen Commit erstellen, der die Änderungen des angegebenen Commits rückgängig macht. Zum Beispiel:

git revert <commit-hash>

3. Git öffnet einen Texteditor, um eine Commit-Nachricht für den Revert zu erstellen. Du kannst die Nachricht bei Bedarf bearbeiten, dann speichern und den Editor schließen.

4. Nach dem Speichern der Commit-Nachricht erstellt Git einen neuen Commit, der die Änderungen, die durch den angegebenen Commit eingeführt wurden, rückgängig macht. Dieser neue Commit wird zur Historie hinzugefügt und macht die Änderungen des ursprünglichen Commits rückgängig.

5. Zum Schluss pusht du die neue Übergabe an das entfernte Repository, um den Revert mit folgendem Befehl zu veröffentlichen:

git push origin <branch-name> 

Mit git revert wird ein neuer Commit erstellt, der die Änderungen des ursprünglichen Commits rückgängig macht, ohne die Commit-Historie zu verändern. Dieser Ansatz ist sicherer als git reset oder git amend, die die Commit-Historie verändern und Probleme für Mitwirkende verursachen können, die die Änderungen bereits gezogen haben.

13. Was bedeutet git reset do?

Der Befehl git reset setzt den aktuellen HEAD auf einen bestimmten Zustand zurück. Das bedeutet, dass du damit Änderungen rückgängig machen, Dateien zurücksetzen oder den HEAD-Zeiger auf einen anderen Commit verschieben kannst. Beachte, dass es drei Hauptarten von git reset gibt:

• --soft: Setzt den HEAD-Zeiger auf einen bestimmten Commit zurück, so dass die Änderungen staged bleiben. Die geänderten Dateien bleiben im Arbeitsverzeichnis, so dass du sie erneut committen kannst.

• --mixed: Setzt den HEAD-Zeiger auf einen bestimmten Commit zurück und hebt damit Änderungen auf. Dateien bleiben im Arbeitsverzeichnis geändert, aber die Änderungen werden nicht für die Übertragung bereitgestellt.

• --hard: Setzt den HEAD-Zeiger auf einen bestimmten Commit zurück und verwirft alle Änderungen im Arbeitsverzeichnis und im Staging-Bereich. Verwende diese Option mit Vorsicht, da sie nicht übertragene Änderungen dauerhaft löscht.

14. Was ist git stash?

git stash ist ein Git-Befehl, der Änderungen im Arbeitsverzeichnis vorübergehend speichert, die noch nicht übertragen werden können. Es ermöglicht Entwicklern, ihre Änderungen zu speichern, ohne sie in das Repository zu übertragen.

Stashing ist nützlich, wenn du den Zweig wechselst, aber deine Änderungen nicht übertragen oder verlieren willst. Später kannst du die versteckten Änderungen auf dein Arbeitsverzeichnis anwenden oder sie aus dem Stapel entfernen, um weiter daran zu arbeiten.

15. Was ist git reflog?

git reflog ist ein Git-Befehl, mit dem du die Referenzprotokolle einsehen kannst, die Änderungen am HEAD-Zeiger und die Historie der ausgecheckten Commits im Repository aufzeichnen. Sie enthält eine chronologische Liste der letzten Aktionen im Repository, einschließlich Commits, Checkouts, Merges und Resets.

Das Reflog ist hilfreich, um verlorene Commits oder Branches wiederherzustellen und die Reihenfolge der Aktionen im Repository zu verstehen.

16. Wie kann man einen bestehenden Git-Zweig einem entfernten Zweig folgen lassen?

Um einen bestehenden Git-Zweig einem entfernten Zweig zuzuordnen, kannst du den Befehl git branch mit der Option --set-upstream-to oder -u verwenden, gefolgt vom Namen des entfernten Zweigs.

Die Syntax sieht dann wie folgt aus:

git branch --set-upstream-to=<remote-name>/<branch-name>

Oder...

git branch -u <remote-name>/<branch-name>

Git-Interview-Fragen für Fortgeschrittene

17. Wie verwaltest du mehrere Konfigurationen für verschiedene Projekte in Git?

Um verschiedene Konfigurationen zu verwalten, kannst du den Befehl git config zusammen mit den Flags --global, --system oder --local verwenden, um die Konfigurationseinstellungen auf verschiedenen Ebenen anzupassen. Alternativ kannst du includeIf in der Git-Konfiguration verwenden, um bestimmte Setups basierend auf dem Pfad des Repositorys einzubinden.

18. Wie handhabst du große Dateien mit Git?

Der Umgang mit großen Dateien in Git kann eine Herausforderung sein, da sie sich auf die Größe des Repositorys und die Leistung auswirken. Verwende Git LFS, um große Dateien außerhalb des Git-Repositorys zu speichern und gleichzeitig leichtgewichtige Zeiger auf sie im Repository zu behalten. Dadurch wird die Größe des Repositorys reduziert und die Leistung verbessert. Git LFS unterstützt verschiedene Speicheranbieter und lässt sich nahtlos in Git-Workflows integrieren.

19. Was ist der Nutzen von git submodule und wie aktualisiert man sie?

Der Befehl git submodule verwaltet externe Abhängigkeiten innerhalb eines Git-Repositorys. Es ermöglicht dir, externe Repositories als Submodule in dein Haupt-Repository einzubinden. Das ist nützlich, wenn du Code aus externen Quellen einbinden willst, ohne ihn von der Codebasis deines Hauptprojekts zu trennen.

Um ein Submodul in Git zu aktualisieren, kannst du die folgenden Schritte ausführen:

1. Navigiere zu dem Verzeichnis des Submoduls in deinem Haupt-Repository.
2. Verwende git fetch, um die neuesten Änderungen aus dem Remote-Repository des Submoduls zu holen.
3. Wenn du auf den letzten Commit auf dem Branch, den das Submodul verfolgt, aktualisieren willst, kannst du git pull verwenden.
4. Wenn du auf einen bestimmten Commit oder Branch aktualisieren willst, kannst du auch git checkout verwenden, gefolgt von dem gewünschten Commit-Hash oder Branch-Namen.
5. Wenn du das Submodul auf den gewünschten Stand gebracht hast, musst du die Änderungen an das Haupt-Repository übertragen, um den aktualisierten Zustand des Submoduls widerzuspiegeln.

20. Was ist die Bedeutung von git push --force-with-lease über git push --force?

git push --force-with-lease ist ein vorsichtigerer Ansatz, um Änderungen in einem entfernten Repository zu erzwingen, als git push --force, weil es verhindert, dass versehentlich Änderungen überschrieben werden, die von anderen im entfernten Repository vorgenommen wurden.

Wenn du git push --force verwendest, überträgst du deine Änderungen zwangsweise auf das entfernte Repository, unabhängig davon, ob andere es seit deinem letzten Fetch aktualisiert haben. Das kann dazu führen, dass die Arbeit anderer Entwickler ungewollt verloren geht.

Im Gegensatz dazu ist git push --force-with-lease eine sicherere Alternative. Er prüft, ob der entfernte Zweig, auf den du pushen willst, seit deinem letzten Fetch von anderen aktualisiert wurde. Wenn der entfernte Zweig bereits aktualisiert wurde, wird der Push abgelehnt. So verhinderst du, dass die Änderungen anderer Entwickler ungewollt überschrieben werden.

Vorbereitung auf ein technisches Interview

Die Präsentation deiner Git-Kenntnisse und -Erfahrungen in Vorstellungsgesprächen ist entscheidend, um deine Fähigkeiten bei der Versionskontrolle und der Zusammenarbeit in Software-Entwicklungsteams unter Beweis zu stellen.

Hier sind einige Tipps, die du bei der Vorbereitung auf dein technisches Vorstellungsgespräch beachten solltest, um deine Git-Fähigkeiten effektiv zu vermitteln:

Verstehe die Grundlagen von Git

Vergewissere dich, dass du ein solides Verständnis der Git-Grundlagen hast, einschließlich Repositories, Branching, Merging, Commits und grundlegende Befehle wie Pull, Push, Clone und Commit. Dieses Basiswissen bildet die Grundlage für dein Gespräch während des Vorstellungsgesprächs. Außerdem ist es hilfreich, wenn du die grundlegenden Prinzipien der Versionskontrolle gut verstehst, die Unterschiede zwischen Git und anderen Versionskontrollsystemen (VCS) kennst und ihre Bedeutung für die Softwareentwicklung verstehst.

Mache dich mit verschiedenen Git-Methoden vertraut, z.B. Git Flow, GitHub Flow und GitLab Flow. Beurteile die Vor- und Nachteile jedes Ansatzes und erkenne die Situationen, in denen sie am vorteilhaftesten sind.

Der vollständige Leitfaden von DataCamp zu Git ist ein guter Ausgangspunkt, um sich mit den Grundlagen vertraut zu machen.

Praktische Erfahrungen sammeln

Je mehr du Git benutzt, desto mehr vertiefst du dein Wissen. Durch regelmäßiges Üben wirst du mit den verschiedenen Befehlen und Abläufen vertrauter. Versuche, Git in deinen täglichen Arbeitsablauf einzubauen, um mehr Aufmerksamkeit zu bekommen. Experimentiere damit, Zweige zu erstellen, sie zusammenzuführen und Konflikte zu lösen.

Wenn du nicht weißt, an welchen Projekten du arbeiten sollst, um praktische Erfahrungen mit Git zu sammeln, ist die Teilnahme an Open-Source-Projekten auf Plattformen wie GitHub eine gute Möglichkeit, die branchenüblichen Kollaborationswerkzeuge und Arbeitsabläufe aus erster Hand kennenzulernen.

Erfahre, welche Probleme häufig auftreten und wie man sie behebt

Wenn du Git verwendest, wirst du zwangsläufig auf Probleme stoßen. Zu den häufigsten Problemen gehören Merge-Konflikte, abgetrennte HEAD-Zustände, das Rückgängigmachen von Änderungen und das Wiederherstellen verlorener Commits. Die Diagnose von Git-Problemen verbessert die Fähigkeiten zur Fehlerbehebung und fördert ein tieferes Verständnis für die zugrunde liegenden Mechanismen von Git.

Durch die aktive Fehlersuche und die Analyse von Fehlermeldungen erhältst du Einblicke in die interne Funktionsweise von Git und entwickelst die Fähigkeit, Probleme effizient zu identifizieren und zu lösen. Dieser proaktive Ansatz mindert potenzielle Risiken und schafft Vertrauen und Fachwissen im Umgang mit Versionskontroll-Workflows.

Probeinterviews üben

Durch Probeinterviews können die Bewerber/innen Schwachstellen in ihrem Git-Wissen und ihren Kommunikationsfähigkeiten erkennen und sich so gezielt vorbereiten.

Außerdem bieten Probeinterviews den Bewerbern wertvolle Möglichkeiten, ihre Problemlösungsfähigkeiten zu verbessern, indem sie realistische Git-bezogene Szenarien und Programmierübungen bewältigen. Diese praktische Übung hilft den Bewerbern, Selbstvertrauen in ihre Git-Fähigkeiten zu entwickeln und ihre Fähigkeit zu verbessern, ihre Gedanken während des Vorstellungsgesprächs klar zu artikulieren.

Fazit

Git ist ein leistungsfähiges Versionskontrollsystem, das in der Softwareentwicklung weit verbreitet ist, um Codeänderungen zu verwalten, mit anderen zusammenzuarbeiten und den Projektverlauf zu pflegen. Die Vertrautheit mit Git ist für technische Vorstellungsgespräche unerlässlich, denn sie zeigt, dass du die wichtigsten Entwicklerwerkzeuge und Arbeitsabläufe beherrschst, dass du gut zusammenarbeiten kannst und dass du in der Lage bist, Code in einer Teamumgebung effektiv zu verwalten.

Außerdem ermöglicht das Verständnis der Git-Konzepte und -Befehle eine effiziente Versionskontrolle, die die Integrität des Codes, die Kontinuität des Projekts und optimierte Entwicklungsprozesse gewährleistet. Daher sind Git-Kenntnisse von unschätzbarem Wert für angehende Software-Ingenieure und -Entwickler, die technische Interviews führen und eine erfolgreiche Karriere anstreben.

Wenn du dich weiterbilden willst, schau dir die folgenden Ressourcen an:

• Was ist Git? - Der vollständige Leitfaden zu Git
• GitHub und Git Tutorial für Einsteiger
• GitHub Concepts
• Vollständiger Git-Spickzettel