GOPATH und Module

Einführung

In diesem Lab werden wir uns mit zwei verschiedenen Ansätzen zur Verwaltung von Abhängigkeiten in Go beschäftigen: GOPATH und Go-Module. Dies sind grundlegende Konzepte, um Go-Projekte effektiv zu strukturieren und zu verwalten.

Wissenspunkte:

GOPATH
GOROOT
Go-Module

Vorbereitung

In diesem Schritt bereiten wir die Umgebung vor, indem wir ein bereitgestelltes Tar-Archiv entpacken.

Öffnen Sie zunächst Ihr Terminal und navigieren Sie mit dem folgenden Befehl in das Projektverzeichnis:
```
cd ~/project
```
Entpacken Sie die Datei helloWorld.tar.gz im aktuellen Verzeichnis:
```
tar -xzf helloWorld.tar.gz
```
Überprüfen Sie nach dem Entpacken, ob der Ordner helloWorld erstellt wurde:
```
ls helloWorld
```

Dies listet den Inhalt des Verzeichnisses helloWorld auf, sofern es korrekt entpackt wurde.

Grundlagen von GOPATH

Vor der Einführung von Go 1.11 verwendete Go einen speziellen Arbeitsbereich namens GOPATH, um den gesamten Go-Code zu speichern. In diesem Schritt werden wir verstehen, wie GOPATH funktioniert.

GOROOT ist das Verzeichnis, in dem Go installiert ist, einschließlich der Tools und der Standardbibliothekspakete.
GOPATH ist der Ort, an dem sich Ihr persönlicher Go-Code befindet. Er enthält normalerweise drei Verzeichnisse:
- src: Speichert den Quellcode Ihrer Projekte.
- bin: Speichert die kompilierten ausführbaren Dateien.
- pkg: Speichert kompilierte Pakete, die nicht eigenständig ausführbar sind.

Um den aktuellen GOPATH und GOROOT zu überprüfen, führen Sie die folgenden Befehle aus:

## GOPATH-Verzeichnis prüfen
go env | grep GOPATH

## GOROOT-Verzeichnis prüfen
go env | grep GOROOT

Diese Befehle zeigen die auf Ihrem System konfigurierten Pfade für GOPATH und GOROOT an.

Modul initialisieren

Go-Module wurden mit Go 1.11 eingeführt und sind seit Go 1.13 standardmäßig aktiviert. Sie lösen zwei Hauptprobleme:

Übermäßige Abhängigkeit von GOPATH: Vor den Go-Modulen musste der Code zwingend im Verzeichnis GOPATH/src liegen. Mit Go-Modulen können Sie Ihren Code an einem beliebigen Ort auf Ihrem System speichern.
Versionskonflikte bei Abhängigkeiten: Go-Module ermöglichen es Projekten, Abhängigkeiten mit spezifischen Versionen zu verwalten und zu verfolgen. Dies erleichtert die Arbeit mit verschiedenen Versionen desselben Pakets.

In diesem Schritt werden wir ein Go-Modul für ein neues Projekt initialisieren.

Erstellen Sie ein neues Verzeichnis für das Projekt namens testHello:
```
cd ~/project
mkdir testHello
```
Wechseln Sie in das Verzeichnis testHello:
```
cd testHello
```
Initialisieren Sie das Go-Modul für dieses Projekt:
```
go mod init testHello
```
Die Ausgabe sollte wie folgt aussehen:
```
go: creating new go.mod: module testHello
```

Erstellen Sie eine neue Go-Datei testHello.go im Ordner testHello mit folgendem Inhalt:

touch testHello.go

package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}

Damit haben wir das Projekt testHello erfolgreich mit Go-Modulen initialisiert und ein einfaches Go-Programm hinzugefügt.

Andere Pakete mit Modulen importieren

In diesem Schritt zeigen wir Ihnen, wie Sie andere Module in Ihr Go-Projekt importieren und verwenden.

Das Paket helloWorld im gleichnamigen Ordner wurde bereits mit Go-Modulen initialisiert. Ebenso importiert das Paket test, welches ebenfalls Go-Module nutzt, die Funktion Say aus dem Paket helloWorld.

Um dies zu untersuchen, führen Sie folgende Schritte aus:

Betrachten Sie zunächst die Struktur der Verzeichnisse helloWorld und test:

helloWorld
├── go.mod
└── helloWorld.go
test
├── go.mod
└── test.go

Öffnen Sie als Nächstes die Datei test/go.mod. Sie sollten folgenden Inhalt sehen:

module test

go 1.15

require "helloWorld" v0.0.1
replace "helloWorld" => "../helloWorld"

Die replace-Anweisung weist Go an, den lokalen Pfad ../helloWorld zu verwenden, anstatt das Paket aus einem externen Repository zu laden. Die require-Anweisung gibt an, dass das Paket test von der Version v0.0.1 des Pakets helloWorld abhängig ist.

Parameter	Beschreibung
module	Gibt den Paketnamen an
require	Definiert Abhängigkeiten
replace	Ersetzt Abhängigkeiten (z. B. durch lokale Pfade)
exclude	Schließt bestimmte Abhängigkeiten aus

So führen Sie die Datei test.go im Paket test aus:

cd ~/project/test
go run test.go

Die Ausgabe sollte lauten:

hello, world

Remote-Pakete importieren

In Go können Sie problemlos Pakete aus entfernten Quellen importieren. Wir demonstrieren dies anhand eines Pakets von GitHub.

Erstellen Sie ein Verzeichnis remoteModule:

cd ~/project
mkdir remoteModule
cd remoteModule

Initialisieren Sie das Go-Modul:
```
go mod init remoteModule
```
Erstellen Sie eine Datei remote.go im Ordner remoteModule mit folgendem Inhalt:
```
touch remote.go
```
```
package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.StringTobase64("miiy")
}
```
Dieses Programm importiert das Paket chap02module von GitHub und verwendet dessen Funktion StringTobase64.
Führen Sie die Datei remote.go mit den folgenden Befehlen aus:
```
go get github.com/labex-labs/golang-dev-code/chap02module
go run -v remote.go
```
Hinweis: Nutzer des kostenlosen Plans haben keinen Internetzugang, daher kann dieser Befehl fehlschlagen. Upgrade auf den Pro-Plan, um Internetzugriff zu erhalten.

Der Befehl go get lädt das Paket chap02module von GitHub herunter und speichert es in Ihrem Modul-Cache. Sobald dies abgeschlossen ist, führt der Befehl go run Ihr Programm aus.

Mini-Test

In diesem Schritt testen wir Ihr Wissen, indem wir eine neue Datei erstellen, welche die Funktion Hello aus dem Remote-Modul verwendet.

Erstellen Sie einen Ordner remoteModule2:

cd ~/project
mkdir remoteModule2
cd remoteModule2

Initialisieren Sie das Go-Modul:
```
go mod init remoteModule2
```

Erstellen Sie eine Datei remote2.go mit folgendem Inhalt:

touch remote2.go

package main

import (
    "github.com/labex-labs/golang-dev-code/chap02module"
)

func main() {
    chap02module.Hello()
}

Führen Sie das Programm aus:

go get github.com/labex-labs/golang-dev-code/chap02module
go run remote2.go

Die Ausgabe sollte lauten:

hello

Zusammenfassung

In diesem Lab haben wir Folgendes gelernt:

Die Bedeutung und den Zweck der Verzeichnisse GOPATH und GOROOT.
Die Grundlagen von Go-Modulen zur Verwaltung von Abhängigkeiten.
Wie man Go-Module in einem Projekt initialisiert und verwendet.
Wie man lokale und entfernte Go-Pakete importiert und einbindet.

Nach Abschluss dieses Labs sollten Sie in der Lage sein, Go-Module sicher zur Verwaltung von Abhängigkeiten in Ihren eigenen Go-Projekten einzusetzen.