Konventionelle Commits retten deine Commit-Nachrichten nicht

Eine kurze Internetrecherche zeigt eine Vielzahl von Artikeln, die dir beibringen, wie du Commit-Nachrichten schreibst. 90% dieser Artikel raten zu konventionellen Commits. Dennoch haben viele Entwickler weiterhin Schwierigkeiten damit. Sie wissen, dass sie sich an diese Konventionen halten sollten, aber sie finden es schwierig, sie in der Praxis anzuwenden. Jedes Mal, wenn sie Code committen, grübeln sie darüber nach, ob sie "refactor" oder "chore" schreiben sollen. Ich habe sogar Projekte gesehen, bei denen die Commit-Nachrichtensammlung ganz aus der gleichen Nachricht bestand: "feat: add page", da das Schreiben von Commit-Nachrichten für sie zu herausfordernd war und sie schließlich aufgaben.

Es ist zu früh, um über konventionelle Commits zu sprechen#

Ich sage nicht, dass konventionelle Commits schlecht sind. Sie haben viele bekannte Vorteile:

• Sie bieten ein einheitliches Format, wodurch Commit-Nachrichten standardisierter werden
• Sie sind einfach für automatisierte Tools zu parsen, was die automatische Generierung von Änderungsprotokollen ermöglicht
• Sie helfen Teammitgliedern, den Zweck und Umfang von Codeänderungen zu verstehen
• Sie ermöglichen eine schnelle Identifikation verschiedener Arten von Codeänderungen

Wenn jedoch ein Entwickler, selbst nach der Nutzung von konventionellen Commits, weiterhin Schwierigkeiten hat, gute Commit-Nachrichten zu schreiben, ist es sinnlos, ihm einen Artikel darüber zu geben, wie man konventionelle Commits nutzt und ihnen beizubringen, was feat oder fix bedeutet. Es ist, als würde man einem Kochanfänger ein fortgeschrittenes Kochbuch geben, ohne ihm zu zeigen, wie man grundlegende Zutaten und Utensilien verwendet. Dennoch gibt es solche Artikel überall im Internet. Nur wenige wissen, dass konventionelle Commits wirklich effektiv sein können, wenn Entwickler klar denken und in der Lage sind, Aufgaben präzise zu unterteilen.

Also, konventionelle Commits sind nicht schlecht, aber bevor wir darauf eingehen, müssen wir die richtige Entwicklungsmentalität etablieren und wissenschaftliches Entwicklendenken nutzen.

Wichtige Denkweisen für gute Commit-Nachrichten#

Codeänderungen sollten eine Sache auf einmal tun#

In der Softwareentwicklung ist "eine Sache auf einmal tun" ein wichtiges Prinzip. Dies gilt nicht nur für das Schreiben von Code, sondern auch für das Committen von Code. Wenn wir uns auf eine bestimmte Aufgabe oder Änderung konzentrieren, wird unser Code klarer und unsere Absichten deutlicher. Diese Methode verbessert nicht nur die Code-Lesbarkeit, sondern vereinfacht auch den Code-Review-Prozess erheblich. Reviewer können leichter den Zweck jeder Änderung verstehen und überprüfen.

Darüber hinaus bietet diese Methode Bequemlichkeit für potenzielle Code-Rollbacks. Wenn Probleme auftreten, können wir bestimmte Änderungen leichter finden und rückgängig machen, ohne andere nicht zugehörige Teile zu beeinträchtigen. Am wichtigsten ist, dass, wenn jede Änderung nur eine Sache tut, die Commit-Nachricht, die diese Änderung beschreibt, natürlicher präziser und bedeutungsvoller wird.

In der Praxis bedeutet dies, dass wir die zu erledigende Aufgabe klar definieren müssen, bevor wir mit dem Codieren beginnen. Nach Abschluss einer Aufgabe sollten wir den Code sofort committen, anstatt zu warten, bis mehrere Aufgaben abgeschlossen sind, bevor wir sie zusammen committen. Wenn wir während der Ausführung der aktuellen Aufgabe auf andere Bereiche stoßen, die angepasst werden müssen, ist der beste Ansatz, sie zu notieren und separat nach Abschluss der aktuellen Aufgabe zu bearbeiten. Wenn du beispielsweise ein Feature implementierst und bestehende Bugs entdeckst, solltest du den Bug nicht sofort mit deinem neuen Code beheben, sondern erst das Feature implementieren, dann den entdeckten Bug in einem anderen Commit beheben, oder den Bug zuerst beheben und dann das Feature committen.

Commit-Nachrichten existieren tatsächlich, bevor du den Code schreibst#

Viele Entwickler denken erst darüber nach, wie sie Commit-Nachrichten schreiben sollen, nachdem sie den Code abgeschlossen haben, aber in Wirklichkeit sollten Commit-Nachrichten schon existieren, bevor wir mit dem Codieren beginnen. Das liegt daran, dass Commit-Nachrichten im Wesentlichen die Schritte widerspiegeln, die wir unternehmen, um eine Aufgabe abzuschließen. Mit anderen Worten, sie sind unsere To-Do-Punkte.

Wenn wir eine Aufgabe beginnen, sollten wir zuerst darüber nachdenken, welche spezifischen Schritte erforderlich sind, um diese Aufgabe abzuschließen. Diese Schritte sind unsere To-Do-Liste, und gleichzeitig sind sie unsere zukünftigen Commit-Nachrichten. Mit dieser To-Do-Liste hat jede unserer Codeänderungen einen Zweck und hält uns beim Codieren konzentriert, sodass wir nicht vom Kurs abkommen.

Wesentlich wichtiger ist, dass diese Methode unsere Effizienz erheblich steigern kann. Wenn wir einen Schritt abschließen, ist die entsprechende Commit-Nachricht bereits vorbereitet, und wir können sie direkt verwenden, wodurch die Zeit, die für das Nachdenken über die Beschreibung der Änderung benötigt wird, verringert wird. Gleichzeitig sind diese Commit-Nachrichten von höherer Qualität und informativer, da sie fertiggestellt wurden, als wir ein umfassendes Verständnis der Aufgabe hatten.

Angenommen, du musst ein neues Benutzerregistrierungs-Feature implementieren. Du könntest deine Aufgaben so planen:

1. Refaktoriere die bestehende Formular-Komponente, um sie allgemeiner und wiederverwendbarer zu machen
2. Erstelle ein Benutzerregistrierungs-Formular
3. Implementiere die API-Integration für die Benutzerregistrierung
4. Füge Unit-Tests für das Benutzerregistrierungs-Feature hinzu
5. Aktualisiere die Dokumentation für das Benutzerregistrierungs-Feature

Die Commit-Nachrichten, die diesen Aufgaben entsprechen, könnten wie folgt sein:

1. refactor: Verbessere die bestehende Formular-Komponente zur Wiederverwendbarkeit
2. feat: Erstelle Benutzerregistrierungsformular
3. feat: Implementiere Benutzerregistrierungs-API-Integration
4. test: Füge Unit-Tests für Benutzerregistrierung hinzu
5. docs: Aktualisiere Dokumentation für Benutzerregistrierungs-Feature

Auf diese Weise hast du klare Aufgaben und entsprechende prägnante Commit-Nachrichten, bevor du mit dem Codieren beginnst. Diese Commit-Nachrichten sind tatsächlich deine To-Do-Liste und führen dich durch den gesamten Prozess der Feature-Implementierung.

Während du jeden Schritt abschließt, kannst du die entsprechende Commit-Nachricht verwenden, um deinen Code zu committen. Dies hilft dir nicht nur, Aufgaben besser zu organisieren und auszuführen, sondern stellt auch sicher, dass sich jedes Commit auf einen bestimmten Schritt konzentriert, was den gesamten Entwicklungsprozess klarer und überschaubarer macht. Wenn du während des eigentlichen Codierens die Commit-Nachricht geringfügig anpassen musst, kannst du kleinere Änderungen vornehmen, um die tatsächlichen Änderungen genauer zu beschreiben.

Konventionelle Commits werden zur natürlichen Wahl#

Wenn wir die richtige Entwicklungsmentalität entwickeln, wird die Nutzung von konventionellen Commits natürlich. An diesem Punkt stellst du fest, dass es mühelos wird, das passende Typpräfix (wie feat, fix, refactor, etc.) zu wählen, weil deine Commit-Nachrichten bereits deutlich deine Aufgaben widerspiegeln.

Wenn du mehr darüber erfahren möchtest, wie man konventionelle Commits nutzt, gibt es viele hervorragende Artikel online. Aber denke daran, dass diese Standards nur dann wirklich effektiv sein können, wenn sie auf der Grundlage der richtigen Entwicklungsmentalität aufgebaut sind.

Fazit#

Gute Commit-Nachrichten zu schreiben, bedeutet nicht nur, einem bestimmten Format zu folgen. Es erfordert, während des Entwicklungsprozesses klar zu denken, den Zweck jeder Änderung zu klären und darüber nachzudenken, wie wir unsere Arbeit beschreiben, bevor wir mit dem Codieren beginnen.

Konventionelle Commits sind in der Tat ein nützliches Werkzeug, aber sie können nur dann ihre maximale Wirkung entfalten, wenn sie mit der richtigen Entwicklungsmentalität kombiniert werden. Durch die Anwendung der beiden Prinzipien "eine Sache auf einmal tun" und "über Commit-Nachrichten im Voraus nachdenken" können wir nicht nur die Qualität der Commit-Nachrichten verbessern, sondern auch die allgemeine Effizienz der Entwicklung und die Codequalität steigern.

Ich hoffe, dieser Artikel hilft dir, deinen Entwicklungsprozess neu zu überdenken und ermutigt dich, diese Methoden auszuprobieren. Denk daran, dass gute Entwicklungsgewohnheiten Zeit brauchen, um sich zu entwickeln, aber sobald sie sich gebildet haben, werden sie deine Arbeitseffizienz und die Codequalität erheblich verbessern.