Git Commit Tutorial: Lernpfad und Dokumentation von Codeänderungen

Git hat sich zum Standard-System für die Verwaltung von Änderungen an Codebases entwickelt. Einer der wichtigsten Befehle in Git ist git commit, der einen Schnappschuss des Projektverlaufs zu einem bestimmten Zeitpunkt festhält.

Um einen sauberen und organisierten Projektverlauf zu erhalten, ist es wichtig zu wissen, wie man git commit effizient nutzt. Das Schreiben von aussagekräftigen Commit-Nachrichten und das Befolgen von Best Practices stellt sicher, dass dein Repository überschaubar bleibt, egal ob du alleine oder in einem größeren Team arbeitest. 

In diesem Tutorial lernst du, wie du den Befehl git commit verwendest, klare und informative Commit-Nachrichten schreibst und die besten Methoden für eine erfolgreiche Versionskontrolle anwendest.

Lass uns loslegen!

Was ist ein Git Commit?

Einer der grundlegenden Bausteine der Versionskontrolle in Git iist der Befehl git commit. Auf git commit wird ein Schnappschuss des aktuellen Zustands deiner Stagedateien erstellt und in der Historie des Repositorys gespeichert. Es erstellt eine eindeutige Kennung für die Änderungen und protokolliert wichtige Metadaten wie den Autor, den Zeitstempel und eine beschreibende Commit-Nachricht. 

Die Entwickler können auch eine Commit-Nachricht hinzufügen, die die vorgenommenen Änderungen kurz beschreibt und den Kontext und die Gründe für die Aktualisierung liefert.

Commits sind wichtig, weil sie es Entwicklern ermöglichen,..:

• Änderungen verfolgen: Commits liefern ein klares Protokoll der Änderungen, die im Laufe der Zeit an der Codebasis vorgenommen wurden.
• Zusammenarbeiten: In einer Teamumgebung helfen Commits den Entwicklern zu verstehen, welche Änderungen von wem und warum vorgenommen wurden.
• Zu vorherigen Zuständen zurückkehren: Wenn ein Fehler oder ein Problem auftritt, ermöglichen Commits den Entwicklern, das Projekt auf einen stabilen Stand zurückzusetzen, bevor die problematische Änderung eingeführt wurde.
• Behalte eine saubere Vergangenheit: Strukturierte, häufige Commits mit aussagekräftigen Nachrichten machen die Verwaltung großer Projekte und die Diagnose von Problemen einfacher.

> Wenn du gerade erst mit Git und GitHub anfängst, kannst duer Lernpfad "GitHub Foundations" bietet einen Weg, der dir hilft, die Grundlagen der Versionskontrolle und der Arbeitsabläufe für die Zusammenarbeit zu beherrschen.

Grundlegende Syntax von Git Commit

Um Git effektiv zu nutzen, musst du die grundlegende Syntax und Struktur von Commits verstehen. In diesem Abschnitt werden die wichtigsten Komponenten des Commit-Prozesses erläutert, um sicherzustellen, dass die Änderungen korrekt erfasst und dokumentiert werden.

Grundbefehl

Der einfachste Weg, eine Übergabe zu erstellen, ist der folgende Befehl: 

git commit -m “Your commit message” 

Hier kannst du mit dem -m Flag eine kurze Commit-Nachricht einfügen, die die Änderungen beschreibt. Hier stellst du zum Beispiel den Kontext für künftige Referenzen und Zusammenarbeit bereit: 

git commit -m “Fix bug in user authentication” 

Dieser Befehl führt die Übergabe durch und verknüpft sie mit der angegebenen Nachricht. 

Was passiert bei einer Übertragung?

Hier ist, was unter der Haube passiert, wenn du eine Übertragung machst: 

1. Inszenierungsänderungen: Bevor du die Änderungen bestätigst, musst du sie mit dem Befehl git add durchführen. Dadurch werden die geänderten Dateien für die nächste Übertragung vorbereitet. Du kannst einzelne Dateien oder alle geänderten Dateien einstellen. 

git add file.txt  #Stages one file
git add .  #Stages all files in the current directory

2. Die Verpflichtung eingehen: Sobald deine Änderungen bereitgestellt wurden, erstellt der Befehl git commit einen Schnappschuss der bereitgestellten Dateien und speichert sie im Repository. Beachte, dass der Snapshot den aktuellen Stand der Dateien darstellt.
3. Aktualisieren des Repositorys: Nach dem Commit aktualisiert Git den Projektverlauf, um den Commit zusammen mit allen vorherigen Commits zu speichern. Jeder Commit dient als Checkpoint, der bei Bedarf zurückgenommen werden kann.

Effektive Git Commit-Nachrichten schreiben

Das Schreiben klarer und aussagekräftiger Commit-Nachrichten ist wichtig, um einen sauberen und verständlichen Projektverlauf zu erhalten. Eine gut geschriebene Commit-Nachricht dient auch als Kommunikationsmittel, das Entwicklern und Mitarbeitern hilft, den Zweck und den Kontext jeder Änderung schnell zu verstehen.

Die Bedeutung guter Commit-Meldungen

Gute Commit-Botschaften sind wie eine Landkarte. Sie geben einen Einblick in die Gründe für jede Änderung, was von unschätzbarem Wert ist, wenn du den Code später überprüfst oder Probleme behebst. Gut geschriebene Commit-Nachrichten machen es außerdem einfacher, Fehler zu finden, die Entwicklung von Funktionen zu verstehen und durch die Geschichte des Repositorys zu navigieren. 

Best Practices für Commit-Meldungen

Um sicherzustellen, dass deine Commit-Nachrichten ihren Zweck erfüllen, befolge diese Best Practices:

1. Sei beschreibend: Eine Commit-Nachricht sollte erklären, was geändert wurde und, falls relevant, warum die Änderung vorgenommen wurde. Vermeide vage oder generische Meldungen wie "beheben" oder "aktualisieren". Strebe stattdessen nach Spezifität. Zum Beispiel ist "Login-Formular-Validierungsfehler beheben" viel hilfreicher als einfach "Fehler beheben".
2. Verwende das Präsens: Verpflichtungserklärungen sollten im Präsens geschrieben werden. Das vermittelt den Eindruck, dass du beschreibst, was der Commit in diesem Moment tut. Verwende zum Beispiel "Login-Validierung hinzufügen" statt "Login-Validierung hinzugefügt".
3. Halte es kurz und einfach: Eine knappe Nachricht ist besser lesbar. Die Zusammenfassung (die erste Zeile der Commit-Meldung) sollte in der Regel 50-72 Zeichen lang sein. Wenn mehr Erklärungen nötig sind, kannst du in den folgenden Zeilen eine längere Beschreibung einfügen. Dieser Ansatz stellt sicher, dass die Nachricht mit verschiedenen Git-Tools und Schnittstellen leicht eingesehen werden kann.
4. Verwende Aufzählungspunkte für detaillierte Änderungen: Wenn dein Commit mehrere zusammenhängende Änderungen beinhaltet, verwende Aufzählungspunkte in der erweiterten Beschreibung, um aufzuschlüsseln, was gemacht wurde. Das hilft, eine klare Struktur zu schaffen, die es einfacher macht, ihr zu folgen.

> Wenn du über die Grundlagen von Commits hinausgehen willst, kannst du im Kurs Intermediate Git fortgeschrittene Konzepte wie Amend, Rebase und die Verwaltung der Commit-Historie in Teams.

Erweiterte Git Commit Optionen

Das -m Flag ist eine gängige Option für Git-Commit-Befehle und reicht für den täglichen Gebrauch aus. Einige andere erweiterte Optionen bieten jedoch mehr Flexibilität und Effizienz bei der Verwaltung von Änderungen. In diesem Abschnitt werfen wir einen Blick auf diese Optionen. 

Commit ohne Staging

In vielen Fällen kann es sich als unnötig erweisen, Dateien vor dem Commit manuell mit git add bereitzustellen, insbesondere wenn alle geänderten Dateien committed werden müssen. Um diesen Prozess zu beschleunigen, bietet Git das -a Flag, das alle verfolgten Dateien in einem Schritt überträgt. Das bedeutet, dass alle Änderungen, die an zuvor getrackten Dateien vorgenommen wurden, in den Commit aufgenommen werden, ohne dass du git add explizit aufrufen musst.

So funktioniert es:

git commit -a -m “Your commit message” 

Eine Zusage ändern

Fehler können passieren. Manchmal musst du einen Commit ändern, den du gerade gemacht hast. Mit der Option --amend kannst du den letzten Commit ändern, anstatt einen neuen zu erstellen. So kannst du die Commit-Nachricht aktualisieren oder zusätzliche Dateien zu derselben Commit-Datei hinzufügen.

Zum Beispiel, um die Nachricht der letzten Übertragung zu korrigieren: 

git commit --amend -m "Update commit message"

Oder wenn du vergessen hast, eine Datei bereitzustellen, füge zuerst die Datei hinzu und ändere dann den Commit:

git add missed-file.txt
git commit --amend

Dadurch wird der vorherige Commit durch den aktualisierten Commit ersetzt. 

Beachte, dass Änderungen nur an Commits vorgenommen werden sollten, die nicht mit anderen geteilt wurden (z.B. nicht in ein gemeinsames Repository gepusht), um zu vermeiden, dass die Geschichte überschrieben wird, auf die sich andere verlassen könnten!

Commit mit Änderungen und Dateien aus einem bestimmten Commit

Manchmal musst du einen Fehler in einem früheren Commit korrigieren oder beheben, ohne andere Änderungen vorzunehmen. Git bietet die Option --fixup, mit der du einen Folge-Commit erstellen kannst, der speziell mit einem früheren Commit verknüpft ist. Dies ist besonders nützlich, wenn du deinen Commit-Verlauf bereinigen musst, bevor du deine Änderungen zusammenführst.

Zum Beispiel, um ein Fixup für einen bestimmten Commit zu erstellen:

git commit --fixup <commit-hash>

Mit diesem Befehl wird ein neuer Commit erstellt, der die Probleme des angegebenen Commits beheben soll. 

Wenn du später einen interaktiven Rebase durchführst, kann Git diese Fixup-Commits automatisch mit dem ursprünglichen Commit, auf den sie verweisen, zusammenführen.

> Für fortgeschrittene Arbeitsabläufe wie das Zerdrücken von Commits kannst du unserem detaillierten Walkthrough iim Git Squash Commits Tutorial folgen.

Commits mit Git verwalten

Wenn sich dein Projekt weiterentwickelt und die Commit-Historie wächst, wird die Verwaltung von Commits zu einem wichtigen Aspekt, um ein organisiertes und navigierbares Repository zu erhalten. Eine effektive Commit-Verwaltung hilft beim Debuggen, bei der Zusammenarbeit und beim Führen einer sauberen, nachvollziehbaren Historie. 

Git bietet leistungsstarke Werkzeuge, mit denen du die Historie der Commits einsehen und bei Bedarf Änderungen revidieren oder sogar rückgängig machen kannst. Wenn du weißt, wie du diese Commits verwaltest, kannst du viel Zeit sparen, wenn du Probleme löst oder die Geschichte deines Projekts verfeinerst.

Commit-Verlauf anzeigen

Ein wichtiger Aspekt des Commit-Managements ist es, die Geschichte des Projekts zu verstehen. Mit dem Befehl git log kannst du einen detaillierten Verlauf deiner Commits einsehen. Es gibt Aufschluss darüber, wann Änderungen vorgenommen wurden, wer sie vorgenommen hat und welche Nachrichten angehängt wurden.

Hier ist zum Beispiel der grundlegende Befehl git log:

git log

Hier werden Commit-Hashes, Autorennamen, Datum und Commit-Nachrichten angezeigt. 

Git ermöglicht es dir aber auch, die Log-Ausgabe an deine Bedürfnisse anzupassen. Du kannst zum Beispiel die Anzahl der angezeigten Commits wie folgt begrenzen: 

git log -n 5 # shows the last 5 commits

Um die Änderungen in jedem Commit zu sehen, verwende das -p Flag, das den Diff für jeden Commit anzeigt. 

So sieht es aus:

git log -p

Eine Übertragung rückgängig machen oder widerrufen

Manchmal musst du Änderungen zurückverfolgen oder rückgängig machen. Eine sichere Möglichkeit, eine Übergabe rückgängig zu machen, istg die Funktion git revert command. Dadurch wird ein neuer Commit erstellt, der die Änderungen eines vorherigen Commits rückgängig macht, ohne den Commit-Verlauf zu verändern. 

Das ist besonders nützlich, wenn du bereits Commits mit anderen geteilt hast und die Historie intakt halten willst.

Um eine Übertragung rückgängig zu machen, verwende Folgendes:

git revert <commit-hash>

Dieser Befehl wendet eine Umkehrung der Änderungen des angegebenen Commits an, macht sie also rückgängig und behält gleichzeitig einen transparenten Verlauf bei.

Zurücksetzen einer Übertragung

In manchen Fällen möchtest du dein Repository komplett auf einen früheren Zustand zurücksetzen, indem du einen oder mehrere Commits löschst. Mit dem Befehl git resetd kannst du genau das tun. Das Zurücksetzen eines Commits verändert jedoch die Commit-Historie und sollte daher mit Vorsicht eingesetzt werden, vor allem, wenn die Änderungen bereits in ein gemeinsames Repository übertragen wurden.

Git Reset bietet drei Modi:

1. Soft Reset: Verschiebt den Commit-Zeiger zurück zu einem bestimmten Commit, behält aber die Änderungen im Arbeitsverzeichnis und im Staging-Bereich bei. Das ist nützlich, wenn du eine Übergabe wiederholen, aber deine Änderungen beibehalten willst. 

git reset --soft <commit-hash>

2. Gemischter Reset: Verschiebt den Commit-Zeiger zurück zu einem bestimmten Commit und behält die Änderungen im Arbeitsverzeichnis, löscht aber den Staging-Bereich. Dies ist der Standard-Reset-Modus von Git.

git reset --mixed <commit-hash>

3. Hard Reset: Verschiebt den Commit-Zeiger zurück zu einem bestimmten Commit und verwirft alle Änderungen im Arbeitsverzeichnis und im Staging-Bereich. Dadurch wird dein Repository auf den Stand des gewählten Commits zurückgesetzt und alle Änderungen, die nach dem Commit gemacht wurden, werden gelöscht. 

git reset --hard <commit-hash>

Der Befehl git reset ist ein mächtiges Werkzeug, aber es ist wichtig, seine Auswirkungen zu verstehen (besonders wenn du in einer kollaborativen Umgebung arbeitest).  

Best Practices für das Commit in Git

Eine effektive Versionskontrolle erfordert mehr als nur die Kenntnis der Git-Befehle - es bedeutet auch, bestimmte Best Practices zu befolgen, um eine saubere, verständliche und effiziente Projekthistorie zu führen. Diese Praktiken helfen dir nicht nur dabei, deine eigene Arbeit zu verwalten, sondern erleichtern es auch den Mitarbeitern, Änderungen beizutragen und zu überprüfen.

Engagiere dich häufig, aber halte es klein

Eine gute Faustregel ist, sich früh und oft zu engagieren, aber jedes Engagement klein und konzentriert zu halten. Dieser Ansatz stellt sicher, dass jeder Commit eine eindeutige und logische Arbeitseinheit darstellt. 

Häufiges Committen kann dabei helfen, große Änderungen in überschaubare Teile zu zerlegen, was es einfacher macht, das Projekt zu überprüfen, zu testen und die Entwicklung nachzuvollziehen. Indem du kleinere, isolierte Änderungen vornimmst, verringerst du auch das Risiko, komplexe Fehler einzuführen. Wenn etwas schief geht, ist es einfacher, das Problem zu isolieren und zu beheben, wenn die Commits granular sind.

Nur verwandte Änderungen festschreiben

Jeder Commit sollte sich auf eine einzelne Aufgabe oder ein Problem konzentrieren. Das Vermischen von nicht zusammenhängenden Änderungen in einem Commit macht es schwieriger, die Absicht hinter den Änderungen zu überprüfen und zu verstehen. Außerdem wird es dadurch schwieriger, bestimmte Änderungen bei Bedarf rückgängig zu machen oder herauszupicken.

Wenn du zum Beispiel an einem Feature arbeitest, aber an einer anderen Stelle des Codes einen kleinen Fehler entdeckst, ist es besser, dies als zwei separate Commits zu behandeln. Dies ermöglicht ein klares Verständnis dessen, was getan wurde und warum - es stellt auch sicher, dass jeder Commit sinnvoll und isoliert ist.

Mit anderen an der Commit-Historie zusammenarbeiten

Wenn du in einem Team arbeitest, ist es wichtig, dass du dich mit deinen Kollegen darüber abstimmst, wie Commits behandelt und präsentiert werden. Dazu gehört auch, dass du dich auf ein einheitliches Format für Commit-Meldungen einigst und dafür sorgst, dass sich alle an bewährte Verfahren halten. Git-Hooks, wie z.B. Pre-Commit-Hooks, können dabei helfen, Regeln durchzusetzen, wie z.B. das Format von Commit-Nachrichten oder die Durchführung von Tests, bevor ein Commit erlaubt ist.

Die Zusammenarbeit wird auch durch Tools verbessert, die bei der Verwaltung und Überprüfung von Commits helfen, z. B. Code-Review-Plattformenwie GitHub oder GitLab. Ein klarer, gut dokumentierterCommit-Verlauf macht es den Teammitgliedern leichter, Änderungen zu verstehen, Verbesserungen zu diskutieren und das Projekt effizient voranzutreiben.

> Willst du die übrig gebliebenen Dateien aufräumen, bevor du dich verpflichtest? Lerne, wie du git clean in tdiesem Tutorial zum Entfernen von nicht verfolgten Dateien verwendest.

Fehlerbehebung bei häufigen Git Commit-Problemen

Git-Commits können manchmal zu Fehlern oder Herausforderungen führen, die deinen Arbeitsablauf verlangsamen können. Das Wissen um die Behebung dieser häufigen Probleme ist entscheidend für eine reibungslose Versionskontrolle und die Vermeidung größerer Probleme.

Fehler in der Commit-Nachricht

Ein häufiger Fehler beim Übertragen von Änderungen ist, dass du vergisst, eine Commit-Nachricht hinzuzufügen oder versehentlich eine vage oder leere Nachricht verwendest. Klare und aussagekräftige Commit-Meldungen sind wichtig, um Änderungen nachzuvollziehen und den Mitwirkenden den Verlauf eines Projekts zu zeigen. Git verhindert in der Regel, dass du dich ohne eine Nachricht verpflichtest, aber es ist immer noch möglich, die Qualität der Nachricht selbst zu übersehen.

Lösung: Überprüfe deine Commit-Meldung immer doppelt, bevor du die Eingabetaste drückst. Wenn du versehentlich einen Commit mit einer leeren oder unklaren Nachricht abgibst, kannst du dies mit dem Befehl git commit --amend korrigieren, um die letzte Commit-Nachricht zu ändern. 

Konflikte nach der Übertragung

Konflikte sind unvermeidlich, wenn mehrere Personen an demselben Projekt arbeiten. Sie entstehen oft nach einem Commit, wenn du Zweige zusammenführst oder neu bindest. Ein Konflikt entsteht, wenn Git die Unterschiede zwischen zwei Commits nicht automatisch auflösen kann und du manuell entscheiden musst, welche Änderungen beibehalten werden sollen.

Konflikte treten am ehesten auf, wenn zwei oder mehr Mitwirkende denselben Abschnitt des Codes ändern oder wenn große Umstrukturierungen an einem Projekt vorgenommen werden. Sie können zwar entmutigend sein, aber Git bietet die Werkzeuge, um diese Konflikte ohne Datenverlust zu lösen.

Lösung: Wenn ein Konflikt auftritt, markiert Git die widersprüchlichen Abschnitte in den Dateien, und du musst sie manuell auflösen, indem du die Datei so bearbeitest, dass sie die gewünschten Änderungen enthält. Nachdem du die notwendigen Änderungen vorgenommen hast, führe die Datei mit git add aus und schließe dann merge oder rebase ab, indem du die beschlossenen Änderungen festlegst. Werkzeuge wie der Merge-Konflikt-Editor von Git oder externe Merge-Tools können dir auch helfen, Konflikte effizienter zu lösen.

Fazit

Der Befehl git commit ist ein grundlegender Aspekt der Versionskontrolle in Git, der es Entwicklern ermöglicht, Schnappschüsse ihrer Arbeit zu erstellen, die im Laufe der Zeit nachverfolgt, überprüft und wieder aufgerufen werden können. Commits dienen als Meilensteine in der Geschichte eines Projekts und verdeutlichen, welche Änderungen vorgenommen wurden, warum sie notwendig waren und wann sie umgesetzt wurden.

In diesem Tutorium haben wir die grundlegende Syntax und den Prozess eines Commits behandelt, von der Bereitstellung der Dateien mit git add bis zum Abschluss des Commits mit git commit. Wir haben besprochen, wie wichtig es ist, klare und prägnante Commit-Botschaften zu verfassen und dabei Best Practices zu befolgen, wie z.B. beschreibende Botschaften, die Verwendung des Präsens und die Beibehaltung der Kürze. 

Außerdem haben wir fortgeschrittene Optionen erkundet, wie z.B. das Commit ohne Staging und das Ändern von Commits, was dir mehr Flexibilität bei der Verwaltung deiner Änderungen bietet. Wir haben uns auch angeschaut, wie man Commits mit Befehlen wie git log, reverting und resetting verwaltet.

Bist du bereit, GitHub genauer zu erkunden? Unser Kurs "GitHub-Konzepte" befasst sich mit Forks, Branches, Issues und Best Practices der Zusammenarbeit. Wenn du dich auf einen realen Arbeitsablauf oder ein Vorstellungsgespräch vorbereitest, ist das Complete Git Cheat Sheet ein tolles Nachschlagewerk, das du immer zur Hand haben solltest!