Übung: Erste Schritte mit Go

Mit dieser Übung bekommen Sie eine kurze Einführung in das Programmieren mit Go. Dabei werden Sie:

Go installieren (wenn Sie's nicht schon getan haben),
ein simples Hello-World-Programm kodieren,
das go-Kommando benutzen, um Ihr Programm auszuführen,
das Suchwerkzeug für Go-Pakete benutzen, um Pakete zu finden, die Sie für Ihren eigenen Kode benutzen können und
Funktionen eines externen Moduls aufrufen.

Hinweis: Weitere Übungen finden Sie hier.

Voraussetzungen

Etwas Programmiererfahrung. Der Kode hier ist recht einfach, aber es hilft, wenn man etwas über Funktionen weiß.
Ein Werkzeug zum Bearbeiten Ihres Kodes. Ein beliebiger Texteditor genügt; die meisten unterstützen das Arbeiten mit Go. Beliebt sind VSCode (frei), GoLand (kostet etwas) und Vim (frei).
Ein Kommandofenster. Go arbeitet unter Linux oder Mac in jedem Terminal, und unter Windows in der PowerShell oder im cmd-Fenster.

Go installieren

Erledigen Sie die beschriebenen Arbeitsschritte in "Download and install" (de).

Kode schreiben

Wir beginnen mit "Hallo Welt".

In einer Kommandozeile begeben Sie sich in ihr Home-Verzeichnis.
Unter Linux oder Mac mit:
```
cd
```
Unter Windows mit:
```
cd %HOMEPATH%
```
Erstellen Sie einen Ordner für Ihren ersten Go-Quellkode.
Etwa mit den folgenden Kommandos:
```
$ mkdir hello
$ cd hello
```
Initialisieren Sie ein neues Modul — das dient zur Überwachung von Abhängigkeiten.
Wenn Ihr Kode Pakete eines anderen Moduls importiert, dann verzeichnet eine Datei namens go.mod die jeweiligen Module und Versionen, durch die diese Pakete bereitgestellt werden. Diese Datei begleitet Ihren Kode ... auch ins Quellkode-Repositorium.

Zum Erzeugen der Datei go.mod benutzen Sie das Kommando go mod init, dem Sie den Namen für Ihr Modul mitgeben (hier ist das einfach "hello"):
```
$ go mod init hello
go: creating new go.mod: module hello
```
Erzeugen Sie mit Ihrem Texteditor eine Datei hello.go, die Ihren Kode aufnehmen wird.
Fügen Sie dort den folgenden Kode ein, und sichern sie die Datei.
```
package main

import "fmt"

func main() {
    fmt.Println("Hallo Welt!")
}
```
Das also ist Ihr Go-Kode.
- Sie deklarieren ein main-Paket. Ein Paket ist eine Methode, Funktionen zu gruppieren; es umfasst alle Dateien desselben Ordners.
- Sie importieren das vielbenutzte fmt-Paket, worin sich Funktionen zum Formatieren von Text befinden, auch solche zur Ausgabe auf die Konsole. Dieses Paket gehört zur Standardbibliothek, die Sie mit der Installation von Go bekommen haben.
- Sie implementieren eine main-Funktion, die eine Nachricht auf der Konsole ausgibt. Eine main-Funktion wird automatisch ausgeführt, wenn Sie das main-Paket ausführen.
Starten Sie das Programm, dann sehen Sie den Gruß!
```
$ go run .
Hallo Welt!
```
Das Kommando go run ist eins von vielen go-Kommandos, die Sie im Rahmen von Go benutzen werden. Mit dem folgenden erhalten Sie eine Liste der anderen:
```
$ go help
```

Kode aus einem externen Paket rufen

Wenn Ihr Kode etwas tun soll, dass vielleicht ein anderer schon implementiert hat, dann können sie nach einem Paket suchen, das die von Ihnen benötigten Funktionen enthält.

Machen Sie die Nachricht Ihres Programms ein bisschen interessanter mithilfe einer Funktion aus einem externen Modul.
1. Besuchen Sie pkg.go.dev und suchen nach einem "quote"-Paket.
2. Lokalisieren Sie das Paket rsc.io/quote in den Suchergebnissen und klicken Sie darauf (ein Paket rsc.io/quote/v3 ignorieren Sie fürs Erste).
3. Betrachten Sie im Abschnitt Documentation unter Index die Liste der Fuktionen, die Sie von Ihrem Kode aus aufrufen können. Sie werden die Funktion Go benutzen.
4. Beachten Sie am Seitenanfang, dass das Paket quote im Modul rsc.io/quote enthalten ist.
Auf der Seite pkg.go.dev finden Sie veröffentlichte Module, worin Pakete Funktionen enthalten, die Sie in Ihrem Kode benutzen können. Pakete werden innerhalb von Modulen — wie rsc.io/quote — veröffentlicht, wodurch andere sie nutzen können. Module werden im Laufe der Zeit mit neueren Versionen verbessert, und Sie können Ihren Kode mit diese verbesserten Versionen aufrüsten.
Importieren Sie in Ihrem Go-Kode das Paket rsc.io/quote und rufen Sie dessen Funktion Go.
Nachdem Sie die herausgehobenen Zeilen hinzugefügt haben, sollte Ihr Kode so aussehen:
```
package main

import "fmt"

import "rsc.io/quote"

func main() {
    fmt.Println(quote.Go())
}
```
Ergänzen Sie die neue Modulvoraussetzung und die Prüfsummen.
Das go-Kommando wird das Modul quote als Voraussetzung ergänzen und eine Datei go.sum für die Echtheitsprüfung (authentication) der Module anlegen. Mehr dazu in Module authentication using go.sum.
```
$ go mod tidy
go: finding module for package rsc.io/quote
go: found rsc.io/quote in rsc.io/quote v1.5.2
```
Starten Sie Ihr Programm, damit Sie die Nachricht sehen können, die jetzt mit der gerufenen Funktion generiert wird.
```
$ go run .
Don't communicate by sharing memory, share memory by communicating.
```
Wie Sie sehen, ruft Ihr Kode die Go-Funktion, die eine schlaue Botschaft zum Thema Nachrichtenaustausch ausgibt.

Mit go mod tidy wurde das Modul rsc.io/quote gefunden und fernkopiert (download). Standardmäßig wird die neueste Version kopiert — hier: v1.5.2.

Mehr Kode schreiben

Mit dieser kurzen Einführung haben Sie Go installiert und einige Grundlagen gelernt. Um mit einer weiteren Übung noch ein bisschen mehr zu kodieren, schauen Sie sich doch "Create a Go module" (de) an.