Dein erstes Git-Labor

Einführung

Willkommen zu deiner ersten spannenden Reise in die Welt von Git! Wenn du dir jemals gewünscht hast, in der Zeit zurückreisen zu können, um einen Fehler in deiner Arbeit zu korrigieren, oder wenn du Schwierigkeiten hattest, den Überblick über Änderungen in deinen Projekten zu behalten, dann bist du hier genau richtig. Git ist wie eine Zeitmaschine für deinen Code und deine Dokumente – und am Ende dieses Labors wirst du die Macht haben, sie zu steuern!

Keine Sorge, falls du noch nie von Git gehört hast – wir fangen ganz von vorne an und begleiten dich bei jedem Schritt. Am Ende dieses Kurses wirst du verstehen, wie man ein Git-Repository erstellt, Änderungen verfolgt und Commits (Speicherpunkte) setzt. Dies sind die grundlegenden Fähigkeiten, die Entwickler weltweit täglich nutzen, um großartige Software zu erschaffen. Lass uns unser Abenteuer beginnen!

Dein geheimes Labor einrichten

Bevor wir in Git eintauchen, richten wir einen Arbeitsbereich ein. Stell dir das wie den Bau eines geheimen Labors vor, in dem all deine Experimente stattfinden werden.

Öffne dein Terminal (keine Angst, es sieht komplizierter aus, als es ist!) und tippe diese magischen Worte ein:

cd ~/project
mkdir my-time-machine
cd my-time-machine

Hier ist die Bedeutung der einzelnen Befehle:

1. cd ~/project: Dies teleportiert dich in dein Projektverzeichnis.
2. mkdir my-time-machine: Dies erschafft einen neuen Ordner namens "my-time-machine".
3. cd my-time-machine: Dies bewegt dich hinein in dein neues geheimes Labor.

Glückwunsch! Du hast gerade einen Platz für dein erstes Git-Projekt geschaffen. Aber warum brauchen wir diesen speziellen Ordner? Nun, in der Welt der Programmierung ist Ordnung das halbe Leben. Wenn deine Projekte wachsen, wirst du es zu schätzen wissen, für jedes Vorhaben einen eigenen Bereich zu haben.

Die Zeitmaschine initialisieren (Git-Repository)

Da wir nun unser geheimes Labor haben, ist es an der Zeit, unsere Zeitmaschine zu bauen! In der Fachsprache nennen wir diese Zeitmaschine ein "Git-Repository".

Gib diesen Befehl in dein Terminal ein:

git init

Du solltest eine Nachricht wie diese sehen:

Initialized empty Git repository in /home/labex/project/my-time-machine/.git/

Wahnsinn! Du hast gerade deine ganz persönliche Zeitmaschine erschaffen. Aber wozu brauchen wir eigentlich eine Zeitmaschine für unseren Code?

Stell dir vor, du schreibst eine Geschichte. Vielleicht möchtest du verschiedene Enden ausprobieren oder löschst versehentlich einen Absatz, der dir eigentlich sehr gut gefiel. Ohne Git müsstest du manuell verschiedene Versionen deiner Geschichte speichern, was in Dateinamen wie "geschichte_final.txt", "geschichte_final_v2.txt" oder "geschichte_JETZT_ABER_WIRKLICH_FINAL.txt" endet. Kommt dir das bekannt vor?

Git löst dieses Problem. Es erlaubt dir, verschiedene Versionen deiner Arbeit zu speichern, ohne unzählige Dateien zu erstellen. Du kannst ganz einfach zu jeder früheren Version zurückkehren oder alternative Zeitlinien (wir nennen sie "Branches") erstellen, um mit neuen Ideen zu experimentieren. Deshalb lieben Entwickler Git – es gibt ihnen die Freiheit zu experimentieren, ohne Angst haben zu müssen, ihre Arbeit zu verlieren.

Den Status deiner Zeitmaschine überprüfen

Jetzt, wo wir unsere Zeitmaschine haben, schauen wir mal, was sie uns sagen kann. In Git nutzen wir dafür den Befehl git status. Es ist so, als würdest du deine Zeitmaschine fragen: "Was ist der aktuelle Stand der Dinge?"

Probier es aus:

git status

Du solltest etwas Ähnliches wie das hier sehen:

On branch master

No commits yet

nothing to commit (create/copy files and use "git add" to track)

Das mag anfangs verwirrend klingen, aber lass es uns aufschlüsseln:

• "On branch master": Stell dir einen Branch wie eine Zeitlinie vor. "master" ist die Hauptzeitlinie deines Projekts.
• "No commits yet": Ein Commit ist wie ein Speicherpunkt in einem Videospiel. Wir haben bisher noch keine Speicherpunkte gesetzt.
• "nothing to commit": Es gibt keine Änderungen, die Git aufzeichnen könnte, da wir noch keine Dateien erstellt haben.

Vielleicht fragst du dich: "Warum brauchen wir das alles, nur um Dateien zu speichern?" Gute Frage! Im Gegensatz zum normalen Speichern erlaubt Git dir, über die Zeit hinweg mehrere Versionen deines Projekts zu sichern. Das bedeutet, du kannst völlig frei experimentieren, weil du weißt, dass du jederzeit zu einem früheren Stand zurückkehren kannst, falls etwas schiefgeht. Es ist wie ein unbegrenztes "Rückgängig machen" für dein gesamtes Projekt!

Deine erste Datei erstellen

Lass uns nun etwas erschaffen, das unsere Zeitmaschine verfolgen kann. Wir beginnen mit einer einfachen Nachricht in einer Datei:

echo "Hello, Future Me" > message.txt

Dieser Befehl erstellt eine neue Datei namens message.txt mit dem Inhalt "Hello, Future Me".

Lass uns überprüfen, was wir geschrieben haben:

cat message.txt

Du solltest sehen:

Hello, Future Me

Hervorragend! Wir haben unsere erste Datei erstellt. Aber hier kommt die Magie von Git ins Spiel: Im Moment existiert diese Datei zwar auf deinem Computer, aber Git überwacht sie noch nicht. Es ist so, als hätten wir eine Notiz geschrieben, sie aber noch nicht in unsere Zeitkapsel (das Git-Repository) gelegt.

In den nächsten Schritten werden wir sehen, wie Git auf diese neue Datei reagiert und wie wir anfangen können, Änderungen daran zu protokollieren. Hier fängt Git an, gegenüber dem normalen Speichern von Dateien richtig zu glänzen. Mit Git wirst du genau sehen können, was sich wann und warum geändert hat. Stell dir vor, wie hilfreich das bei einem großen Projekt ist!

Den Status erneut prüfen

Nachdem wir eine Datei erstellt haben, fragen wir unsere Zeitmaschine erneut, was sie sieht. Führe den Befehl git status noch einmal aus:

git status

Diesmal wirst du eine Veränderung bemerken:

On branch master

No commits yet

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

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

Spannend! Git hat unsere neue Datei bemerkt, sagt uns aber, dass sie "untracked" (unbeobachtet) ist. Das ist einer der Vorteile von Git – es überwacht nicht automatisch jede einzelne Datei in deinem Ordner. So behältst du die volle Kontrolle darüber, welche Änderungen du in deine Projekthistorie aufnehmen möchtest.

Du denkst vielleicht: "Warum nicht einfach alles automatisch überwachen?" Nun, stell dir vor, du arbeitest an einem riesigen Projekt. Vielleicht hast du dort Dateien, die nicht in die Versionsverwaltung gehören – wie persönliche Notizen oder temporäre Dateien. Git lässt dich entscheiden, was wichtig ist, und hält so deine Projekthistorie sauber und aussagekräftig.

Im nächsten Schritt werden wir Git mitteilen, dass wir diese Datei überwachen wollen. Ab hier fühlt sich Git wie eine Superkraft an – du bist kurz davor, deinen ersten Speicherpunkt in der Zeit zu setzen!

Den ersten Speicherpunkt vorbereiten

Jetzt sagen wir Git, dass wir message.txt in unseren nächsten Speicherpunkt (im Git-Jargon "Commit" genannt) aufnehmen wollen. Das machen wir mit dem Befehl git add:

git add message.txt

Dieser Befehl gibt keine direkte Rückmeldung im Terminal aus, aber er hat Git angewiesen, message.txt ab jetzt zu berücksichtigen.

Prüfen wir den Status erneut, um zu sehen, was passiert ist:

git status

Jetzt solltest du das hier sehen:

On branch master

No commits yet

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

Sieh dir das an! Git überwacht unsere Datei nun offiziell, und sie ist bereit für den Commit. Dieser zweistufige Prozess – erst hinzufügen (add), dann bestätigen (commit) – mag anfangs umständlich wirken, ist aber eine der größten Stärken von Git.

Stell dir vor, du bereitest eine Zeitkapsel vor. Der Befehl git add ist wie die Entscheidung, was du in die Kapsel hineinlegen möchtest. Der Commit (den wir als Nächstes machen) ist dann das eigentliche Versiegeln der Kapsel. So kannst du ganz präzise auswählen, was in jedem einzelnen Speicherpunkt deiner Projekthistorie landet.

Diese Funktion ist unglaublich nützlich bei größeren Projekten. Du änderst vielleicht zehn Dateien, möchtest aber nur die Änderungen von drei davon in einem Speicherpunkt zusammenfassen. Der "Staging Area" von Git (wo sich message.txt gerade befindet) ermöglicht dir genau das!

Den ersten Speicherpunkt erstellen (Commit)

Jetzt kommt der aufregende Teil – wir erstellen unseren ersten Commit! Ein Commit ist wie das Versiegeln einer Zeitkapsel. Er speichert den aktuellen Zustand aller überwachten Dateien und fügt eine Nachricht hinzu, die beschreibt, was geändert wurde.

Hier ist der Befehl für den Commit:

git commit -m "Eine Nachricht an die Zukunft senden"

Du solltest eine Ausgabe ähnlich dieser sehen:

[master (root-commit) a1b2c3d] Eine Nachricht an die Zukunft senden
 1 file changed, 1 insertion(+)
 create mode 100644 message.txt

Herzlichen Glückwunsch! Du hast gerade deinen ersten Git-Commit erstellt. Du hast offiziell einen Zeitpunkt in deinem Projekt markiert, zu dem du jederzeit zurückkehren kannst.

Das ist das Geheimnis der Macht von Git. Jeder Commit ist eine Momentaufnahme deines gesamten Projekts zu diesem Zeitpunkt. Du kannst so viele dieser Schnappschüsse erstellen, wie du möchtest, und erhältst so eine detaillierte Chronik deines Projekts.

Stell dir vor, du schreibst an einem Aufsatz für die Schule. Beim normalen Speichern hast du immer nur die aktuellste Version. Mit Git hättest du Speicherpunkte für "Erster Entwurf", "Fazit hinzugefügt", "Einleitung korrigiert" und so weiter. Du könntest bei Bedarf zu jedem dieser Punkte zurückspringen!

Das Logbuch deiner Zeitreise einsehen

Da wir nun unseren ersten Commit gemacht haben, schauen wir uns die Historie unseres Projekts an. Das geht mit dem Befehl git log:

git log

Du solltest etwas in dieser Art sehen:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9 (HEAD -> master)
Author: Dein Name <deine.email@example.com>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Eine Nachricht an die Zukunft senden

Dieser Log-Eintrag verrät uns mehrere Dinge:

• Eine eindeutige Kennung für den Commit (diese lange Kette aus Buchstaben und Zahlen)
• Wer den Commit erstellt hat
• Wann der Commit erstellt wurde
• Die Commit-Nachricht, die wir geschrieben haben

Dieses Logbuch ist wie die Zeitlinie deines Projekts. Mit jedem weiteren Commit wächst diese Liste und bildet eine lückenlose Historie. Das ist extrem hilfreich, wenn du verstehen willst, wie sich dein Projekt entwickelt hat, oder wenn du herausfinden musst, wann genau eine bestimmte Änderung vorgenommen wurde.

Drücke q, um die Log-Ansicht zu verlassen und zur Kommandozeile zurückzukehren. Merk dir: Mit q kannst du in Git fast jede Vollbildansicht beenden.

Stell dir vor, du arbeitest mit anderen an einem Gruppenprojekt. Mit Git siehst du genau, wer welche Änderung warum gemacht hat, was die Abstimmung im Team massiv erleichtert. Das ist einer der Gründe, warum Git weltweit der Standard für Entwickler ist!

Zusammenfassung

Glückwunsch, Zeitreisender! Du hast dein erstes Git-Abenteuer erfolgreich bestanden. Lassen wir die tollen Dinge, die du gelernt hast, noch einmal Revue passieren:

1. Wie man ein Git-Repository (deine Zeitmaschine) mit git init erstellt.
2. Wie man den Status seines Repositorys mit git status überprüft.
3. Wie man Dateien erstellt und sie mit git add für einen Commit vorbereitet.
4. Wie man mit git commit einen Speicherpunkt in der Zeit setzt.
5. Wie man die Projekthistorie mit git log einsieht.

Vielleicht fragst du dich immer noch: "Warum der ganze Aufwand, nur um Dateien zu speichern?" Hier ist die Antwort, warum Git so mächtig ist:

1. Detaillierte Historie: Mit Git hast du eine lückenlose Chronik deines Projekts. Du siehst, was sich wann und warum geändert hat.
2. Experimentierfreude: Git erlaubt dir, völlig frei zu experimentieren. Du kannst verschiedene Versionen deines Projekts erstellen, ohne Angst um deine ursprüngliche Arbeit zu haben.
3. Zusammenarbeit: In einem Team macht es Git leicht nachzuvollziehen, wer welche Änderungen vorgenommen hat.
4. Backup: Jedes Git-Repository ist ein vollständiges Backup deines Projekts inklusive der gesamten Historie.

Dies sind die Grundbausteine, die Entwickler jeden Tag nutzen, um fantastische Software zu bauen. Auf deinem weiteren Weg wirst du auf diesen Grundlagen aufbauen, um komplexere Projekte zu verwalten und mit anderen zusammenzuarbeiten.

Denk daran: Jeder fängt mal klein an. Selbst die erfahrensten Profis standen einmal genau dort, wo du jetzt stehst. Übe weiter, experimentiere viel und – am wichtigsten – hab Spaß dabei!

Wenn du mehr über LabEx erfahren möchtest, besuche unser Support Center oder schau dir dieses Video an, um mehr über die Plattform zu lernen.

Deine Reise in die Welt der Programmierung und Versionsverwaltung hat gerade erst begonnen. Das nächste Labor ist nur einen Klick entfernt. Lass uns weiter forschen und deine Fähigkeiten mit deinen neuen Git-Superkräften ausbauen! Wer weiß, welche großartigen Projekte du bald erschaffen wirst?