Vielleicht hast du ja etwas von Git gehört und möchtest es jetzt benutzen, allerdings weißt du noch nicht, wie. Das ist kein Problem denn in diesem Tutorial wird Git leicht und verständlich erklärt. Alles was du dafür brauchst ist ein UNIX-System (Linux, Mac OS X, …), ein bisschen Zeit und einen Terminal. Terminal-Kenntnisse sind hilfreich. Mac OS X und Linux verhalten sich identisch. Fangen wir an.
1. Was ist git eigentlich?
Git wurde u.a. von Linus Torvalds dafür geschrieben, um dem Quelltext des Linux-Kernels einfacher zu verwalten. Heute ist es ein Open Source-System zur Versionsverwaltung von Projekten. Das bedeutet, dass man Änderungen an Projekten macht, die Git dann im Auge behält. Wenn man mit einer Änderung fertig ist, kann man Git sagen, dass jetzt eine Version aufgezeichnet werden soll. Diese kann man dann noch kurz beschreiben und speichern.
Wichtig ist, dass hier nicht von “klassischen” Versionen gesprochen wird (also 1.0, 1.1 etc.). Eine Version hat in einem Git keine Versionsnummer, sondern jede Version ist ein Zwischenstand des Statuses eines Projektes. Das Tolle an Git ist zudem noch, dass man alle Änderungen und den gesamten Sourcecode auch extern speichern kann. Dadurch lässt sich kollaborativ arbeiten.
Beispiel: Zwei Personen haben den selben Stand eines Projektes. Person A ändert etwas an einer Datei, Person B an einer anderen. Beide machen ein commit (eine Version) und schicken diesen an einen externen Server. Der Server erkennt, was verändert wurde und pflegt die Änderungen ein. Beide Personen können dann einen pull machen (die aktuellste Version herunterladen) und haben dann wieder den gleichen Stand.
2. Ein Git einrichten
a. Git installieren
Damit du ein Git einrichten kannst, musst du es zuerst installieren. Auf Linux kannst du dies über eine Paketverwaltung tun. Bei Debian/Ubuntu wäre das z.B. apt-get oder aptitude:
apt-get install git
Auf Mac OS X ist git bereits vorinstalliert.
b. Git initialisieren
Lege zuerst ein Verzeichnis an, dass du als Git benutzen möchtest und wechsle hinein oder wechsle direkt in ein bestehendes Verzeichnis (dafür dann mkdir … weglassen, vorhandene Dateien bleiben bestehen):
mkdir /path/to/directory/ && cd /path/to/directory/
Jetzt kommt die Magie. Ein simpler Befehl genügt und schon hast du ein Git:
git init
3. Das Git benutzen
a. git add
Das Git ist bereits einsatzbereit. Wenn du mit einem neuen Projekt anfangen möchtest, kannst du bereits Dateien erstellen, verändern, etc.. Du musst Git mitteilen, welche Dateien verändert/hinzugefügt wurden. Dies geschieht mit:
git add FILE1 FILE2 …
Anschließend weiß Git, welche Dateien verändert wurden.
b. git rm
Wenn du Dateien aus einem Projekt entfernen möchtest, verwende diesen Befehl:
git rm FILE1 FILE2 …
Git macht diese Änderungen – falls noch nicht geschehen – auch direkt im Verzeichnis. Es ist also nicht notwendig, die Dateien vorher bereits zu entfernen.
c. git mv
Wenn sich in deinem Projekt Dateien verschieben und den Ort wechseln, musst du auch das dem Git mitteilen. Dies geschieht per:
git mv FILE TARGET
Git macht diese Änderungen – falls noch nicht geschehen – auch direkt im Verzeichnis. Es ist also nicht notwendig, die Dateien vorher bereits zu entfernen.
4. Commits machen
Wenn du entsprechende Änderungen gemacht hast, musst du dem Git noch sagen, wann es eine Version mit Beschreibung erstellen soll. Das nennt sich commits. Jedes commit enthält eine Liste der Änderungen. Ein simpler Commit geht so:
git commit -m “BESCHREIBUNG”
Statt BESCHREIBUNG gibst du eine kurze Beschreibung an, was sich geändert hat, z.B. “Hyperlink-Farbe geändert”. Man schreibt vorzugsweise auf englisch, da die meisten GIt-Remotes (dazu mehr gleich) ebenfalls englisch sind.
5. Git Remotes
a. Allgemein
Ein lokales Git ist zwar schön und gut, aber die richtige Power eines Gits kommt erst zum Vorschein, wenn man sein Git auf einen Server hochlädt. Dafür gibt es zwei Möglichkeiten: Entweder nutzt man einen vorhandenen Git-Hoster (bitbucket.org, GitHub.com, …) oder man installiert sich ein eigenes Git auf einem eigenen Server (z.B. GitLab, nur für erfahrene Nutzer geeignet).
Wenn man dann einen Hoster hat, legt man dort ein Git an. Man erhält dann vom Hoster eine URL in diesem Schema:
https://HOSTERADRESSE/USERNAME/NAME.git
oder
ssh://USERNAME@HOSTERADRESSE/USERNAME/NAME.git
Wenn man eine URL vom Hoster erhalten hat, muss man diese seinem lokalen Git hinzufügen, um sie zu benutzen. Dies geschieht mit:
git remote add NAME URL
Typischerweise nennt man den ersten Remote “origin”, also git remote add origin URL. Wenn man einen Remote hinzugefügt hat und die URL des Remotes ändern möchte, kann man diesen Befehl nutzen:
git remote set-url NAME NEUEURL
Man kann auch vorhandene Remotes umbenennen:
git remote rename ALTERNAME NEUERNAME
…oder löschen:
git remote rm NAME
b. Hochladen/Herunterladen
Wenn man seinen Remote eingerichtet hat, muss man diesen natürlich auch bestücken. Dazu müssen zuerst commits gemacht worden sein. Wenn man so weit ist, führt man dann diesen Befehl aus, um alle commits an den Server zu schicken:
git push NAME BRANCH
Hat man seinen Remote z.B. “origin” genannt, führt man git push origin BRANCH aus. Nun, hier gibt es etwas, dass wir noch nicht hatten: Branch. Mehr dazu im Punkt “Branches.” Vorerst nehmen wir als Branch “master”, z.B.: git push origin master
Um Änderungen von einem Server herunterzuladen, führt man diesen Befehl aus:
git pull NAME BRANCH
z.B.: git pull origin master.
6. Änderungen verwerfen
Wenn du Änderungen gemacht hast, die dir aber doch nicht gefallen, kannst du sie, so lange sie noch nicht in einem commit waren, wieder rückgängig machen. Dazu einfach diesen Befehl ausführen:
git stash
Git macht daraufhin eine Sicherheitskopie und verwirft dann die Änderungen.
7. Branches
a. Branches erstellen und wechseln
Ein Branch ist nichts anderes als ein “Parallelprojekt”. Wenn du z.B. eine Änderung an einem Projekt machen möchtest, die aber nur testweise stattfinden soll, wird das mithilfe eines Branches gemacht. So bleiben testweise Änderungen vom Originalprojekt getrennt.
Eine Übersicht aller vorhanden Branches erhälst du durch:
git branch
Um einen neuen Branch zu erstellen, hilft dieser Befehl:
git branch NAME
Dies erstellt dann den Branch NAME. Bedenke, dass master ein reservierter Begriff ist.
Um dann nach der Erstellung zum neuen Branch zu wechseln, genügt die Eingabe von:
git checkout BRANCHNAME
Alles, was du dann änderst, bleibt nur im Branch BRANCHNAME. Dazu zählen alle Commits, Dateiadditions, …
b. Merging
Ein weiterer Vorteil solcher Branches ist es, dass dadurch ein solches Szenario möglich wird:
Im Branch master befindet sich die öffentliche Version eines Programmes. Jetzt hast du aber eine Idee, die du erst in einem Branch testen willst. Du erstellst also einen Branch und implementierst dort die Idee. In der Zwischenzeit ist ein Bug im Branch master aufgetaucht. Du wechselst also zum master-Branch, fixt den Bug, committest ihn und wechselt wieder zurück. Obwohl du Änderungen im Test-Branch hattest, sind diese Änderungen nicht im master-Branch.
Wenn deine Änderungen deinen Vorstellungen entsprechen und in den master-Branch übernommen werden sollen, musst du diese mergen (zusammenfügen). Wechsle dazu zuerst zum Branch, in den die Änderungen gehen sollen, z.B. master und führe dann diesen Befehl aus:
git merge BRANCHNAME
Statt BRANCHNAME setzt du den Branch ein, aus dem die Änderungen kommen. Schon sind die Änderungen übernommen.
Sollte ein Merge nicht erfolgreich durchgeführt werden können, weil Änderungen der beiden Branches miteinander kollidieren, erscheint eine Fehlermeldung. Diese Meldung sagt einem, welche Dateien nicht gemerged werden können. Um diesen Fehler zu behebn, genügt es, die Dateien zu öffnen. Dort sind sogenannte HEAD-markers drin. Diese Marker zeigen den Konflikt auf, z.B.:
<<<<<<< HEAD:lib/simplegit.rb
def commit(message)
command("git commit -m '#{message}'")
=======
def add(path)
command("git add #{path}")
>>>>>>> experiment:lib/simplegit.rb
endNun einfach manuell die Änderungen übernehmen, die bleiben sollen und die HEAD-Marker entfernen. Anschließend einfach die Datei zum Git hinzufügen (git add FILE) und einen simplem Commit ohne Parameter machen (git commit). Der Merge ist dann fertig.
Soll nach dem Mergen ein Branch entfernt werden, muss an den merge-Befehl noch ein -d angehängt werden.
Schlusswort: Warum Git und nicht z.B. SVN?
Git ist das effektivste System. Ein simpler Test zeigt die wahre Effektivität von Git gegenüber SVN:
Es werden in SVN und Git ein komplettes Iconset hinzugefügt und committed. In SVN dauert das 45s, während Git die selbe Aufgabe in 0.3s erledigt.
Ich hoffe, ich konnte dir Git etwas näher bringen. Natürlich ist alles hier aufgezeigte nicht alles, was Git kann. Das würde den Ramen eines Anfängertutorials sprengen.
Vergiss nicht, diese Hilfsbefehle auszuführen, um zu sehen, was Git noch so kann:
git –help
git remote –help
git commit –help
git add –help
…
