Tag 0: Das Trainingsgelände
Ziel: Toolchain, Editor und Linter einrichten und das erste Tool
hallomit eingebauter Version bauen · Dauer: ca. 60 min · Voraussetzung: keine
Briefing
- Go ist eine einzige Toolchain:
go build,go run,go test,go vet,go fmt,go doc– alles im Kommandogo. - Ein Modul (
go.mod) ist dein Projekt; jedes Tool in diesem Buch ist ein eigenes Modulexample.com/<tool>. - Ein Programm ist
package mainmitfunc main(). Das Ergebnis ist ein statisches Binary – kein Interpreter, kein venv. - Die Version setzt der Build per
-ldflags "-X main.version=…", nicht der Code. - Qualität kommt von Werkzeugen:
gofmt,go vet,golangci-lint.
main.go ──go build──► bin/hallo (ein Binary, ~2 MB)
▲ │
-ldflags "-X main.version=0.1.0" ./bin/hallo -version ─► hallo 0.1.0
Drill 1: Toolchain prüfen
go version
go env GOVERSION GOOS GOARCHErwartet:
go version go1.26.9 darwin/arm64
go1.26.9
darwin
arm64
Warum? GOOS/GOARCH bestimmen, wofür gebaut
wird – das nutzt du an Tag 14 für Cross-Compiles. Deine Projekte liegen,
wo du willst; go env GOPATH (meist ~/go) ist
nur noch Cache und Ablage für go install.
Tipp: Zeigt
go versionetwas Älteres als 1.26:brew upgrade go. Steht in einemgo.modeine neuere Version, lädt Go die passende Toolchain selbst nach (GOTOOLCHAIN=auto, der Default).
Fortschritt speichern? Kostenlos registrieren
Drill 2: Editor mit gopls
Jeder ernsthafte Go-Editor spricht mit gopls, dem offiziellen Language Server: Autovervollständigung, Springen zur Definition, Umbenennen, Fehler beim Tippen.
go install golang.org/x/tools/[email protected]
gopls versionErwartet:
golang.org/x/tools/gopls v0.23.0
In VS Code installierst du die Erweiterung „Go” (vom Go-Team); sie findet gopls selbst. GoLand bringt eine eigene Engine mit und braucht gopls nicht.
Tipp: Liegt
~/go/binnicht imPATH, findet die Shellgoplsnicht. Der Editor schon – er fragtgo env GOPATH.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Modul anlegen
mkdir -p ~/go-lab/tag00-hallo && cd ~/go-lab/tag00-hallo
go mod init example.com/hallo
cat go.modErwartet:
go: creating new go.mod: module example.com/hallo
module example.com/hallo
go 1.26.9
Warum? Der Modulpfad ist der Import-Präfix für alle Pakete im
Projekt. example.com/… ist reserviert und kollidiert nie
mit echten Repos; für echte Projekte nimmst du den Repo-Pfad, z. B.
github.com/<user>/hallo.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Das erste Programm
mkdir -p cmd/hallo
cat > cmd/hallo/main.go <<'EOF'
// hallo begrüßt dich und verrät seine Version.
// Tag 0 aus "Go zum Anfassen".
package main
import (
"flag"
"fmt"
"os"
"runtime"
)
// version setzt der Build per -ldflags "-X main.version=...".
var version = "dev"
func main() {
name := flag.String("name", "Welt", "wen hallo begrüßt")
showVersion := flag.Bool("version", false, "Version ausgeben und beenden")
flag.Parse()
if *showVersion {
fmt.Printf("hallo %s (%s %s/%s)\n",
version, runtime.Version(), runtime.GOOS, runtime.GOARCH)
return
}
if *name == "" {
fmt.Fprintln(os.Stderr, "hallo: -name darf nicht leer sein")
os.Exit(2)
}
fmt.Printf("Hallo, %s!\n", *name)
}
EOF
go run ./cmd/hallo
go run ./cmd/hallo -name ThomasErwartet:
Hallo, Welt!
Hallo, Thomas!
Warum? flag.String liefert einen
Pointer (*string); erst
flag.Parse() füllt ihn, *name liest den Wert.
Großgeschriebene Namen wie fmt.Printf sind exportiert,
kleingeschriebene wie version nur im eigenen Paket
sichtbar.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Flags, Hilfe und Exit-Codes
Gebaute Binaries verhalten sich wie jedes Unix-Tool. Bau eins und prüf die Exit-Codes:
go build -o bin/hallo ./cmd/hallo
./bin/hallo -h; echo "exit=$?"
./bin/hallo -name ""; echo "exit=$?"
go run ./cmd/hallo -name ""; echo "exit=$?"Erwartet:
Usage of ./bin/hallo:
-name string
wen hallo begrüßt (default "Welt")
-version
Version ausgeben und beenden
exit=0
hallo: -name darf nicht leer sein
exit=2
hallo: -name darf nicht leer sein
exit status 2
exit=1
Warum? Die Hilfe erzeugt das Paket flag aus deinen
Definitionen. go run meldet den Exit-Code nur als Text und
endet selbst mit 1 – für Skripte und CI immer das gebaute Binary prüfen.
Konvention in diesem Buch: 0 = ok, 1 = Fehler bei der Arbeit, 2 =
falscher Aufruf.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Version per -ldflags
./bin/hallo -version
go build -ldflags "-X main.version=0.1.0" -o bin/hallo ./cmd/hallo
./bin/hallo -version
ls -lh bin/hallo | awk '{print $5}'
go build -ldflags "-s -w -X main.version=0.1.0" -o bin/hallo ./cmd/hallo
ls -lh bin/hallo | awk '{print $5}'
go version -m bin/hallo | head -6Erwartet:
hallo dev (go1.26.9 darwin/arm64)
hallo 0.1.0 (go1.26.9 darwin/arm64)
2,5M
1,7M
bin/hallo: go1.26.9
path example.com/hallo/cmd/hallo
mod example.com/hallo (devel)
build -buildmode=exe
build -compiler=gc
build -ldflags="-s -w -X main.version=0.1.0"
Warum? -X paket.variable=wert überschreibt eine
String-Variable beim Linken – der Code bleibt
unverändert. -s -w entfernt Symbol- und Debug-Tabellen
(kleiner, aber schlechter zu debuggen). go version -m liest
die eingebetteten Build-Infos aus jedem Go-Binary – praktisch, wenn ein
Kunde fragt „womit wurde das gebaut?“.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Qualitätskontrolle
Erst die eingebauten Werkzeuge, dann der Linter. Bau einen Fehler ein, den der Compiler nicht findet:
perl -pi -e 's/"Hallo, %s!\\n"/"Hallo, %d!\\n"/' cmd/hallo/main.go
go build ./... && echo "kompiliert trotzdem"
go vet ./...
perl -pi -e 's/"Hallo, %d!\\n"/"Hallo, %s!\\n"/' cmd/hallo/main.go
go vet ./... && gofmt -l . && echo "sauber"Erwartet:
kompiliert trotzdem
cmd/hallo/main.go:29:21: fmt.Printf format %d has arg *name of wrong type string
sauber
Für golangci-lint legst du ein kleines Wrapper-Skript an.
go run …@version baut den Linter in fester Version in den
Go-Cache – keine globale Installation, und alle Tage nutzen dieselbe
Version:
mkdir -p ~/go-lab/bin
cat > ~/go-lab/bin/lint <<'EOF'
#!/usr/bin/env bash
# golangci-lint in fester Version – ohne globale Installation
exec go run github.com/golangci/golangci-lint/v2/cmd/[email protected] "$@"
EOF
chmod +x ~/go-lab/bin/lint
~/go-lab/bin/lint version
~/go-lab/bin/lint run ./...
go fix -diff ./... && echo "nichts zu modernisieren"Erwartet (der erste Aufruf baut ca. 1–2 Minuten, gekürzt):
golangci-lint has version 2.14.0 built with go1.26.9 from (unknown, ...)
0 issues.
nichts zu modernisieren
Warum? gofmt -l listet unformatierte Dateien – leer
heißt gut; dein Editor formatiert beim Speichern. golangci-lint bündelt
govet, errcheck, staticcheck,
unused und ineffassign (Standard-Set).
go fix bringt seit Go 1.26 „Modernizer” mit, die alten Code
auf aktuelle Sprachmittel heben.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Doku ohne Browser
Die Standardbibliothek ist groß und gut dokumentiert – direkt im Terminal:
go doc flag.String
go doc -short os | grep -E 'func (Exit|Getenv)\('
go list -f '{{.ImportPath}} {{.Imports}}' ./cmd/hallo
go list std | wc -lErwartet:
package flag // import "flag"
func String(name string, value string, usage string) *string
String defines a string flag with specified name, default value, and usage
string. The return value is the address of a string variable that stores the
value of the flag.
func Exit(code int)
func Getenv(key string) string
example.com/hallo/cmd/hallo [flag fmt os runtime]
360
Warum? Rund 360 Pakete Standardbibliothek decken HTTP, JSON, Krypto,
Tests und Logging ab – deshalb kommen die Tools in diesem Buch mit
wenigen Abhängigkeiten aus. go doc funktioniert genauso für
deine eigenen Pakete (Tag 2).
Zum Einordnen, was du aus Bash und Python kennst:
| Aufgabe | Bash | Python | Go |
|---|---|---|---|
| Argumente | getopts |
argparse |
flag (Tag 5: cobra) |
| Exit-Code | exit 2 |
sys.exit(2) |
os.Exit(2) |
| Umgebung | $HOME |
os.environ |
os.Getenv("HOME") |
| Ausliefern | Skript + Tools | venv/pipx | ein Binary |
Fortschritt speichern? Kostenlos registrieren
Drill 9: Das Tool ist fertig
cd ~/go-lab/tag00-hallo
go build -ldflags "-s -w -X main.version=0.1.0" -o bin/hallo ./cmd/hallo
./bin/hallo -name "Platform-Team"
./bin/hallo -versionErwartet:
Hallo, Platform-Team!
hallo 0.1.0 (go1.26.9 darwin/arm64)
Dein Modul sieht jetzt so aus:
tag00-hallo/
├── bin/hallo
├── cmd/hallo/main.go
└── go.mod
Den fertigen Code jedes Tages gibt es zum Vergleichen im Begleitcode auf GitHub. Hol ihn jetzt; erst tippst du selbst, dann siehst du nach:
git clone https://github.com/thomaszachmann/go-zum-anfassen.git ~/go-zum-anfassen
ls -1 ~/go-zum-anfassen/tag00-halloErwartet:
Cloning into '…/go-zum-anfassen'...
cmd
go.mod
Die Ordner heißen wie deine in ~/go-lab. Nach Tag 1
zeigt etwa
diff -r ~/go-lab/tag01-wc ~/go-zum-anfassen/tag01-wc, wo du
abweichst.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/go-lab/tag00-hallo
check "Go 1.26 aktiv" "go version | grep -q 'go1\.26'"
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Version per ldflags" "./bin/hallo -version | grep -q '^hallo 0.1.0'"
check "Exit-Code 2 bei leerem Namen" "./bin/hallo -name ''; test \$? -eq 2"Erwartet:
✔ Go 1.26 aktiv
✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Version per ldflags
✔ Exit-Code 2 bei leerem Namen
Challenge
Ohne -ldflags soll hallo -version nicht
„dev” zeigen, sondern die Version aus Git: den Tag, falls vorhanden,
sonst eine Pseudo-Version mit Commit. main.go bleibt dabei
unverändert.
Hinweis: Go bettet seit Go 1.18 VCS-Infos ins Binary
ein, und seit Go 1.24 steht in
debug.ReadBuildInfo().Main.Version eine Version aus Git;
eine init()-Funktion läuft vor main.
Lösung
cat > cmd/hallo/buildinfo.go <<'EOF'
package main
import "runtime/debug"
// init läuft vor main: ohne -ldflags nehmen wir die Version aus Git.
func init() {
if version != "dev" {
return
}
if bi, ok := debug.ReadBuildInfo(); ok && bi.Main.Version != "(devel)" {
version = bi.Main.Version
}
}
EOF
git init -q && printf 'bin/\n' > .gitignore
git add . && git commit -qm "hallo"
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
git tag v0.2.0
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
echo "// geändert" >> cmd/hallo/main.go
go build -o bin/hallo ./cmd/hallo && ./bin/hallo -version
git checkout -q cmd/hallo/main.goErwartet (Zeitstempel und Hash weichen ab):
hallo v0.0.0-20261010064452-1ace3d653a29 (go1.26.9 darwin/arm64)
hallo v0.2.0 (go1.26.9 darwin/arm64)
hallo v0.2.0+dirty (go1.26.9 darwin/arm64)
Ein uncommitteter Stand bekommt +dirty – genau das
willst du in Produktion nie sehen. -ldflags hat weiterhin
Vorrang, weil init dann früh aussteigt. Mit
go run gibt es keine VCS-Infos, dort bleibt es bei
„dev”.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Go-Version im Team festnageln:
go- undtoolchain-Zeile ingo.mod, dieselbe Version in CI (Tag 14) – sonst baut jeder mit etwas anderem. - Proxy und Prüfsummen: Unternehmen setzen oft
GOPROXYauf einen internen Proxy (Artifactory, Athens) undGOPRIVATEfür interne Repos;GOSUMDBbleibt für öffentliche Module an. - Linter-Version und
.golangci.ymlgehören ins Repo; CI bricht bei Findings ab, lokal läuft derselbe Aufruf. - Version immer aus dem Build (Git-Tag →
-ldflagsoder Build-Info), nie von Hand im Code pflegen. - Kein
go install …@latestauf Build-Servern: Versionen pinnen, damit Builds reproduzierbar bleiben.