Git Basics

Dieses Git Repository soll ein Überblick für die grundlegenden Git-Befehle bieten. Weitere Informationen zu den verwendeten Befehle sowie zu weiteren Git-Befehlen gibt es [hier]

Verwendete Befehle

Eine Tabelle zur Übersicht der verwendeten Befehle

Projekterstellung

Um Git zu benutzen muss erst ein Git Repository initialisiert (erstellt) werden. Zur Erstellung eines lokalen Git Repositories wird der folgende Befehl verwendet: git init

• Falls kein Git Repository existiert, wird ein neues Repository lokal angelegt.
• Falls bereits ein Git Repository existiert, wird das Repository neu initialisiert, dabei werden keine Daten überschrieben

Zum anlegen von Git Repositories wird standardmäßig das aktuelle Verzeichnis genutzt. Um in einen bestimmten Verzeichnis ein Git Repository anzulegen kann der Pfad als weiterer Parameter angegeben werden.

Beispiel: Als Beispiel gibt es die folgende Verzeichnisstruktur, wobei das aktuelle Verzeichnis mit einem * markiert ist:

~/DIRECTORY_1
~/DIRECTORY_2 (*)

git init ~/DIRECTORY_1

git init

Änderungen speichern

Das Hinzufügen von Dateien/Verzeichnissen erfolgt in zwei Schritten.

1. Dokumente/Verzeichnisse zum Staging-Bereich (staging area) hinzufügen
2. Dokumente/Verzeichnisse des Staging-Bereichs als neue Version speichern (Commit als neue Projektversion)

Staging-Bereich

Der Staging-Bereich dient als Sammlung von Dokumenten/Verzeichnissen deren Veränderungen gespeichert werden sollen.

Dokumente/Verzeichnisse befinden sich nicht automatisch im Staging-Bereich. Es müssen also alle Dokumente/Verzeichnisse explizit zum Staging-Bereich hinzugefügt werden.

Dokumtente/Verzeichnisse können mit git add <file/directory> oder git stage <file/directory> zum Staging-Bereich hinzugefügt werden. Mit git add . werden alle Dokumente/Verzeichnisse im aktuellen Verzeichniss zum Staging-Bereich hinzugefügt.

Dokumente/Verzeichnisse können mit git restore --staged <file/directory> wieder aus dem Staging-Bereich entfernt werden.

Um sich eine Übersicht zum Stand des Repository (der aktuellen Branch) zu verschaffen kann der Befehl git status genutzt werden. Der Befehl vergleicht dafür den aktuellen Stand mit dem Stand des letzten Commits.

Dabei werden folgende Informationen berücksichtigt:

• Veränderte/bearbeitete Dokumente/Verzeichnisse
• Dokumente/Verzeichnisse in dem Staging-Bereich
• Informationen zur aktuellen Branch

Beispiel:

• In dem Beispiel wurden bereits Dokumente/Verzeichnisse zum Staging-Bereich hinzugefügt
• Dokumente/Verzeichnisse die sich im Staging-Bereich befinden sind mit einem (+) markiert

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt

git add DIRECTORY_2

git add file_2.txt

git add .

~/DIRECTORY_1 (+)
~/DIRECTORY_2 (+)
~/file_1.txt (+)
~/file_2.txt

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt (+)

~/DIRECTORY_1 (+)
~/DIRECTORY_2 (+)
~/file_1.txt (+)
~/file_2.txt (+)

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt

git restore --staged DIRECTORY_1

git restore --staged file_1.txt

git restore --staged .

~/DIRECTORY_1
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt
~/file_2.txt

~/DIRECTORY_1
~/DIRECTORY_2
~/file_1.txt
~/file_2.txt

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt

git status

On branch main

Staging Area:
~/DIRECTORY_1
~/file_1.txt

Untracked:
~/DIRECTORY_2
~/file_2.txt

Projektversion anlegen

Eine neue Projektversion wird mithilfe der Dokumente/Verzeichnisse, die sich im Staging-Bereich befinden, erstellt. Dokumente/Verzeichnisse die sich nicht im Staging-Bereich befinden werden nicht für die neue Projektversion verwendet.

Eine neue Projektversion wird nur im lokalen Repository erstellt!

Eine Projektversion wird in Git: Commit genannt und kann mit git commit -m "commit message" erstellt werden. Mit dem Parameter -m kann ein Text für den aktuellen Commit (die neue Projektversion) gespeichert werden.

Dokumente/Verzeichnisse die mit einem Commit als neue Projektversion gespeichert werden, werden automatisch wieder aus dem Staging-Bereich entfernt.

Beispiel:

• In dem Beispiel wurden bereits Dokumente/Verzeichnisse zum Staging-Bereich hinzugefügt.
• Dokumente/Verzeichnisse die sich im Staging-Bereich befinden sind mit einem (+) markiert

~/DIRECTORY_1 (+)
~/DIRECTORY_2
~/file_1.txt (+)
~/file_2.txt

git commit -m "Add files/directories"

~/DIRECTORY_1
~/DIRECTORY_2
~/file_1.txt
~/file_2.txt

Branching

In Git gibt es Branches. Eine Branch ist ein Verweis (Pointer) auf einen bestimmten Commit.

 b1              main
 V                V
c1 <- c2 <- c3 <-c4

Änderungen die auf einer Branch mit einem Commit gespeichert werden, sind nur auf dieser Branch (als Commit) vorhanden. Jede Branch kann eigene Commits mit unterschiedliche Dokumente/Verzeichnisse speichern. Diese Unterschiede werden als Verzweigungen der Commits sichtbar. (git log --graph --oneline --all)

               b2
               V
 b1     c3 <- c4        main
 V      /               V
c1 <- c2 <- c5 <-c6 <- c7

Häufig gibt es eine Hauptbranch (main/master) von der andere Branches abzweigen.

Branch Operationen

Um Operationen mit Branches durchzuführen ist es sinnvoll einen Überblick zu allen existierenden Branches zu bekommen.

Die lokalen Branches können mit dem Befehl git branch angezeigt werden.
Mit den Optionen -r werden die remote Branches und mit -a lokal und remote Branches angezeigt.

Zum anzeigen der Branches kann zusätzlich die --list Option gesetzt werden, um mit einem Muster zu filtern. Die aktuelle lokale Branch wird mit einem * markiert.

Zum erstellen einer neuen Branch kann git branch <BRANCH_NAME> [<COMMIT/BRANCH>] verwendet werden.
Mit dem Parameter ([<COMMIT/BRANCH>]) kann ein Commit oder eine Branch als Grundlage für die zu erstellende Branch angegeben werden. Ohne diesen zusätzlichen Parameter ist die Grundlage der letzte Commit der aktuellen Branch.
Mit git checkout -b <NEUE_BRANCH> [<COMMIT/BRANCH>] wird zusätzlich zu der neu erstellten Branch gewechselt.

Zum entfernen einer Branch kann git branch -d <BRANCH_NAME> verwendet werden.

Zum wechseln zu einer anderen Branch kann git checkout <BRANCH_NAME> verwendet werden.

Anstatt eine Branch anzugeben kann auch ein Commit durch den Commit-Hash oder einen relativen Pfad angegeben werden!
Ein relativer Pfad verweist auf einen Commit zuvor, von dem der aktuelle Commit abhängt. Ein relativer Pfad kann von einem Commit (Commit-Hash~1), einer Branch (Branch~1) oder dem HEAD (HEAD~1) angegeben werden.

Beispiel:

• Commits werden mit c markiert
• Aktuelle Branch wird mit einem (*) markiert

b1                     main (*)
V                       V
c1 <- c2 <- c3 <- c4 <- c5

git branch b2

git branch b2 b1

git branch b2 c3

                       b2
b1                     main (*)
V                       V
c1 <- c2 <- c3 <- c4 <- c5

b2
b1                     main (*)
V                       V
c1 <- c2 <- c3 <- c4 <- c5

b1          b2         main (*)
V           V           V
c1 <- c2 <- c3 <- c4 <- c5

b1                     main (*)
V                       V
c1 <- c2 <- c3 <- c4 <- c5

git branch -d b1

                       main (*)
                        V
c1 <- c2 <- c3 <- c4 <- c5

b1                     main (*)
V                       V
c1 <- c2 <- c3 <- c4 <- c5

git checkout b1

git checkout c3

b1 (*)                 main
V                       V
c1 <- c2 <- c3 <- c4 <- c5

b1         (*)         main
V           V           V
c1 <- c2 <- c3 <- c4 <- c5

Merging

In einem Git Repository kann es verschiedene Branches mit unterschiedlichen Dokumenten/Verzeichnissen geben. Um einen eindeutigen Projektstand wiederherzustellen, können Branches zusammengefügt werden. Häufig werden Branches wieder mit einer Hauptbranch zusammengefügt, die dann wieder als Ausgangspunkt für neue Branches dient.

Das Zusammenfügen von zwei Branches kann mit git merge oder git rebase erfolgen.

Merge:
Mit git merge entsteht ein neuer Commit auf der aktuellen Branch. Der Merge-Commit beinhaltet beide Branches als Vorgänger.

Rebase:
Mit git rebase werden die Commits einer Branch ans ende der aktuellen Branch "geschoben". Dabei wird der Abzweig mit den Commits entfernt.

        c3 <- c4                    b1
       /
c1 <- c2 <- c5 <-c6                 main

git checkout main
git merge b1

git checkout b1
git merge main

        c3 <- c4 <-----              b1
       /               \
c1 <- c2 <- c5 <-c6 <- c7            main (*)

        c3 <- c4 <- c7      b1 (*)
       /           /
c1 <- c2 <- c5 <-c6         main

        c3 <- c4                    b1
       /
c1 <- c2 <- c5 <-c6                 main

git checkout main
git rebase b1

git checkout b1
git rebase main

              b1
              V
        c3 <- c4 <- c5 <- c6        main (*)
       /
c1 <- c2

                main
                 V
c1 <- c2 <- c5 <-c6 <- c3 <- c4         b1 (*)

Remote Repositories

Git Repository können auch auf Servern (Online) gespeichert werden.
Da das Repository Online gespeichert wird, kann unabhängig vom benutztem Gerät auf dieses remote Repository zugegriffen werden. Dabei können mehrere Entwickler an einem Projekt (Repository) zusammenarbeiten.

Es gibt verschiedene Sichtbarkeitsstufen die für remote Repository festgelegt werden können:

• Private (Benutzer müssen zum Projekt (Repository) hinzugefügt werden - einzelned/als Gruppe)
• Internal (Benutzer der gleichen Organisation)
• Public (Alle Benutzer - ohne Authentifizierung)

Nutzen eines remote Repository

Falls ein Projekt als remote Repository gespeichert oder öffentlich zugänglich gemacht werden soll können folgende Möglichkeiten auftreten:

• Ein lokales Verzeichnis (Projekt) soll in einem remote Repository gespeichert werden
• Ein lokales Git Repository soll in einem remote Repository gespeichert werden
• Ein remote Repository soll lokal bearbeitet/genutzt werden

Für die Nutzung eines remote Repository muss dieses Repository erst erstellt werden.

Ein remote Repository hat eigene Branches (mit origin bezeichnet).
Diese Upstream Branches können mit lokale Branches verknüpft werden.
Dabei haben lokale Branches maximal ein Upstream Branch zu welcher lokale Commits für das remote Repository gepusht werden.

Erstellen eines remote Repository

Es gibt unterschiedliche Plattformen die das Hosten von Git Repository anbieten:

• GitHub
• GitLab
• Bitbucket

Erstellung eines remote Repository mit GitLab

• New Project (rechts oben)
• Create blank project (oder von einem Template: Create from template)
• Repository Einstellungen
  • Projektnamen
  • Sichtbarkeitslevel (Private, Internal oder Public)
  • README Dokument
• Create project

Lokales Projekt

In diesem Fall existiert bereits ein Projekt ohne Git Repository. Dieses Projekt soll jetzt mit einem remote Repository gespeichert werden.

Folgende Schritte sind notwendig:

0. Erstellen eines remote Repository

   Auf einer Plattform die Git Repository hosted - Speicherort des Repository

1. Navigation in das Verzeichnis des lokalen Projekts

   cd [lokales Projekt]

2. Erstellen eines lokalen Git Repository

   git init --initial-branch=main

   Bei GitLab standardmäßig die Hauptbranch: main

3. Verknüpfung zum erstellten remote Repository herstellen

   git remote add origin [URL des erstellten remote Repository]

4. Alle Dokumente/Verzeichnisse im Repository speichern

   git add .
   git commit -m "Initial commit"

5. Die lokale Branch mit der Upstream Branch verknüpfen und den lokalen Commit zum remote Repository hinzufügen

   git push --set-upstream origin main

   Verknüpfung der lokalen Branch main mit der Upstream Branch (remote Branch) main
   Dadurch werden Commits automatisch von der lokalen Branch main auf die remote Branch main gepusht

Lokales Repository

In diesem Fall gibt es bereits ein lokales Git Repository auf dem Gerät, das jetzt mit dem zuvor erstellten remote Repository verknüpft werden soll.

Folgende Schritte sind notwendig:

0. Erstellen eines remote Repository

   Auf einer Plattform die Git Repository hosted - Speicherort des Repository

1. Navigation in das Verzeichnis des lokalen Projekts

   cd [lokales Projekt]

2. Entferen der Verknüpfung zu einem möglichen remote Repository

   git remote rename origin old-origin

3. Verknüpfung zum erstellten remote Repository herstellen

   git remote add origin [URL des erstellten remote Repository]

4. Festlegen der Upstream branches

   git push --set-upstream origin --all

   Verknüpfung der lokalen Branch main mit der Upstream Branch (remote Branch) main
   Dadurch werden Commits automatisch von der lokalen Branch main auf die remote Branch main gepusht

5. Festlegen der Upstream tags

   git push --set-upstream origin --tags