Go: Pakete, Module und Standardbibliothek

Kurz: Ein Modul ist ein Projekt (mit go.mod), ein Paket ein Ordner mit Go-Dateien, die dieselbe package-Zeile haben.

Teil des Kurses Go

Kapitel 9 von 11 im Kurs Go (Abschnitt „Praxis“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Module und Pakete

Ein Modul ist ein Projekt (mit go.mod), ein Paket ein Ordner mit Go-Dateien, die dieselbe package-Zeile haben.

go mod init beispiel.de/rechner      # legt go.mod an

rechner/
├─ go.mod                     module beispiel.de/rechner
├─ main.go                    package main
└─ mathe/
   ├─ mathe.go                package mathe
   └─ mathe_test.go

// mathe/mathe.go
package mathe
 
func Addiere(a, b int) int { return a + b }     // Großbuchstabe: exportiert
func geheim() int          { return 42 }        // klein: nur im Paket
 
// main.go
package main
 
import (
    "fmt"
    "beispiel.de/rechner/mathe"
)
 
func main() {
    fmt.Println(mathe.Addiere(2, 3))
}

Befehl	Zweck
go mod init name	Modul anlegen
go get paket@version	Abhängigkeit holen
go mod tidy	go.mod aufräumen
go build ./...	alles bauen
go install	Programm nach $GOPATH/bin installieren

Pakete von Drittanbietern importierst du mit ihrer URL (github.com/gorilla/mux).

Dateien lesen und schreiben

package main
 
import (
    "bufio"
    "fmt"
    "os"
    "path/filepath"
    "strings"
)
 
func main() {
    ordner, _ := os.MkdirTemp("", "kurs")
    defer os.RemoveAll(ordner)
    pfad := filepath.Join(ordner, "notiz.txt")
 
    if err := os.WriteFile(pfad, []byte("Zeile 1\nZeile 2\n"), 0o644); err != nil {
        fmt.Println(err)
        return
    }
    f, err := os.OpenFile(pfad, os.O_APPEND|os.O_WRONLY, 0o644)
    if err == nil {
        fmt.Fprintln(f, "Zeile 3")
        f.Close()
    }
 
    daten, _ := os.ReadFile(pfad)
    fmt.Println(strings.Count(string(daten), "\n"), "Zeilen")
 
    datei, _ := os.Open(pfad)
    defer datei.Close()
    scanner := bufio.NewScanner(datei) // zeilenweise
    for scanner.Scan() {
        fmt.Println(">", scanner.Text())
    }
 
    _, err = os.ReadFile(filepath.Join(ordner, "gibt-es-nicht"))
    fmt.Println(os.IsNotExist(err), err != nil)
}

Ausgabe:

3 Zeilen
> Zeile 1
> Zeile 2
> Zeile 3
true true

JSON

package main
 
import (
    "encoding/json"
    "fmt"
)
 
type Nutzer struct {
    Name   string   `json:"name"`
    Alter  int      `json:"alter"`
    Hobbys []string `json:"hobbys,omitempty"`
    intern string   // klein: wird nicht serialisiert
}
 
func main() {
    mia := Nutzer{Name: "Mia", Alter: 17, Hobbys: []string{"Lesen", "Rad"}}
    daten, _ := json.Marshal(mia)
    fmt.Println(string(daten))
    schoen, _ := json.MarshalIndent(map[string]any{"ok": true, "zahl": 42}, "", "  ")
    fmt.Println(string(schoen))
 
    var tom Nutzer
    if err := json.Unmarshal([]byte(`{"name":"Tom","alter":19}`), &tom); err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%+v\n", tom)
 
    var beliebig map[string]any
    json.Unmarshal([]byte(`{"a":1,"b":[true,"x"]}`), &beliebig)
    fmt.Println(beliebig["a"], beliebig["b"])
 
    err := json.Unmarshal([]byte(`{kaputt`), &tom)
    fmt.Println(err != nil)
}

Ausgabe:

{"name":"Mia","alter":17,"hobbys":["Lesen","Rad"]}
{
  "ok": true,
  "zahl": 42
}
{Name:Tom Alter:19 Hobbys:[] intern:}
1 [true x]
true

Nur exportierte Felder (Großbuchstabe) werden serialisiert. Tags wie json:"name,omitempty" steuern die Namen.

Zeit

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    t := time.Date(2025, time.March, 8, 14, 30, 0, 0, time.UTC)
    fmt.Println(t.Format("02.01.2006 15:04"), t.Weekday(), t.YearDay())
    // Go formatiert mit dem Beispieldatum "Mon Jan 2 15:04:05 2006"
    fmt.Println(t.Add(36*time.Hour).Format(time.RFC3339), t.AddDate(0, 1, 0).Format("2006-01-02"))
 
    ende := time.Date(2025, 12, 24, 0, 0, 0, 0, time.UTC)
    fmt.Println(int(ende.Sub(t).Hours()/24), "Tage")
 
    p, err := time.Parse("02.01.2006", "24.12.2025")
    fmt.Println(p.Format("2006-01-02"), err)
    d, _ := time.ParseDuration("1h30m")
    fmt.Println(d, d.Minutes())
 
    start := time.Now()
    time.Sleep(20 * time.Millisecond)
    fmt.Println(time.Since(start) >= 20*time.Millisecond)
}

Ausgabe:

08.03.2025 14:30 Saturday 67
2025-03-10T02:30:00Z 2025-04-08
290 Tage
2025-12-24 <nil>
1h30m0s 90
true

Ein HTTP-Server in wenigen Zeilen

Die Standardbibliothek enthält einen vollwertigen Webserver:

package main
 
import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)
 
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hallo vom Server!")
    })
    mux.HandleFunc("GET /nutzer/{id}", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]string{"id": r.PathValue("id")})
    })
    log.Println("läuft auf http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

Start mit go run main.go; jede Anfrage läuft in einer eigenen Goroutine.

Ein HTTP-Client:

resp, err := http.Get("https://example.org")
if err != nil { return err }
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

Weitere nützliche Pakete

Paket	Zweck
fmt, log, log/slog	Ausgabe, Logging
strings, strconv, bytes, regexp	Text
os, io, bufio, path/filepath	Dateien und Ströme
encoding/json, encoding/csv, encoding/xml	Formate
net/http, net/url	Web
time, math, math/rand/v2, sort, slices, maps	Grundlagen
flag	Kommandozeilen-Argumente
database/sql	Datenbanken (mit Treiber)
testing, testing/fstest	Tests
embed	Dateien ins Programm einbetten

Merke

• Module (go.mod) enthalten Pakete (Ordner); exportiert wird, was mit Großbuchstaben beginnt
• go mod init, go get, go mod tidy
• os, bufio, encoding/json, time, net/http decken viele Alltagsaufgaben ab
• Zeitformate nutzen das Beispieldatum 02.01.2006 15:04:05
• Ein Webserver braucht nur net/http

Übungsaufgabe

Lies eine JSON-Datei mit einer Liste von Büchern ein und gib die Titel sortiert aus.

Quiz zur Selbstkontrolle

Wie wird in Go etwas aus einem Paket exportiert?

• Name beginnt mit einem Großbuchstaben (richtig)
• Mit dem Schlüsselwort export
• Mit public
• Mit einem Sternchen

Was enthält die Datei go.mod?

• Modulname und Abhängigkeiten (richtig)
• Den Quellcode
• Die Tests
• Binärdateien

Wie schreibt man in Go ein Datumsformat?

• Mit dem Beispieldatum 02.01.2006 15:04:05 (richtig)
• Mit yyyy-MM-dd
• Mit %Y-%m-%d
• Mit DD/MM

Weiter im Kurs

Zurück: Goroutinen, Channels und Synchronisation

Weiter: Tests, Benchmarks und Werkzeuge

Alle Kapitel: Go im Überblick