Wenn Du dich mit Versionskontrollsystemen beschäftigst, ist Git eine der beliebtesten und leistungsfähigsten Lösungen. Es ermöglicht dir, Änderungen an deinem Code zu verfolgen, verschiedene Versionen zu verwalten und bequem mit anderen zusammenzuarbeiten. Für Anfänger ist der Einstieg oft einfacher, wenn man die wichtigsten Befehle kennt und versteht, wie sie zusammenwirken.
In diesem Artikel erhältst Du einen klaren Überblick über die wesentlichen Git-Kommandos. So kannst Du Schritt für Schritt Deine Projekte effektiver verwalten und merkst schnell, dass dir die Arbeit mit Git deutlich leichter fällt. Dabei setzen wir auf verständliche Erklärungen und praktische Tipps, damit Du sofort loslegen kannst.
Das Wichtigste in Kürze
- Mit „git init“ startest du ein neues Repository und legst die Basis für die Versionskontrolle.
- „git add“ bereitet Dateien für den nächsten Commit vor, indem sie in den Staging-Bereich verschoben werden.
- „git commit -m“ speichert die Änderungen dauerhaft mit einer verständlichen Nachricht.
- „git remote add“ verbindet dein Projekt mit einem Remote-Server wie GitHub für Zusammenarbeit und Backups.
- „git push“ und „git pull“ synchronisieren dein lokales Projekt mit dem Remote-Repository.
Git initialisieren: „git init“ im Projektordner ausführen
Bevor Du mit der eigentlichen Arbeit an deinem Projekt beginnst, ist es notwendig, Git zu initialisieren. Dies geschieht durch den Befehl „git init“, der direkt im Ordner deines Projekts ausgeführt wird. Dadurch wird ein versteckter Ordner namens .git erstellt, in dem alle Informationen zur Versionskontrolle gespeichert werden. Dieser Schritt ist entscheidend, um Git als Werkzeug für Dein Projekt nutzen zu können.
Nachdem Du den Befehl eingegeben hast, kannst Du sofort anfangen, Änderungen zu verfolgen und Deine Versionen zu verwalten. Es ist hilfreich, sich bewusst zu machen, dass die Initialisierung nur einmal nötig ist, wenn Du ein neues Projekt startest. Danach kannst Du weitere Befehle verwenden, um Dateien hinzuzufügen, Änderungen zu committen oder Remote-Repositories zu verbinden.
Der Befehl „git init“ bildet somit die Grundlage für alle weiteren Schritte. Ohne diese Initialisierung erkennt Git Dein Projekt und ermöglicht dir eine strukturierte Verwaltung des Codes. Dabei bleibt das gesamte System übersichtlich und transparent, was vor allem bei längeren Entwicklungsprozessen von großem Vorteil ist.
Empfehlung: Die besten VS Code Extensions für Entwickler 2025
Änderungen verfolgen: „git add“ oder „git add “ nutzen
Nachdem Du Dein Projekt initialisiert hast, ist es wichtig, die Änderungen an den Dateien zu verfolgen. Dafür kommt der Befehl „git add“ zum Einsatz. Mit diesem kannst Du einzelne Dateien oder auch ganze Gruppen von Dateien in den sogenannten Staging-Bereich verschieben, was bedeutet, dass sie für einen späteren Commit vorgemerkt werden. Das ist notwendig, weil Git nur die in diesem Bereich befindlichen Dateien bei einem Commit berücksichtigt.
Um eine einzelne Datei hinzuzufügen, gibst Du einfach „git add dateiname“ ein. Möchtest Du alle Änderungen aus deinem Projekt erfassen, kannst Du stattdessen „git add .“ verwenden. Dieser Befehl bewirkt, dass alle modifizierten, neuen oder gelöschten Dateien im aktuellen Verzeichnis und seinen Unterordnern für das nächste Commit vorbereitet werden. Es ist ratsam, vor dem Commit stets alle relevanten Änderungen mit „git add“ zu versehen, um sicherzustellen, dass nichts Wichtiges ausgelassen wird.
Der Ablauf erleichtert dir die Kontrolle über Deine Änderungen erheblich. Durch das gezielte Hinzufügen kannst Du genau bestimmen, was in die neue Version deines Projekts aufgenommen wird. Dies bietet dir Flexibilität bei der Arbeit, insbesondere wenn Du nur bestimmte Anpassungen sichern möchtest. Nur durch das Nutzen von „git add“ bist Du in der Lage, deinen Fortschritt Schritt für Schritt sorgfältig und übersichtlich zu dokumentieren.
Änderungen committen: „git commit -m ‚Nachricht'“ verwenden
Nachdem Du alle gewünschten Änderungen mit „git add“ in den Staging-Bereich verschoben hast, kannst Du diese endgültig sichern, indem Du einen Commit durchführst. Der Befehl „git commit -m ‚Nachricht'“ ist hierfür die richtige Wahl. Hierbei ersetzt Du ‚Nachricht‘ durch eine kurze, prägnante Beschreibung Deiner vorgenommenen Änderungen. Diese Nachricht dient später dazu, die einzelnen Versionen besser nachvollziehen zu können. Es ist ratsam, verständliche und aussagekräftige Mitteilungen zu verfassen, damit Du jederzeit erkennen kannst, was bei jedem Commit geändert wurde.
Der Commit-Prozess speichert die aktuellen Änderungen dauerhaft im Verlauf deines Repositories. Er bildet somit einen wichtigen Fixpunkt, an dem Du bei Bedarf auf eine bestimmte Arbeitsversion zurückgreifen kannst. Stelle sicher, dass Du immer nur die relevanten Dateien committest, um die Übersichtlichkeit zu bewahren. Zudem solltest Du regelmäßig kleinere Änderungen sichern, anstatt alles auf einmal zu committen, was das spätere Nachvollziehen erleichtert.
Dieses Vorgehen macht Dein Projekt strukturierter und verbessert die Zusammenarbeit, gerade wenn mehrere Personen am selben Code arbeiten. Ein gut geschriebener Commit-Message-Text hilft dir oder anderen, die Geschichte des Projekts nachzuvollziehen und frühzeitig Fehlerquellen zu identifizieren. Insgesamt unterstützt dich dieser Schritt dabei, den Entwicklungsprozess übersichtlich und transparent zu gestalten, sodass Du jederzeit kontrolliert vorankommst.
„Software crafting is a process of constant improvement, with each change making the project better.“ – Kent Beck
Remote-Repository hinzufügen: „git remote add“ eingeben
Nachdem Du Dein Projekt initialisiert und Änderungen vorgenommen hast, ist es sinnvoll, ein Remote-Repository hinzuzufügen. Dieses dient dazu, deinen Code auf einen Server hochzuladen und dort mit anderen zu teilen oder eine zentrale Sicherung zu haben. Um dies zu erledigen, verwendest Du den Befehl „git remote add“, gefolgt vom Namen des Remote-Servers (häufig origin) und der URL des Repositorys.
Ein Beispiel: Wenn Du bei einem Dienst wie GitHub oder GitLab ein neues Repository erstellt hast, erhältst Du die URL, beispielsweise https://github.com/benutzername/projekt.git. Mit dem Befehl „git remote add origin https://github.com/benutzername/projekt.git“ verbindest Du Dein lokales Repository mit diesem Remote. Dadurch kannst Du später Deine Änderungen bequem auf den Server übertragen oder aktuelle Versionen herunterladen.
Das Hinzufügen eines Remote-Repositories ist somit ein wichtiger Schritt, um die Zusammenarbeit zu erleichtern und den eigenen Workflow in Teams zu optimieren. Es lohnt sich, den Namen „origin“ standardmäßig zu verwenden, was auch von vielen Tools automatisch übernommen wird. Sobald dieser Schritt abgeschlossen ist, kannst Du durch Befehle wie „git push“ oder „git pull“ die Synchronisation zwischen deinem lokalen Projekt und dem Web-Repository steuern.
Zusätzlicher Lesestoff: Bash Script Tutorial: So automatisierst Du Deine Aufgaben unter Linux
| Schlüsselbegriff | Beschreibung |
|---|---|
| git init | Initialisiert ein neues Git-Repository im Projektordner, erstellt den versteckten Ordner .git zur Versionskontrolle. |
| git add | Fügt Dateien zum Staging-Bereich hinzu, um sie für den nächsten Commit vorzubereiten. |
| git commit -m ‚Nachricht‘ | Sichert die Änderungen dauerhaft im Repository und versieht sie mit einer verständlichen Nachricht. |
| git remote add | Verbindet das lokale Repository mit einem Remote-Server, etwa auf GitHub oder GitLab. |
| git push | Überträgt die lokalen Änderungen auf den Remote-Server, um sie zu veröffentlichen. |
| git pull | Lädt die neuesten Änderungen vom Remote-Repository herunter und integriert sie in das lokale Projekt. |
| git branch / git checkout | Erstellt neue Zweige und wechselt zwischen verschiedenen Entwicklungssträngen. |
| Konflikte lösen | Bei Zusammenführungen (Merge) treten Konflikte auf, die manuell gelöst werden müssen, um den Code zusammenzuführen. |
Änderungen pushen: „git push“ verwenden, um auf Server zu übertragen
Wenn Du Deine Änderungen in Git abgeschlossen hast, ist der nächste Schritt das Hochladen dieser Änderungen auf den Remote-Server. Hierfür verwendest Du den Befehl „git push“. Dieser Befehl sorgt dafür, dass alle lokal vorgenommenen Commits auf den definierten Server übertragen werden, sodass andere Teammitglieder Zugriff auf die aktuellen Versionen haben. Es ist wichtig, vorher sicherzustellen, dass Dein Repository korrekt mit einem Remote-Repositorium verbunden ist, beispielsweise über „git remote add“.
Beim Ausführen von „git push“ solltest Du evtl. noch den Namen des Ziel-Branches angeben, wenn Du beispielsweise an einem spezifischen Entwicklungszweig arbeitest. Das kann so aussehen: „git push origin main“. Dabei steht origin für das Remote-Repository und main für den Branch, in den Du hochladen möchtest. Dadurch wird Dein lokaler Stand in das zentrale Repository kopiert, was den Austausch und die Weiterentwicklung vereinfacht.
Ein weiterer Vorteil von „git push“ ist, dass es dir ermöglicht, eine Versionsgeschichte aktuell zu halten. Dies bedeutet, dass jeder Commit auch transparent dokumentiert wird, was insbesondere bei Teams hilfreich ist. Mit jedem Push sind die neuesten Änderungen auf dem Server verfügbar und können von anderen genutzt oder weiterentwickelt werden. Dabei ist es ratsam, regelmäßig zu pushen, um Konflikte beim Zusammenfügen verschiedener Entwicklungen zu vermeiden. Mithilfe dieses Befehls bleibt Dein Projekt stets gut synchronisiert und sorgt für einen reibungslosen Ablauf im Team.
Zum Weiterlesen: Python vs JavaScript: Welches ist besser für Anfänger
Änderungen pullen: „git pull“, um aktuelle Version zu laden
Nachdem Du Deine Änderungen auf dem Remote-Server veröffentlicht hast, ist es oftmals notwendig, die neuesten Versionen des Projekts auf deinen lokalen Rechner zu laden. Dafür nutzt Du den Befehl „git pull“. Dieser Befehl ist besonders praktisch, um stets auf dem aktuellen Stand zu bleiben, wenn mehrere Personen gleichzeitig am selben Projekt arbeiten.
Durch das Ausführen von „git pull“ werden automatisch alle neuen Commits vom entfernten Repository heruntergeladen und in Dein lokales Projekt integriert. Der Befehl sorgt außerdem dafür, dass mögliche Konflikte zwischen Deiner aktuellen Arbeitsversion und der externen Version direkt erkannt werden. Falls es Unterschiede gibt, wirst Du aufgefordert, diese manuell zu klären, bevor das Zusammenfügen vollständig abgeschlossen ist. Damit kannst Du sicherstellen, dass Dein Code immer mit der neuesten Entwicklung übereinstimmt.
Es ist wichtig, regelmäßig „git pull“ auszuführen, vor allem, wenn Du im Team arbeitest oder dich vorher noch nicht mit deinem Projekt beschäftigt hast. So vermeidest Du größere Konflikte, die beim späteren Zusammenführungsprozess entstehen könnten. Das Pull-Kommando aktualisiert Deine lokale Kopie stets zuverlässig und hält Deine Arbeitsumgebung ebenso auf dem neuesten Stand wie die gemeinsame Projektbasis.
Branch erstellen und wechseln: „git branch“ und „git checkout“
Wenn Du an einem Projekt arbeitest und verschiedene Entwicklungslinien erkunden möchtest, ist das Erstellen eines neuen Branches eine sehr nützliche Technik. Dafür verwendest Du den Befehl „git branch“. Mit diesem kannst Du einen separaten Arbeitsbereich in deinem Repository aufsetzen, der es ermöglicht, Features oder Änderungen unabhängig vom Hauptzweig durchzuführen.
Um einen neuen Zweig zu erstellen, gibst Du beispielsweise „git branch feature-xyz“ ein. Damit hast Du eine Kopie des aktuellen Standes deines Codes und kannst dort experimentieren, ohne die Stabilität des Hauptprojekts zu beeinträchtigen. Nachdem der Branch angelegt ist, kannst Du zwischen den verschiedenen Linien wechseln. Dies erfolgt mit dem Befehl „git checkout“.
Wenn Du momentan im Branch main bist und zu deinem zuvor erstellten Zweig feature-xyz wechseln möchtest, lautet der Befehl: „git checkout feature-xyz“. Das Umschalten erfolgt sofort, sodass Du direkt in Deiner gewählten Entwicklungsumgebung weiterarbeitest. Alternativ kannst Du auch den neuen Befehl „git switch“ verwenden, der ab neueren Versionen von Git verfügbar ist.
Das Arbeiten mit mehreren Branches erleichtert das parallele Entwickeln, da Änderungen in einem Format erfolgen und gleichzeitig andere Bereiche stabil bleiben können. Zudem lassen sich Funktionen einfach zusammenführen, sobald sie fertiggestellt sind, was die Zusammenarbeit und den Versionsverlauf deutlich übersichtlicher macht.
Konflikte lösen bei Zusammenführungen
Beim Arbeiten mit Git können Konflikte auftreten, wenn mehrere Personen gleichzeitig an denselben Dateien Änderungen vornehmen und diese Änderungen nicht automatisch zusammengeführt werden können. Solche Konflikte entstehen meist nach einem „git merge“-Befehl, bei dem zwei Zweige zusammengeführt werden sollen. In diesem Fall weist Git dich darauf hin, dass manuelle Eingriffe nötig sind, um die Probleme zu beheben.
Um Konflikte zu lösen, solltest Du dir zunächst die Datei anschauen, in der der Konflikt aufgetreten ist. Git kennzeichnet die Stellen im Code, an denen die Unterschiede bestehen, durch spezielle Markierungen wie <<<<<<<, ======= und >>>>>>>. Diese markieren den Anfang, die Trennlinie und das Ende der jeweiligen Änderungen. Es liegt an dir, die passende Version auszuwählen oder beide Varianten zu kombinieren, sodass Deine Anwendung weiterhin funktioniert.
Nachdem Du die Konfliktstellen bereinigt hast, entferne alle Markierungen und überprüfe den Code sorgfältig. Ist alles in Ordnung, kannst Du die Datei wieder stagen (mit „git add“) und den Konfliktraum abschließen, indem Du einen Commit machst. Wichtig ist, bei Konflikten stets behutsam vorzugehen, um keine wichtigen Änderungen unabsichtlich zu entfernen. Mit etwas Erfahrung wirst Du schnell sicherer im Umgang und kannst solche Situationen effizient bewältigen.
