Git in 30 Minuten verstehen – Leitfaden für Anfänger begeistern (2023)

Git in 30 Minuten verstehen – Ein Anfängerleitfaden für das Jahr 2023

In den vergangenen Jahren hat die Nutzung von Git sprunghaft zugenommen. Dieses populäre Versionskontrollsystem wird von großen Open-Source-Projekten wie Linux, von Entwicklerteams, Einzelentwicklern und sogar von Studenten verwendet.

Anfänger empfinden den Einstieg oft als herausfordernd, da Git viele neue und teilweise rätselhafte Befehle mit sich bringt.

In diesem umfassenden Git-Tutorial wirst du die Grundlagen dieses Versionskontrollsystems von Grund auf erlernen. Ein großer Vorteil von Git besteht darin, dass du nicht alles von Anfang an wissen musst, um damit zu beginnen. Bereits mit dem Wissen über 2-3 grundlegende Befehle kannst du direkt loslegen. Dein Verständnis kannst du nach und nach vertiefen.

Du musst nicht die gesamte Anleitung an einem Tag durcharbeiten. Wenn du sofort praktisch loslegen möchtest, empfehle ich dir außerdem unseren Git Schnellstart-Kurs. Wenn du lediglich eine Übersicht mit allen Git-Befehlen wünschst, steht das ‚LerneProgrammieren Git Cheatsheet‘ kostenlos in unserem Mitgliederbereich zum Download bereit.

Lass uns loslegen!

Was ist Git? – Git in 30 Minuten verstehen

Git – Dein Werkzeugkasten in der Befehlszeile: Verfolgen und Aufzeichnen von Änderungen

Git ist eine Zusammenstellung von Befehlszeilen-Dienstprogrammen, die dazu dienen, Änderungen in Dateien zu verfolgen und aufzuzeichnen. Dies betrifft in der Regel Quellcode, aber es können auch diverse andere Dateiformate wie Text- oder sogar Bilddateien verfolgt werden.

Diese Funktionalität ermöglicht es dir, frühere Versionen deines Projekts wiederherzustellen, diese miteinander zu vergleichen, zu analysieren, Änderungen zusammenzuführen (mergen) und vieles mehr.

Der gesamte Prozess wird als Versionskontrolle bezeichnet. Es existieren mehrere Versionskontrollsysteme, die diese Aufgabe erfüllen. Vielleicht sind dir einige davon bekannt: Perforce, Mercurial, CVS, SVN und mehr.

Git zeichnet sich durch seine Dezentralisierung aus, was bedeutet, dass es nicht von einem zentralen Server abhängig ist, um ältere Versionen deiner Dateien zu speichern. Stattdessen funktioniert es komplett lokal, indem es diese Daten als Ordner auf deiner Festplatte ablegt. Dieses Konzept nennen wir ein Repository.

1. Git installieren – Git in 30 Minuten verstehen

Vorbereitung für die Git-Nutzung: Installation und Werkzeuge

Bevor du mit Git arbeiten kannst, ist die Installation auf deinem Computer erforderlich. Hier ist eine unkomplizierte Anleitung für die gebräuchlichsten Betriebssysteme:

Windows: Unsere Empfehlung ist Git für Windows, da es sowohl einen GUI-Client als auch einen BASH-Kommandozeilenemulator bereitstellt.

Linux: Öffne einfach ein neues Terminal und installiere Git über den Paketmanager deiner Linux-Distribution. Bei Ubuntu beispielsweise verwendest du den Befehl sudo apt-get install git.

Mac OS X: Der einfachste Weg besteht darin, Homebrew zu installieren und dann über dein Terminal den Befehl brew install git auszuführen.

Wenn du lieber nicht mit Git auf der Kommandozeile arbeiten möchtest, kann ich dir Client-Programme wie GitHub Desktop und SourceTree (von Atlassian) empfehlen. Es gibt auch zahlreiche andere kostenlose Git-Programme. Selbst wenn du eine grafische Benutzeroberfläche (GUI) bevorzugst, ist es dennoch wichtig, die grundlegenden Git-Befehle zu kennen.

In diesem Git-Tutorial werden wir uns vorwiegend auf die Nutzung der Kommandozeile konzentrieren, da dies die beste Methode ist, um die Git-Befehle durch praktisches Ausprobieren zu erlernen (Learning by Doing).

2. Git konfigurieren- Git in 30 Minuten verstehen

Nach der erfolgreichen Installation von Git auf deinem Computer müssen noch einige Konfigurationen vorgenommen werden. Es gibt zahlreiche Optionen, die du anpassen kannst, beispielsweise das Erscheinungsbild und die Funktionalität des Clients. Hier werden jedoch nur die beiden wesentlichen Konfigurationen behandelt: das Festlegen deines Benutzernamens und deiner E-Mail-Adresse.

Folge diesen Schritten, um die Konfigurationen vorzunehmen:

1. Öffne das Programm ‚Git Bash‘ auf deinem Computer.
2. Führe die folgenden Befehle aus:

Öffne dazu das Programm ‚Git Bash‘, sofern installiert, und gib folgende Befehle ein:

git config --global user.name "Dein Benutzername"
git config --global user.email "deine@email.com"

Jede Handlung, die wir in Git ausführen, wird nun mit dem zuvor angegebenen Namen und der E-Mail-Adresse gekennzeichnet. Dadurch ist immer nachvollziehbar, wer welche Aktion wann durchgeführt hat. Dies schafft Klarheit inmitten des Chaos, insbesondere bei umfangreichen Projekten, an denen viele Entwickler beteiligt sind.

3. Die Erstellung eines neuen Repositories – git init – Git in 30 Minuten verstehen

Wie bereits erwähnt, speichert Git seine Dateien und Historie direkt als Ordner in deinem Projekt. Um ein neues Repository anzulegen, öffnen wir ein Terminal, navigieren zum Projektverzeichnis und führen den Befehl ‚git init‘ aus. Dadurch wird Git für diesen speziellen Ordner aktiviert und ein verstecktes .git-Verzeichnis erstellt, in dem die Historie und Konfiguration des Repositories gespeichert werden.

Um einen neuen Ordner mit dem Namen ‚git-bc-lernen‘ auf deinem Desktop zu erstellen, öffne ein neues Git-Terminal und gib Folgendes ein:

cd git-bc-lernen
git init

Die Befehlszeile sollte in etwa die folgende Ausgabe anzeigen:

Oder als Text:

Initialized empty Git repository in C:/Users/frank/git-bc-lernen/.git/

Dies zeigt an, dass das Repository erfolgreich erstellt wurde. Natürlich ist es derzeit noch leer. Um es zu befüllen, erstelle eine einfache Textdatei namens ‚lerneprogrammieren.txt‘ und speichere sie im Ordner ‚git-lernen‘.

Deine Struktur sollte etwa wie folgt aussehen:

4. Überprüfen des Status des Repositories – git status – Git in 30 Minuten verstehen

Git Status überprüfen – Ein weiterer wichtiger Befehl, den du kennen solltest, ist ‚git status‘. Dieser Befehl liefert Informationen über den aktuellen Zustand des Repositories.

Hast du die aktuellsten Änderungen? Gibt es Neuerungen? Was hat sich verändert? usw.

Führe den Status-Befehl folgendermaßen aus:

git status

Wenn du ‚git status‘ in unserem frisch erstellten Repository ausführst, erhältst du in etwa die folgende Ausgabe:

Oder als Textausgabe:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        bc-lerne-programieren.txt

nothing added to commit but untracked files present (use "git add" to track)

Die angezeigte Meldung besagt, dass ‚bc-lerne-programieren.txt‘ nicht verfolgt wird (genauer gesagt, nicht im Tracking ist). Dies bedeutet, dass die Datei neu ist und Git noch nicht entschieden hat, ob es die Änderungen an der Datei verfolgen oder sie ignorieren soll.

Um die neue Datei zu bestätigen, müssen wir sie ’stagen‘.

5. Staging – git add – Git in 30 Minuten verstehen

Git arbeitet mit einem Konzept namens ‚Staging Area‘ oder ‚Staging-Bereich‘. Stelle dir das vor wie eine leere Leinwand, auf der du die Änderungen platziert, die du für deinen nächsten Commit (Bestätigung) auswählen möchtest. Anfangs ist der Staging-Bereich leer, aber du kannst mit dem Befehl ‚git add‘ Dateien (oder sogar einzelne Zeilen und Teile von Dateien) hinzufügen. Dann kannst du mit ‚git commit‘ all diese Änderungen in einem Commit festhalten, quasi einen Momentaufnahme erstellen.

In unserem Fall haben wir nur eine Datei. Lass uns diese zur Staging-Area hinzufügen:

git add bc-lerne-programieren.txt

Wenn du alle Dateien im Verzeichnis hinzufügen möchtest, verwende den Befehl wie folgt:

git add -a

Nachdem du den obigen Befehl ausgeführt hast, überprüfe den Status erneut mit ‚git status‘. Du solltest dann folgende Ausgabe sehen:

git status

Oder als Textausgabe:

$ git status
On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   bc-lerne-programieren.txt

Unsere Datei befindet sich nun im Staging-Bereich. Die Statusmeldung gibt uns auch Auskunft darüber, welche Änderungen an den Dateien im Staging-Bereich vorgenommen wurden. In diesem Fall handelt es sich um das Hinzufügen einer neuen Datei. Weitere Statusmeldungen könnten sich auch auf Änderungen oder Löschungen von Dateien beziehen.

6. Commit erstellen – git commit – Git in 30 Minuten verstehen

Ein Commit stellt den Zustand unseres Repositorys zu einem bestimmten Zeitpunkt dar. Er gleicht einem Schnappschuss, den wir zu einem späteren Zeitpunkt wiederherstellen können. Dadurch können wir sehen, wie das Repository zu dem Zeitpunkt aussah, als wir den Schnappschuss (Snapshot) erstellt haben.

Um einen neuen Commit zu erzeugen, müssen wir mindestens eine Änderung im Staging-Bereich haben (was wir gerade mit ‚git add‘ gemacht haben). Hier ist, wie du deinen ersten Commit erstellst:

git commit -m "Mein erster Commit"

Ausgabe:

Oder als Textausgabe:

$ git commit -m "Mein erster Commit"
[master (root-commit) a030f55] Mein erster Commit
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 bc-lerne-programieren.txt

Dieser Befehl wird einen neuen Commit mit allen Änderungen aus dem Staging-Bereich erzeugen (hier das Hinzufügen von ‚bc-lerne-programmieren.txt‘). Die Option ‚-m‘ gefolgt von dem Text ‚Mein erster Commit‘ ist eine benutzerdefinierte Nachricht, die die Änderungen des Commits zusammenfasst.

Es ist ratsam, regelmäßig Commits durchzuführen und dabei möglichst präzise Commit-Nachrichten zu verwenden.

7. Remote-Repository – Git in 30 Minuten verstehen

Derzeit ist unser Commit lokal – er existiert nur im .git-Verzeichnis. Obwohl ein lokales Repository an sich bereits nützlich ist, werden wir in den meisten Fällen unsere Arbeit mit anderen Entwicklern teilen wollen. Dazu werden wir unser Repository auf einem Server oder in einem Repository-Hosting-Dienst (wie z.B. GitHub oder Bitbucket) bereitstellen.

7.1 Aufbau einer Verbindung zu einem Remote-Repository – git remote add – Git in 30 Minuten verstehen

Um Inhalte in ein Remote-Repository hochzuladen, müssen wir zuerst eine Verbindung zu diesem herstellen.

In diesem Tutorial verwenden wir die Adresse unseres Repositories als Beispiel: https://github.com/bc24/bc-lerne-programieren . Wir empfehlen dir jedoch, dein eigenes leeres Repository bei GitHub, Bitbucket oder einem anderen Dienst zu erstellen. Die Registrierung und Einrichtung des Repositories können einige Zeit in Anspruch nehmen, aber alle Plattformen bieten hilfreiche Schritt-für-Schritt-Anleitungen zur Erstellung.

Um unser lokales Repository mit dem auf GitHub zu verknüpfen, geben wir folgende Zeile im Terminal ein:

(Hinweis: Ersetze bitte die URL durch die URL deines eigenen Remote-Repositorys)

git remote add origin https://github.com/bc24/bc-lerne-programieren.git

Ein Projekt kann gleichzeitig mit mehreren Remote-Repositories verknüpft sein. Um sie zu unterscheiden, erhalten sie unterschiedliche Namen. In der Praxis wird das Haupt-Remote-Repository oft als ‚origin‘ (Ursprung) bezeichnet.

7.2 Übertragung von Änderungen auf den Remote-Server – git push – Git in 30 Minuten verstehen

Jetzt ist es an der Zeit, unsere lokalen Commits auf den Server zu übertragen. Dieser Vorgang wird als ‚Push‘ bezeichnet und wird immer dann ausgeführt, wenn wir das Remote-Repository aktualisieren möchten.

Der Git-Befehl dafür lautet ‚git push‘. Er erfordert zwei Parameter: 1) den Namen des Remote-Repositorys (wir haben es ‚origin‘ genannt) und 2) den Branch, auf den gepusht werden soll (normalerweise ist der ‚master‘ der Standard-Branch für jedes Repository).

git push origin master

Ausgabe:

Oder als Textausgabe:

$ git push origin master
info: please complete authentication in your browser...
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Delta compression using up to 8 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 228 bytes | 228.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/bc24/bc-lerne-programieren.git
 * [new branch]      master -> master

Je nachdem, welchen Remote-Dienst du verwendest, musst du möglicherweise vor dem Push-Vorgang eine Anmeldung durchführen. Wenn alles korrekt eingerichtet wurde, sollte die ‚lerneprogrammieren.txt‘-Datei verfügbar sein, wenn du das zuvor erstellte Remote-Repository in deinem Webbrowser aufrufst. In unserem Fall kannst du den durchgeführten Push unter dieser URL überprüfen: https://github.com/bc24/bc-lerne-programieren

7.3 Aktualisieren des lokalen Repositories mit Änderungen vom Remote-Server – git pull – Git in 30 Minuten verstehen

„Wenn du Updates in deinem Repository durchführst, können andere Entwickler diese Änderungen mit einem einzigen Befehl herunterladen – ‚git pull‘.

(In diesem Beispiel habe ich die Datei ‚test.txt‘ hinzugefügt. Jetzt werden wir diese Datei aus dem Remote-Repository durch einen ‚pull‘-Befehl holen.)

git pull origin master

Ausgabe:

Oder in Textform:

$ git pull origin master
From https://github.com/bc24/bc-lerne-programieren
 * branch            master     -> FETCH_HEAD
Already up to date.

8. Ein Repository klonen – ‚git clone – Git in 30 Minuten verstehen

An diesem Punkt können Teammitglieder auf GitHub dein Remote-Repository sehen und erkunden. Sie können es lokal herunterladen und mit dem Befehl ‚git clone‘ eine voll funktionsfähige Kopie deines Projekts erstellen:

git clone https://github.com/bc24/bc-lerne-programieren.git

Es wird automatisch ein neues lokales Repository erstellt, wobei die Version auf GitHub als Remote konfiguriert ist.

9. Branches – Git in 30 Minuten verstehen

Beim Entwickeln neuer Features ist es bewährte Praxis, an einer Kopie des Originalprojekts zu arbeiten, die als Branch bezeichnet wird. Branches haben ihre eigene Historie und isolieren Änderungen voneinander, bis sie schließlich wieder zusammengeführt werden. Dies geschieht aus verschiedenen Gründen:

1. Eine bereits funktionierende, stabile Version des Codes bleibt frei von unerwünschten Fehlern.
2. Mehrere Funktionen können gleichzeitig von verschiedenen Entwicklern sicher entwickelt werden.
3. Entwickler können auf ihren eigenen Branches arbeiten, ohne das Risiko, dass die Codebasis durch die Arbeit anderer Entwickler beeinträchtigt wird.
4. Bei Unsicherheit über die beste Herangehensweise können verschiedene Versionen desselben Features in verschiedenen Branches entwickelt und später verglichen werden.

9.1 Erstellung von Branches – ‚git branch‘ – Git in 30 Minuten verstehen

Der Standard-Branch in jedem Repository heißt ‚master‘. Um zusätzliche Branches zu erstellen, verwendest du den Befehl ‚git branch <Name>‘:

git branch feature1

Mit dem oben genannten Befehl erstellst du den Branch ‚feature1‘, der aktuell dem ‚master‘-Branch entspricht.

(Hinweis: Nach erfolgreichem Anlegen des Branches werden keine weiteren Meldungen angezeigt)

9.2 Zwischen Branches wechseln – git checkout – Git in 30 Minuten verstehen

Wir befinden uns momentan im ‚master‘-Branch. Jetzt möchten wir jedoch in unseren neu erstellten Branch ‚feature1‘ wechseln. Das erreichst du mit dem Befehl ‚git checkout‘, dem ein Parameter übergeben wird – nämlich der Name des Branches, zu dem du wechseln möchtest.

git checkout feature1

9.3 Branches zusammenführen – git merge – Git in 30 Minuten verstehen

Unser neues Feature (‚feature1‘) wird lediglich eine weitere Textdatei namens ‚button.txt‘ sein. Wir werden sie erstellen, hinzufügen und committen:

git add button.txt
git commit -m "Neues Feature fertig"

Das neue Feature ist vollständig implementiert. Nun können wir zurück zum ‚master‘-Branch wechseln:

git checkout master

Oh nein! Wo ist plötzlich unsere ‚button.txt‘ hin? Sie ist aus dem Dateisystem verschwunden.

Keine Sorge.

Das liegt daran, dass wir wieder im ‚master‘-Branch sind, und hier wurde die ‚button.txt‘ nie erstellt. Um sie im ‚master‘-Branch hinzuzufügen, müssen wir beide Branches zusammenführen (mergen) und die Änderungen, die im ‚feature1‘-Branch gemacht wurden, auf die Hauptversion des Projekts übertragen. Das mag komplex klingen, ist es aber nicht. Du benötigst erneut nur eine Zeile, um den Merge-Prozess durchzuführen:

git merge feature1

Der ‚master‘-Branch ist jetzt auf dem aktuellen Stand. Der ‚feature1‘-Branch wird nicht mehr benötigt und kann entfernt werden.

git branch -d feature1

Git für Fortgeschrittene – Git in 30 Minuten verstehen

Im ersten Teil des Git-Tutorials haben wir die Grundlagen behandelt. In diesem Teil werden wir uns einige fortgeschrittenere Funktionen von Git genauer ansehen.

10. Überprüfen von Unterschieden zwischen Commits – Git in 30 Minuten verstehen

Jeder Commit besitzt eine eindeutige ID in Form einer Zeichenfolge von Zahlen und Symbolen (SHA). Um eine Liste aller Commits und ihrer IDs anzuzeigen, verwenden wir den Befehl ‚git log‘:

git log

Ausgabe:

Oder als Textausgabe:

commit a030f551e19dbf2e1f62ba0079314f0d6e7343ba (HEAD -> master, origin/master)
Author: Frank <frank@panzerit.de>
Date:   Tue Aug 22 18:58:08 2023 +0200

    Mein erster Commit

Wie du sehen kannst, sind die IDs sehr lang. Du musst sie jedoch nicht manuell abtippen. Du kannst sie markieren und in die Zwischenablage kopieren. Alternativ reichen auch die ersten paar Zeichen aus, um Git den richtigen Commit zuzuordnen.

Um den Inhalt eines bestimmten Commits anzuzeigen, verwenden wir den Befehl ‚git show <Commit-ID>‘:

git show a030f551e19dbf2e1

Ausgabe:

Oder als Textausgabe:

$ git show a030f551e19dbf2e1
commit a030f551e19dbf2e1f62ba0079314f0d6e7343ba (HEAD -> master, origin/master)
Author: Frank <frank@panzerit.de>
Date:   Tue Aug 22 18:58:08 2023 +0200

    Mein erster Commit

diff --git a/bc-lerne-programieren.txt b/bc-lerne-programieren.txt
new file mode 100644
index 0000000..e69de29

Im oben gezeigten Output erhalten wir eine Fülle von Informationen zum Commit. Es werden Details zum Autor, ein Zeitstempel, die Commit-Nachricht sowie verschiedene Datei-Informationen, wie beispielsweise die hinzugefügten Zeilen innerhalb der Textdatei (‚ich bin ein Button‘), angezeigt.

11. Rückgängig machen von Änderungen an einer Datei auf eine frühere Version – Git in 30 Minuten verstehen

Git ermöglicht es uns, eine ausgewählte Datei auf den Zustand einer bestimmten Commit-Version zurückzusetzen. Dies erfolgt mithilfe des bekannten ‚git checkout‘-Befehls, den wir zuvor verwendet haben, um zwischen Branches zu wechseln. Er kann jedoch auch dazu verwendet werden, zwischen verschiedenen Commits zu navigieren. (In Git ist es recht häufig, dass ein Befehl für mehrere scheinbar nicht zusammenhängende Aufgaben verwendet wird.)

Im folgenden Beispiel nehmen wir die Textdatei ‚lerneprogrammieren.txt‘ und setzen sie auf den Zustand zurück, den sie im ersten Commit hatte. Dazu müssen wir die ID des Commits angeben, zu dem wir zurückkehren möchten, sowie den vollständigen Pfad zur Datei. Die entsprechende ID erhältst du über ‚git log‘. Führe anschließend den folgenden Befehl aus:

git checkout a030f551e19dbf2e1 bc-lerne-programieren.txt

12. Rückgängigmachen eines Commits – ‚git revert‘ – Git in 30 Minuten verstehen

Wenn du bemerkst, dass du in deiner Commit-Nachricht einen Tippfehler gemacht hast oder vergessen hast, eine Datei hinzuzufügen, kannst du den Fehler mit ‚git commit –amend‘ korrigieren.

Dies führt dazu, dass alles vom letzten Commit wieder in den Staging-Bereich verschoben wird. Gleichzeitig wird versucht, einen neuen Commit zu erstellen. Dadurch erhältst du die Möglichkeit, deine Commit-Nachricht zu bearbeiten oder weitere Dateien zum Staging-Bereich hinzuzufügen.

Für komplexere Korrekturen, die nicht den letzten Commit betreffen (oder wenn du deine Änderungen bereits gepusht hast), solltest du ‚git revert‘ verwenden. Dadurch werden alle Änderungen, die ein Commit vorgenommen hat, rückgängig gemacht, und es wird ein neuer Commit erstellt.

Der neueste Commit kann über das Alias ‚HEAD‘ angesprochen werden.

git revert HEAD

Für andere Commits empfiehlt es sich, deren ID zu verwenden. Die ID des betreffenden Commits findest du über den ‚git log‘-Befehl. Verwende dann den folgenden ‚git revert‘-Befehl:

git revert <Commit ID>

Beachte, dass beim Rückgängigmachen älterer Commits Fusionkonflikte wahrscheinlich auftreten können. Dies tritt auf, wenn eine Datei durch einen neueren Commit geändert wurde und Git nun möglicherweise nicht die passenden Zeilen zum Zurücksetzen findet, da sie nicht mehr vorhanden sind.

13. Dateien mit .gitignore ignorieren – Git in 30 Minuten verstehen

In den meisten Projekten gibt es Dateien oder Verzeichnisse, die wir nie committen möchten. Wir können sicherstellen, dass sie nicht versehentlich mit ‚git add -A‘ erfasst werden, indem wir eine .gitignore-Datei erstellen:

1. Erstelle manuell eine Textdatei namens ‚.gitignore‘ und speichere sie im Verzeichnis deines Projekts.
2. Listet darin die Namen der Dateien/Verzeichnisse auf, die ignoriert werden sollen, jeweils in einer neuen Zeile.
3. Die ‚.gitignore‘-Datei selbst muss hinzugefügt, committet und gepusht werden, da sie wie jede andere Datei im Projekt behandelt wird.

Gute Beispiele für Dateien/Verzeichnisse, die ignoriert werden sollen:

• Log-Dateien
• Builds von Task Runnern
• Der ’node_modules‘-Ordner in Node.js-Projekten
• Ordner, die von IDEs wie Netbeans und IntelliJ erstellt werden
• Persönliche Anmerkungen der Entwickler

Ein ‚.gitignore‘-File, das all diese Dinge ignoriert, könnte wie folgt aussehen:

*.log
build/
node_modules/
.idea/
meineKommentare.txt

Der Schrägstrich am Ende einiger Zeilen signalisiert, dass es sich um ein Verzeichnis handelt und alle darin befindlichen Dateien rekursiv ignoriert werden. Das Sternchen dient als Platzhalter (Wildcard).

Fazit zur ‚Git Lernen‘-Anleitung – Git in 30 Minuten verstehen

Wenn du es bis zu diesem Punkt in der Anleitung geschafft hast, dann gebührt dir Respekt! Wenn du jeden Abschnitt durchgearbeitet hast, hast du bereits eine solide Grundlage in Git erworben. Du kannst dieses Tutorial jederzeit als Referenz verwenden, wenn dir ein Git-Befehl entfallen ist oder du eine schnelle Nachschlagemöglichkeit benötigst.

Zusätzlich empfehle ich dir unseren kostenlosen Git-Spickzettel. Dort sind alle Git-Befehle kompakt aufgeführt. Du findest ihn im Mitgliederbereich von LerneProgrammieren.

In diesem Leitfaden habe ich versucht, die wichtigsten Informationen über das Versionskontrollsystem zu vermitteln. Git kann ziemlich komplex wirken und hat noch viele weitere Features und Tricks zu bieten.

An diesem Punkt hast du bereits etwa 90% der wichtigsten Funktionen und Befehle von Git erlernt.