Git - Verteilte Versionskontrolle für all deine Projekte

  • Schritt für Schritt geht's in deinem Projekt voran…, aber deine Version soll nicht entwurf_v12_ergänzung_korrektur_v2_FINAL2 heißen?
  • Die Gruppenarbeit nach 2 Jahren Arbeit veröffentlichen wollen…, aber wie führt ihr jetzt alle eure Änderungen zusammen?
  • Dein Programmierprojekt hat "letztes" doch noch funktioniert!? Könntest du doch nur nochmal die Zeit zurückspulen!

Mit Git existiert ein extrem mächtiges Werkzeug, um Zwischenversionen zu speichern und - verteilt über Raum und Zeit hinweg(!) - mit anderen zusammenzuarbeiten. Seit seiner Veröffentlichung ist Git zu dem Tool geworden, um Software-Entwicklung zu koordinieren, verwalten und zu veröffentlichen.

Selbst wenn du nichts mit Software-Entwicklung zu tun hast, sondern in den Kulturwissenschaften ein Interview-Transkript anfertigen musst: Git kann dir nützen!

Das Prinzip

Das Prinzip ist einfach und genial: du speicherst den Zustand von Dateien innerhalb eines Ordners, sodass du einen Schnappschuss zur Verfügung hast.
Diesen Schnappschuss versiehst du jedes Mal mit einem Kommentar, was sich darin verändert hat.

Wenn du mit den Inhalten experimentierst, machst du das sicherheitshalber in einem getrennten Bereich. Dieser zweigt von deinem Schnappschuss ab. Ein kleines Paralleluniversum deines Projekts sozusagen.

Diese beiden Paralleluniversen - ihre stetig "anwachsende" Historie von Zwischenspeicherpunkten und "abzweigende" Versionen - kannst du mit Git verwalten.
In Git heißen die veränderten Zustände "commits" (engl. "sich verpflichten" / "sich etwas widmen") und die "Abzweigungen" mit deinen Experimenten sind "branches" (engl. "Zweig").

Wichtig
Git kann sehr gut mit Dateien umgehen, die z.B. Texte enthalten oder deren Inhalt mit Text beschrieben ist, schließlich ist es ursprünglich für Code von Computerprogrammen entwickelt worden.
Anders sieht es hingegen bei z.B. Bild-, Video- oder Audiodateien aus: ihre Inhalte sind nicht grundsätzlich lesbar (nicht Zeilen- und Zeichenbasiert). Somit kann Git keine Unterschiede erkennen und speichert bei diesen Dateien die jeweils die ganze Datei bei Änderungen noch einmal komplett neu. Das kann dazu führen, dass ein Git-Projekt wegen solcher Dateien sehr groß wird, da bei jeder Änderung die komplette Datei neu abgespeichert wird, statt nur der Teile, die sich verändert haben.
Um dies zu umgehen gibt es Git-LFS oder Projekte wie Git-Annex.

Erste Schritte

Wichtig
Git an sich ist ein reines Kommandozeilen-Tool. Es gibt aber auch Programme mit grafischen Oberflächen (GUI) für Git. Mit Lazygit steht dir u.a. ein mächtiges und gutes Terminal-UI zur Verfügung, dass viele Schritte mit Git stark vereinfacht.

Grob unterteilt sich die Arbeit mit Git in folgende Schritte:

Projekt-Ordner vorbereiten

Zunächst musst du einen Projekt-Ordner vorbereiten - ein sogenanntes Git "Repository" (engl. "Lager" oder "Quelle") erstellen. In diesem liegen später deine Projektdateien. Dazu navigierst du über die Kommandozeile in Ordner und führst das Kommando git init aus. Git legt nun in dem Ordner einen weiteren versteckten(!) Ordner an, in dem es alles verwaltet.

Achtung
Dieser versteckte Ordner wird alle Dateien und Zustände deines Projekts enthalten. Wenn du ihn löschst, löschst du damit sämtliche Versionen deines Projekts und es wird nicht mehr von Git verwaltet!

Ein externes Repository herunterladen

Online wirst du viele Hinweise darauf finden, ein Git-Repository bei einer größeren Plattform oder Service anzulegen. Das ergibt vor allem Sinn, wenn du in einem Projekt mit anderen zusammenarbeiten oder einen anderen Speicherort als deinen Computer verwenden willst. Bei diesen Plattformen kannst du meist wählen, ob du ein öffentliches oder ein privates (nur für dich sicht- und durchsuchbares) Projekt anlegen willst.

Wenn du ein solches Repository selbst weiter bearbeiten willst, "klonst" du es auf dein Gerät mit dem Kommando git clone <URL>. Dabei lädt Git alle jemals zwischengespeicherten Versionen von diesem Repository herunter und legt einen Ordner an, in dem diese Projektdateien liegen.
Git weiß innerhalb dieses Ordners, woher die Daten heruntergeladen wurden. So kannst du später mit Git deine Änderungen wieder hochladen oder die neuesten Änderungen von Anderen herunterladen und in deinen lokalen Ordner integrieren.

Den Status überprüfen

Wenn du in einem Git-Repository arbeitest, solltest du immer zunächst den generellen Status des Repositories prüfen. Hier stehen z.B. Änderungen, neue Dateien, die Git noch nicht kennt oder ähnliches. Den Status eines Git-Repositories lässt du dir mit git status anzeigen.

Dateien und Ordner erstellen / ändern

Nun kannst du im Projekt-Ordner beliebig Dateien und Ordner erstellen, bearbeiten und mit Inhalten füllen. Sobald du einen Stand hast, den du zwischenspeichern willst…

Änderungen vormerken

…solltest du deine Änderungen zunächst vormerken! Git wird anschließend Änderungen an diesen Dateien verfolgen:
Das bedeutet, Git weiß, dass diese Datei (1.) dauerhaft von Git verwaltet werden soll und dich (2.) darauf hinweist, dass diese Dateien sich seit der letzten Zwischenspeicherung verändert haben.

Du kannst Veränderungen einzelner Dateien zum "commit" vormerken mit git add <DATEINAME>. Willst du alle veränderten Dateien im Verzeichnis vormerken, kannst du das mit git add . (der Punkt (.) steht dabei für "alles in diesem Ordner").

Änderungen committen

Möchtest du den derzeitigen Zustand dieser veränderten Dateien speichern, "commitest" du deine Änderungen daran mit git commit.

Es erscheint ein neues Fenster, in dem du eine "commit message" eingeben musst, also deine Änderungen beschreiben. Du kannst auch direkt eine Nachricht in einem einzigen Befehl hinterlegen mit git commit -m "<NACHRICHT>".

Bestätigst du deine Eingabe, speichert Git diese Änderungen, zusammen mit einer eindeutigen ID und deinem Kommentar. Dabei geht Git sehr effizient vor, indem es nur die Unterschiede zwischen den Versionen speichert (du speicherst beispielsweise nur eine veränderte Zeile Code, anstelle der gesamten Datei).

Änderungen ansehen

Möchtest du dir eine Liste bisheriger Änderungen ansehen, nutze dafür git log (ausführliche Darstellung) oder git log --oneline für eine kurze Zusammenfassung.
Hier listet Git alle Änderungen auf, zusammen mit deinen Kommentaren dazu. Außerdem hat jede gespeicherte Änderung eine eindeutige ID, unter der du diesen Zustand dir wieder ansehen kannst.

(bei externen Repositorien) Änderungen von einem entfernten Projekt holen

Wenn du mit einem entfernten Git-Repository mit anderen arbeitest, solltest du, bevor(!) du weiterarbeitest, unbedingt die neuesten Änderungen von anderen Personen in dein lokales Git-Repository übernehmen. Das machst du mit git pull.

(bei externen Repositorien) Änderungen an ein entferntes Projekt übertragen

Hast du im ersten Schritt ein entferntes Git-Repository "geklont", d.h. von einer Plattform wie Codeberg, GitLab oder GitHub bezogen, arbeitest du quasi mit anderen an einem gemeinsamen Projekt. Deine Änderungen solltest du (sobald du einen sinnvollen Beitrag hast) dort hin zurückübertragen. So sehen andere, woran du arbeitest.

Mit git push überträgst du deine Änderungen an das entfernte Repository. Damit "schiebst" du deine Änderungen quasi zurück an den Ort, woher du alle Projektdateien bezogen hast.

In einer neuen, abweichenden Version arbeiten ("Branch")

Manchmal willst du experimentieren und an der jetzt vorliegenden Version deines Projekts etwas verändern, bei dem du dir noch unsicher bist, ob es danach noch funktioniert.

Dazu erstellst du quasi eine "Arbeitskopie" dafür: einen "Branch" (engl. "Zweig" oder "Abzweigung"). Das tust du mit dem Befehl git branch <BRANCH-NAME>.

Um an dem jeweils einen oder anderen Branch zu arbeiten, kannst du zwischen ihnen mit git switch <BRANCHNAME> wechseln.

Branches Zusammenbringen: Merge

Hast du in einem abweichenden Branch gearbeitet, musst du irgendwann die dort gemachten Änderungen wieder in den Haupt-Branch (oder einen anderen) übernehmen. Dazu führst du beide Branches zusammen (engl. "merge" für "verschmelzen"). Arbeitest du lokal mit Branches, machst du das z.B. über den Befehl git merge:
Möchtest du die Änderungen aus Branch test in den Branch final übernehmen, würdest du z.B. git merge final test ausführen.
Auch hierbei wirst du eine "commit message" angeben müssen, was bei diesem Schritt geändert wurde.

Tipp:
Oft fließt deine Arbeit nicht "einfach so" zurück in den Branch, sondern muss vorher von anderen begutachtet, diskutiert und genehmigt werden. Vor allem bei den genannten Git-Plattformen erstellst du an dieser Stelle oft "Merge-Requests". Dies ist quasi die formale Bitte, deine Änderungen anzunehmen. Deine Änderungen am Code oder an Projektdateien sind dabei noch nicht übernommen, sondern du legst sie zunächst zur Prüfung vor, die anschließend noch von anderen Entwickler*innen genehmigt werden muss.

Zurückspulen: vorige Zustände ansehen

Du willst noch mal sehen, wie dein Projekt vor einiger Zeit aussah?
Rufe mit git log oder der kurzfassung git log --oneline eine Liste aller Änderungen auf. Jeder commit hat ja jeweils eine eindeutige ID am Anfang, die du - cool, wie du bist ;) - "auschecken" kannst: git checkout <ID-NUMMER>. Damit schaust du dir deinen Projektordner in dem Zustand an, wie es zu dem Zeitpunkt dieser Änderung aussah.

Git wird dazu quasi alle seitdem gemachten Änderungen zurückspulen, sodass der Inhalt z.B. deines Ordners wieder genau wie früher war.
Wenn du wieder zurück zu dem eigentlich aktuellen Zustand deines Projekts zurückkehren willst, kannst du das mit git checkout <BRANCHNAME> tun.

Noch mal von vorn: Änderungen zurücknehmen

Na, ist dein letzter Schritt total daneben gegangen und du willst ihn lieber ungeschehen machen?
Was im echten Leben oft nicht so einfach ist - Git kann das! Schau dir wieder die Liste aller Änderungen mit git log bzw. git log --oneline an und suche die Schritte, die zu zurücknehmen willst. Hier gibt es leider einiges zu beachten - schließlich machst du eine Zeitreise!

Mit git revert <COMMIT-ID> erstellst du eine neue Änderung, die eine bereits geschehene Veränderung Zurücknimmt. Das bedeutet, dass du z.B. eine wüste Beleidigung zurücknehmen kannst, aber immer noch im "Ablaufprotokoll" stehen wird, dass diese mal gefallen ist und du sie zwei Änderungen später entfernt hast. Das Zurücknehmen wird eine neue Änderung sein, die du "dem Lauf der Dinge" hier hinzufügst.

Mit git reset --hard <COMMIT-ID> setzt du den Zustand "hart" auf einen anderen zurück und löschst Dateien oder Inhalte von Dateien, die du zurücknehmen willst.

Achtung!
Mit git reset --hard löschst du womöglich Inhalte. Das funktioniert aber nur problemlos, wenn du allein an einem Projekt arbeitest bzw. nur lokal bei dir diese Änderungen geschehen. Arbeitest du gemeinsam mit Anderen über z.B. eine Git-Plattform zusammen, haben diese jeweils eigene Kopien des Repositories und besitzen diese Inhalte vielleicht noch. Hier kann es also dazu kommen, dass nicht mehr ein gleicher Zustand bei allen Beteiligten existiert!

Hinweis:
Es gibt noch weitere Möglichkeiten, im Verlauf der Änderungen zurückzuspulen. Sowohl mit als auch ohne Dinge zu verändern oder kaputtzumachen. Diese beiden Schritte sollen dir nur einen ersten Einblick geben.

Fazit

Mit Git steht dir ein enorm mächtiges Werkzeug zur Verfügung:
nicht nur, dass du die Inhalte eines Ordners mit Kommentaren zwischenspeichern kannst. Du kannst sie sogar rückgängig machen und in allen Zwischenschritten noch mal ansehen. Jeder Ordner auf deinem System kann mit Git potenziell mit anderen Personen über das Internet, im lokalen Netzwerk oder einfach auf demselben Gerät synchronisiert werden!

Die einzelnen Branches könntest du nicht nur in einem Ordner abrufbar machen, sondern mit Git-Worktrees gleichzeitig in mehreren Branches arbeiten.

Und nicht nur über Plattformen lässt sich ein Git Repository anlegen:
mit Bare Repos bringt Git direkt die Funktion mit, um ein Repository irgendwo auf deinem lokalen System zu erstellen, dessen Inhalt dann in einem anderen Ordner auf dem System wieder als Ordner-Inhalt angezeigt wird. Hast du einen SSH-Zugriff auf den Systemen, kannst du ohne dauerhafte Internet-Verbindung in einem Netzwerk trotzdem mit mehreren Personen an einem Projekt arbeiten.

(Fast) alles geht - mit Git!

https://www.git-scm.com

Hilfe

Video-Tutorials