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
stringist eine Folge von Bytes;rangeüber einen String liefert Runen (Unicode-Zeichen). „Grüße” hat 7 Bytes, aber 5 Zeichen. - Slices (
[]string) wachsen mitappend, Maps (map[string]int) sind Hashtabellen; beide sind Referenzen auf darunterliegende Daten. - Es gibt nur eine Schleife:
for. Keinwhile, keindo. bufiopuffert 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 ./spielwieseErwartet:
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/wcErwartet: 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/wcErwartet: 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.txtErwartet:
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.txtErwartet:
✔ 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 -1Erwartet:
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
flaghört beim ersten Nicht-Flag auf. Inwc gruss.txt -list-lein 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.txtErwartet:
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.txtErwartet:
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.Readerliest in 4-KB-Blöcken, der Speicherbedarf bleibt konstant – auch bei Logs mit vielen GB.bufio.Scannerdagegen 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/encodingumwandeln, sonst zählst duRuneError-Zeichen. - Locale-Unterschiede: GNU-
wcauf Linux-Servern und BSD-wcauf 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).