Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: Syntax kompakt – wc

Ziel: Mit Variablen, Slices, Maps, Schleifen und Runen einen wc-Nachbau schreiben, der exakt wie das Original zählt – plus Top-Wörter · Dauer: ca. 90 min · Voraussetzung: Tag 0

Briefing

  • := deklariert und weist zu, der Typ wird abgeleitet; jede Variable hat einen Nullwert (0, "", false, nil).
  • Ein string ist eine Folge von Bytes; range über einen String liefert Runen (Unicode-Zeichen). „Grüße” hat 7 Bytes, aber 5 Zeichen.
  • Slices ([]string) wachsen mit append, Maps (map[string]int) sind Hashtabellen; beide sind Referenzen auf darunterliegende Daten.
  • Es gibt nur eine Schleife: for. Kein while, kein do.
  • bufio puffert Ein- und Ausgabe – unverzichtbar, wenn du Dateien Zeichen für Zeichen liest.
 Datei/stdin ─bufio.Reader─► ReadRune() ─► count() ─► Zeilen, Wörter, Bytes, Zeichen
                                              │
                                              └─► map[string]int ─► topWords() ─► Top N

Drill 1: Syntax im Schnelldurchlauf

mkdir -p ~/go-lab/tag01-wc && cd ~/go-lab/tag01-wc
go mod init example.com/wc
mkdir -p spielwiese cmd/wc
cat > spielwiese/main.go <<'EOF'
// spielwiese: Go-Syntax im Schnelldurchlauf.
package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func main() {
    // Variablen: var mit Typ (Nullwert), := mit Typinferenz, const
    var n int
    gruss := "Grüße"
    const limit = 3
    fmt.Println("1)", n, gruss, limit)

    // Strings sind Bytes, range liefert Runen (Unicode-Codepoints)
    fmt.Println("2)", len(gruss), utf8.RuneCountInString(gruss))
    for i, r := range gruss {
        fmt.Printf("%d:%c ", i, r)
    }
    fmt.Println()

    // Slices: append wächst bei Bedarf, s[a:b] ist eine Sicht
    tools := []string{"kubectl", "helm"}
    tools = append(tools, "bao")
    fmt.Println("3)", tools, len(tools), tools[1:])

    // Maps: Zugriff mit comma-ok, fehlender Key liefert den Nullwert
    ports := map[string]int{"http": 80, "https": 443}
    p, ok := ports["ssh"]
    fmt.Println("4)", p, ok, len(ports))

    // Schleifen: es gibt nur for – klassisch, range, while-artig
    for i := range limit {
        fmt.Print(i, " ")
    }
    words := strings.Fields("  go   ist  schnell ")
    for len(words) > 0 {
        fmt.Print(strings.ToUpper(words[0]), " ")
        words = words[1:]
    }
    fmt.Println()
}
EOF
go run ./spielwiese

Erwartet:

go: creating new go.mod: module example.com/wc
1) 0 Grüße 3
2) 7 5
0:G 1:r 2:ü 4:ß 6:e 
3) [kubectl helm bao] 3 [helm bao]
4) 0 false 2
0 1 2 GO IST SCHNELL 

Warum? Zeile 2 zeigt den wichtigsten String-Fakt in Go: len zählt Bytes, range springt von Rune zu Rune – die Indizes 2 → 4 → 6 verraten, dass ü und ß je zwei Bytes lang sind. for i := range limit (seit Go 1.22) zählt von 0 bis 2. Ein fehlender Map-Key ist kein Fehler, sondern der Nullwert – ok sagt dir, ob er wirklich da war.

Tipp: Ändere die Spielwiese nach Lust und Laune. Der Compiler lehnt unbenutzte Variablen und Imports ab – lies die Meldung, sie sagt genau, welche Zeile.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Zählen, Rune für Rune

Das Herz von wc: Eine Funktion liest eine Eingabe und zählt alles in einem Durchgang.

cat > cmd/wc/count.go <<'EOF'
package main

import (
    "bufio"
    "io"
    "strings"
    "unicode"
)

// counts hält die Zählerstände einer Eingabe (mehr zu Structs an Tag 2).
type counts struct {
    lines, words, bytes, chars int
}

// count liest r Rune für Rune. Ist freq nicht nil, zählt es jedes Wort mit.
func count(r io.Reader, freq map[string]int) (counts, error) {
    var c counts
    var word strings.Builder
    inWord := false

    flush := func() { // Wort abschließen und in die Map eintragen
        w := strings.TrimFunc(word.String(), unicode.IsPunct)
        if freq != nil && w != "" {
            freq[w]++
        }
        word.Reset()
    }

    br := bufio.NewReader(r)
    for {
        ch, size, err := br.ReadRune()
        if err == io.EOF {
            break
        }
        if err != nil {
            return c, err
        }
        c.bytes += size
        c.chars++
        if ch == '\n' {
            c.lines++
        }
        if unicode.IsSpace(ch) {
            if inWord {
                flush()
            }
            inWord = false
            continue
        }
        if !inWord {
            c.words++
            inWord = true
        }
        word.WriteRune(unicode.ToLower(ch))
    }
    if inWord {
        flush()
    }
    return c, nil
}
EOF
go vet ./cmd/wc

Erwartet: keine Ausgabe – main fehlt noch, go vet prüft trotzdem schon Syntax und Typen.

Warum so? io.Reader ist „alles, was man lesen kann” – Datei, stdin, Netzwerk. ReadRune liefert Zeichen und ihre Bytegröße, deshalb stimmen Bytes und Zeichen gleichzeitig. flush ist eine Closure: eine Funktion in der Funktion, die word und freq von außen mitbenutzt. Ein Wort beginnt, wo auf Leerraum etwas anderes folgt – genau so zählt auch das Unix-wc.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Top-Wörter mit Map und Slice

Maps haben keine Reihenfolge. Zum Sortieren kopierst du die Einträge in ein Slice:

cat > cmd/wc/top.go <<'EOF'
package main

import (
    "cmp"
    "slices"
)

// wordCount ist ein Paar aus Wort und Häufigkeit.
type wordCount struct {
    word string
    n    int
}

// topWords liefert die n häufigsten Wörter, bei Gleichstand alphabetisch.
func topWords(freq map[string]int, n int) []wordCount {
    list := make([]wordCount, 0, len(freq))
    for w, k := range freq {
        list = append(list, wordCount{w, k})
    }
    slices.SortFunc(list, func(a, b wordCount) int {
        if c := cmp.Compare(b.n, a.n); c != 0 {
            return c // absteigend nach Häufigkeit
        }
        return cmp.Compare(a.word, b.word)
    })
    if len(list) > n {
        list = list[:n]
    }
    return list
}
EOF
go vet ./cmd/wc

Erwartet: keine Ausgabe.

Warum? make([]wordCount, 0, len(freq)) reserviert gleich die richtige Kapazität, append muss dann nie umkopieren. slices.SortFunc erwartet eine Vergleichsfunktion mit Rückgabe <0, 0, >0 – cmp.Compare liefert genau das. list[:n] schneidet ab, ohne zu kopieren.

Fortschritt speichern? Kostenlos registrieren

Drill 4: main – Flags, Dateien, Summen

cat > cmd/wc/main.go <<'EOF'
// wc zählt Zeilen, Wörter, Bytes und Zeichen – wie das Unix-Original.
// Tag 1 aus "Go zum Anfassen".
package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {
    lines := flag.Bool("l", false, "Zeilen zählen")
    words := flag.Bool("w", false, "Wörter zählen")
    bytes := flag.Bool("c", false, "Bytes zählen")
    chars := flag.Bool("m", false, "Zeichen (Runen) zählen")
    top := flag.Int("top", 0, "die `N` häufigsten Wörter ausgeben")
    flag.Parse()

    // Ohne Auswahl wie das Original: Zeilen, Wörter, Bytes.
    if !*lines && !*words && !*bytes && !*chars {
        *lines, *words, *bytes = true, true, true
    }
    show := func(c counts, name string) {
        if *lines {
            fmt.Printf("%8d", c.lines)
        }
        if *words {
            fmt.Printf("%8d", c.words)
        }
        if *chars {
            fmt.Printf("%8d", c.chars)
        }
        if *bytes {
            fmt.Printf("%8d", c.bytes)
        }
        if name != "-" {
            fmt.Print(" ", name)
        }
        fmt.Println()
    }

    var freq map[string]int // nil-Map: lesen ok, schreiben verboten
    if *top > 0 {
        freq = make(map[string]int)
    }
    files := flag.Args()
    if len(files) == 0 {
        files = []string{"-"} // "-" steht für stdin
    }

    var total counts
    exitCode := 0
    for _, name := range files {
        c, err := countFile(name, freq)
        if err != nil {
            fmt.Fprintln(os.Stderr, "wc:", err)
            exitCode = 1
            continue
        }
        show(c, name)
        total.lines += c.lines
        total.words += c.words
        total.bytes += c.bytes
        total.chars += c.chars
    }
    if len(files) > 1 {
        show(total, "total")
    }
    for i, wc := range topWords(freq, *top) {
        fmt.Printf("%3d. %-20s %d\n", i+1, wc.word, wc.n)
    }
    os.Exit(exitCode)
}

// countFile öffnet name (oder stdin bei "-") und zählt.
func countFile(name string, freq map[string]int) (counts, error) {
    if name == "-" {
        return count(os.Stdin, freq)
    }
    f, err := os.Open(name)
    if err != nil {
        return counts{}, err
    }
    defer f.Close() //nolint:errcheck // nur gelesen, Close-Fehler egal
    return count(f, freq)
}
EOF
go build -o bin/wc ./cmd/wc
printf 'Grüße aus Hamburg!\nGo ist schnell, Go ist einfach.\n' > gruss.txt
./bin/wc gruss.txt
./bin/wc -l -w gruss.txt
./bin/wc -m gruss.txt
./bin/wc -top 3 gruss.txt

Erwartet:

       2       9      53 gruss.txt
       2       9 gruss.txt
      51 gruss.txt
       2       9      53 gruss.txt
  1. go                   2
  2. ist                  2
  3. aus                  1

Warum? freq bleibt ohne -top eine nil-Map: Lesen und range darauf sind erlaubt, Schreiben würde paniken – deshalb prüft count auf nil. Weil Maps Referenzen sind, sammelt dieselbe Map Wörter über alle Dateien. defer f.Close() schließt die Datei, sobald countFile zurückkehrt; der nolint-Kommentar sagt dem Linter, dass ein Close-Fehler beim reinen Lesen egal ist.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Gegen das Original antreten

Ein Nachbau ist nur gut, wenn er dasselbe zählt. Testtext: Goethes Faust vom Projekt Gutenberg, mit Umlauten und rund 200 KB.

curl -sO https://www.gutenberg.org/cache/epub/2229/pg2229.txt
for f in "" -l -w -c -m; do
  if diff <(./bin/wc $f pg2229.txt) <(wc $f pg2229.txt) >/dev/null; then
    echo "✔ gleich: wc $f"
  else
    echo "✘ anders: wc $f"
  fi
done
./bin/wc pg2229.txt

Erwartet:

✔ gleich: wc 
✔ gleich: wc -l
✔ gleich: wc -w
✔ gleich: wc -c
✔ gleich: wc -m
    7542   33705  218440 pg2229.txt

Warum? 218440 Bytes, aber nur 214638 Zeichen – die Differenz sind die Umlaute. wc -m zählt nur dann Zeichen statt Bytes, wenn deine Shell eine UTF-8-Locale hat (echo $LANG, auf dem Mac der Normalfall); dein Go-Tool zählt immer Runen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: stdin, Fehler und eine Flag-Falle

cat gruss.txt | ./bin/wc -w
./bin/wc gruss.txt nix.txt go.mod; echo "exit=$?"
./bin/wc gruss.txt -l; echo "exit=$?"
./bin/wc -top x gruss.txt 2>&1 | head -1

Erwartet:

       9
       2       9      53 gruss.txt
wc: open nix.txt: no such file or directory
       3       4      33 go.mod
       5      13      86 total
exit=1
       2       9      53 gruss.txt
wc: open -l: no such file or directory
       2       9      53 total
exit=1
invalid value "x" for flag -top: parse error

Warum? Ein Fehler bei einer Datei bricht nicht alles ab: Meldung auf stderr, weiter mit der nächsten, am Ende Exit-Code 1 – wie das Original. Ohne Dateien liest wc von stdin, deshalb funktioniert es in Pipes.

Achtung: Das Paket flag hört beim ersten Nicht-Flag auf. In wc gruss.txt -l ist -l ein Dateiname. Flags gehören vor die Argumente; erst cobra (Tag 5) erlaubt beides.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Das Tool ist fertig

cd ~/go-lab/tag01-wc
go vet ./... && ~/go-lab/bin/lint run ./...
go build -o bin/wc ./cmd/wc
./bin/wc -top 5 pg2229.txt

Erwartet:

0 issues.
    7542   33705  218440 pg2229.txt
  1. und                  919
  2. ich                  690
  3. die                  667
  4. der                  609
  5. nicht                423

Dein Modul:

tag01-wc/
├── cmd/wc/
│   ├── count.go    zählen (bufio, Runen, Closure)
│   ├── main.go     Flags, Dateien, Ausgabe
│   └── top.go      Map → Slice → sortiert
├── spielwiese/main.go
└── go.mod

Drei Dateien, ein Paket: Alles mit package main im selben Ordner gehört zusammen und sieht sich gegenseitig – auch kleingeschriebene Namen. Wie du Code in eigene Pakete schneidest, zeigt Tag 2.

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/tag01-wc
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Zeilen wie wc" "diff <(./bin/wc -l pg2229.txt) <(wc -l pg2229.txt)"
check "Zeichen wie wc -m" "diff <(./bin/wc -m pg2229.txt) <(wc -m pg2229.txt)"
check "stdin funktioniert" "test \"\$(printf 'a b\n' | ./bin/wc -w | tr -d ' ')\" = 2"
check "Exit 1 bei fehlender Datei" "./bin/wc nix.txt; test \$? -eq 1"

Erwartet:

✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Zeilen wie wc
✔ Zeichen wie wc -m
✔ stdin funktioniert
✔ Exit 1 bei fehlender Datei

Challenge

Die Top-Liste ist voller Füllwörter wie „und”, „ich”, „die”. Lass in -top nur Wörter mit mindestens vier Zeichen zu.

Hinweis: len("für") ist 4 – das wäre falsch; das Paket unicode/utf8 zählt Runen.

Lösung

cat > cmd/wc/top.go <<'EOF'
package main

import (
    "cmp"
    "slices"
    "unicode/utf8"
)

// minRunes: kürzere Wörter (und, der, ich) zählen nicht für die Top-Liste.
const minRunes = 4

// wordCount ist ein Paar aus Wort und Häufigkeit.
type wordCount struct {
    word string
    n    int
}

// topWords liefert die n häufigsten Wörter, bei Gleichstand alphabetisch.
func topWords(freq map[string]int, n int) []wordCount {
    list := make([]wordCount, 0, len(freq))
    for w, k := range freq {
        if utf8.RuneCountInString(w) < minRunes {
            continue // nicht len(w): "für" hat 4 Bytes, aber 3 Runen
        }
        list = append(list, wordCount{w, k})
    }
    slices.SortFunc(list, func(a, b wordCount) int {
        if c := cmp.Compare(b.n, a.n); c != 0 {
            return c // absteigend nach Häufigkeit
        }
        return cmp.Compare(a.word, b.word)
    })
    if len(list) > n {
        list = list[:n]
    }
    return list
}
EOF
go build -o bin/wc ./cmd/wc && ./bin/wc -top 5 pg2229.txt

Erwartet:

    7542   33705  218440 pg2229.txt
  1. nicht                423
  2. mephistopheles       283
  3. faust                270
  4. sich                 262
  5. mich                 236

Mephistopheles steht öfter im Text als Faust – die Sprecherangaben vor jedem Dialog zählen mit. Mit Bash-Bordmitteln wäre das eine Pipeline aus tr, sort und uniq -c. Der Filter steht bewusst in topWords und nicht in count: Die Zähler -w bleiben identisch mit dem Original.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Große Dateien: bufio.Reader liest in 4-KB-Blöcken, der Speicherbedarf bleibt konstant – auch bei Logs mit vielen GB. bufio.Scanner dagegen hat ein Zeilenlimit von 64 KB (Tag 2).
  • Encodings: Go geht von UTF-8 aus. Windows-Dateien in UTF-16 oder Latin-1 erst mit golang.org/x/text/encoding umwandeln, sonst zählst du RuneError-Zeichen.
  • Locale-Unterschiede: GNU-wc auf Linux-Servern und BSD-wc auf dem Mac formatieren Spalten unterschiedlich – Skripte nie auf exakte Leerzeichen prüfen.
  • Ein eigenes Binary ersetzt keine Coreutils, aber es läuft identisch auf Mac, Linux und im distroless-Container (Tag 14).