Das große Git-Tutorial

Motivation

Jeder kennt und nutzt Git. Es gibt bis auf Ausnahmen (ich schaue dich an, Perforce) keine ernstzunehmenden Alternativen mehr.

Ich lasse Azubis ab der ersten Woche schon mit Git arbeiten, allerdings zunächst im Kontext einer IDE,
damit sie ihren Code entspannt versionieren können.

Im zweiten Lehrjahr gibt es dann den Blick hinter die Kulissen, also auf die Kommandozeile.

Inhalt

• Basics: Installation, Konfiguration, Repository erstellen, Status & Log, Commits, .gitignore, Remote, Fetch & Pull
• Intermediate: Branching, Merging, Merge-Konflikte, Stash, Diff, Tags
• Advanced: Rebase, Squashen von Commits, Cherry-Pick, Reflog, Bisect

Voraussetzungen

• Ein Terminal / eine Shell (bash, zsh, PowerShell, …)
• Grundlegende Erfahrung mit der Kommandozeile (cd, mkdir, ls/dir)
• Optional: ein GitHub- oder GitLab-Account für Remote-Repositories

Basics

Installation

Damit etwas unter Versionskontrolle gestellt werden kann, muss Git zuerst installiert sein.

Windows:

Download von https://git-scm.com/download/win und Installer ausführen

Linux (Debian/Ubuntu):

sudo apt install git

macOS:

brew install git

Wir können nun testen, ob die Installation erfolgreich war:

git --version

Konfiguration

Bevor wir loslegen, teilen wir Git unseren Namen und unsere E-Mail-Adresse mit.
Diese Infos werden in jedem Commit gespeichert.

git config --global user.name "Dein Name"
git config --global user.email "deine@email.de"

Optional – Standardbranch auf main setzen:

git config --global init.defaultBranch main

Repository erstellen (init)

mkdir my_workspace
cd my_workspace
git init

Damit haben wir ein leeres Git-Repository. Jetzt legen wir die ersten Dateien an:

touch .gitignore
touch README.md
touch app.py

Status & Log

Zwei Befehle, die man ständig braucht sind:

git status # Zeigt den aktuellen Zustand des Repositories
git log # Zeigt die Commit-Historie
git log --oneline # Kompakte Einzeiler-Ansicht

Staging & Commit

Dateien müssen zunächst in die Staging Area und können dann committet werden:

git add . # Alle Änderungen stagen
git add README.md # Einzelne Datei stagen
git commit -m "initial commit" # Commit mit Nachricht

Tipp: Gute Commit-Messages beschreiben was und warum, nicht wie.

.gitignore

Die Datei .gitignore definiert, welche Dateien Git ignorieren soll (Build-Artefakte, IDE-Konfiguration, Secrets, …):

# Beispiel .gitignore
pycache/
*.pyc
.idea/
.env
build/

Remote hinzufügen und pushen

Ein Remote-Repository (z. B. auf GitHub) wird so verknüpft:

git remote add origin https://github.com/user/repo.git
git push -u origin main

-u setzt das Upstream-Tracking, sodass git push danach ohne weitere Argumente funktioniert.

Änderungen vom Remote holen

git fetch # Holt Änderungen, merged aber NICHT
git pull # Holt Änderungen UND merged in den aktuellen Branch

Faustregel: fetch ist sicher und unverbindlich, pull verändert den lokalen Branch.

Intermediate

Remote-Repo clonen

Statt ein Repository von Grund auf neu zu erstellen, kannst du ein bestehendes Remote-Repository mit git clone auf den eigenen Rechner kopieren.
Dabei passiert automatisch einiges:

1. Ein neuer Ordner mit dem Repository-Namen wird erstellt
2. Die gesamte Historie (alle Commits, Branches, Tags) wird heruntergeladen
3. Ein Remote namens origin wird angelegt, der auf die Quell-URL zeigt
4. Der Standard-Branch (z. B. main) wird ausgecheckt

Grundsyntax:

git clone https://github.com/user/repo.git

Einen bestimmten Branch clonen:

git clone -b develop https://github.com/user/repo.git

Damit wird direkt der Branch develop ausgecheckt, nützlich, wenn du nicht auf main arbeiten möchtest.

Tipp: Nach dem Clonen kannst du dir den eingerichteten Remote anzeigen lassen:

cd repo
git remote -v

#origin https://github.com/user/repo.git (fetch)
#origin https://github.com/user/repo.git (push)

Branching

Branches sind einer der größten Vorteile von Git. Sie erlauben paralleles Arbeiten an Features, Bugfixes usw.

git branch # Alle lokalen Branches anzeigen
git branch feature/login # Neuen Branch erstellen
git checkout feature/login # In den Branch wechseln
git checkout -b feature/login # Erstellen + Wechseln in einem Schritt

Merging

Wenn ein Feature fertig ist, wird der Branch zurück in main gemerged:

git checkout main
git merge feature/login

Merge-Konflikte

Wenn zwei Branches dieselbe Stelle in einer Datei geändert haben, entsteht ein Merge-Konflikt.
Git markiert die betroffenen Stellen:

<<<<<<< HEAD
Deine Änderung
=======
Änderung aus dem anderen Branch
>>>>>>> feature/login

Lösung: Datei manuell bereinigen, dann:

git add <datei>
git commit

Stash

Unfertige Änderungen kann man zwischenspeichern, ohne zu committen:

git stash # Änderungen wegstashen
git stash list # Alle Stashes anzeigen
git stash pop # Letzten Stash wiederherstellen und entfernen
git stash apply # Letzten Stash wiederherstellen, aber behalten

Diff

Änderungen anzeigen lassen:

git diff # Unstaged-Änderungen
git diff --staged # Staged-Änderungen (vor dem Commit)
git diff main..feature # Unterschied zwischen zwei Branches

Tags

Releases oder Meilensteine markieren:

git tag v1.0.0
git tag -a v1.0.0 -m "Erstes Release"
git push origin v1.0.0

Advanced

Rebase

Rebase schreibt die Commit-Historie um und setzt Commits auf eine neue Basis.
Nützlich, um einen sauberen, linearen Verlauf zu erzeugen:

git checkout feature/login
git rebase main

Achtung: Rebase verändert die Historie. Deshalb nicht auf bereits gepushten, geteilten Branches verwenden.

Squashen von Commits

Mehrere Commits zu einem zusammenfassen (z. B. vor einem Merge Request):

git rebase -i HEAD~3 # Die letzten 3 Commits interaktiv bearbeiten

Im Editor dann pick für die gewünschten Commits durch squash (oder s) ersetzen.

Cherry-Pick

Einen einzelnen Commit aus einem anderen Branch übernehmen:

git cherry-pick <commit-hash>

Reflog

Das Sicherheitsnetz: Zeigt alle Aktionen, auch nach einem versehentlichen Reset:

git reflog
git checkout <hash> # Verlorenen Stand wiederherstellen

Fazit

Git ist ein mächtiges Werkzeug. Die Basics reichen für den Alltag, aber wer Rebase, Squash und Bisect beherrscht,
kann auch in komplexen Projekten souverän arbeiten.

Weiterführende Ressourcen:
– Pro Git Book (kostenlos)
– Git Cheat Sheet
– git help <befehl>: Die eingebaute Hilfe ist besser, als man denkt