Projekt: ein Wortzähler

swift run wortzaehler --top 3 < text.txt

mkdir wortzaehler
cd wortzaehler
swift package init --name wortzaehler --type executable

// swift-tools-version: 6.0
import PackageDescription

let package = Package(
    name: "wortzaehler",
    targets: [
        .executableTarget(name: "wortzaehler"),
        .testTarget(name: "wortzaehlerTests", dependencies: ["wortzaehler"]),
    ]
)

wortzaehler/
├── Package.swift
├── Sources/
│   └── wortzaehler/
│       ├── main.swift
│       └── Wortstatistik.swift
└── Tests/
    └── wortzaehlerTests/
        └── WortstatistikTests.swift

/// Ergebnis einer Analyse. Ein Werttyp: einmal berechnet, danach unveränderlich.
struct Wortstatistik: Equatable {
    struct Eintrag: Equatable {
        let wort: String
        let anzahl: Int
    }

    let woerter: Int
    let verschiedene: Int
    let laengstes: String?
    let haeufigste: [Eintrag]
}

/// Zerlegt Text in Wörter: alles, was weder Buchstabe noch Ziffer ist, trennt.
/// "Swift-Code" wird so zu "swift" und "code" (siehe Übung 2).
func woerter(in text: String) -> [String] {
    text
        .split(whereSeparator: { !($0.isLetter || $0.isNumber) })
        .map { $0.lowercased() }
}

func analysiere(_ text: String, top: Int = 5) -> Wortstatistik {
    let alle = woerter(in: text)

    var zaehlung: [String: Int] = [:]
    for wort in alle {
        zaehlung[wort, default: 0] += 1
    }

    // Häufigste zuerst, bei Gleichstand alphabetisch: so ist die Ausgabe immer gleich
    let sortiert = zaehlung
        .map { Wortstatistik.Eintrag(wort: $0.key, anzahl: $0.value) }
        .sorted { $0.anzahl != $1.anzahl ? $0.anzahl > $1.anzahl : $0.wort < $1.wort }

    let laengstes = zaehlung.keys.max { a, b in
        a.count != b.count ? a.count < b.count : a > b
    }

    return Wortstatistik(
        woerter: alle.count,
        verschiedene: zaehlung.count,
        laengstes: laengstes,
        haeufigste: Array(sortiert.prefix(max(0, top)))
    )
}

func bericht(_ s: Wortstatistik) -> String {
    var zeilen = [
        "Wörter:        \(s.woerter)",
        "Verschiedene:  \(s.verschiedene)",
        "Längstes Wort: \(s.laengstes ?? "–")",
    ]
    if !s.haeufigste.isEmpty {
        zeilen.append("Häufigste:")
        for eintrag in s.haeufigste {
            zeilen.append("  \(eintrag.anzahl)× \(eintrag.wort)")
        }
    }
    return zeilen.joined(separator: "\n")
}

(keine Ausgabe: die Datei definiert nur Typen und Funktionen)

/// Liest Text von der Standardeingabe und gibt eine Wortstatistik aus.
/// Aufruf: swift run wortzaehler --top 3 < text.txt

func anzahlHaeufigste(aus argumente: [String]) -> Int? {
    guard let index = argumente.firstIndex(of: "--top") else { return 5 }
    let wertIndex = argumente.index(after: index)
    guard wertIndex < argumente.endIndex, let wert = Int(argumente[wertIndex]), wert >= 0 else {
        return nil
    }
    return wert
}

if let top = anzahlHaeufigste(aus: Array(CommandLine.arguments.dropFirst())) {
    var text = ""
    while let zeile = readLine() {
        text += zeile + "\n"
    }
    print(bericht(analysiere(text, top: top)))
} else {
    print("Verwendung: wortzaehler [--top ANZAHL] < datei.txt")
}

main --top 3

Wer Swift lernt, lernt zuerst Werte und Typen.
Dann lernt man Funktionen, dann Optionals, dann Protokolle.
Ein Werkzeug, das Wörter zählt, ist ein kleines Projekt, aber ein echtes Projekt:
Es liest Eingaben, verarbeitet Text und gibt ein Ergebnis aus. Übung macht den Unterschied.

Wörter:        43
Verschiedene:  34
Längstes Wort: unterschied
Häufigste:
  4× ein
  3× dann
  3× lernt

// Prüft die Logik aus Wortstatistik.swift. Jede Prüfung bricht das Programm ab, wenn sie scheitert.
struct Pruefer {
    private(set) var bestanden = 0

    mutating func pruefe(_ bedingung: Bool, _ beschreibung: String) {
        precondition(bedingung, "Fehlgeschlagen: \(beschreibung)")
        bestanden += 1
    }
}

var p = Pruefer()
p.pruefe(woerter(in: "") == [], "leerer Text hat keine Wörter")
p.pruefe(woerter(in: "Hallo, Welt!") == ["hallo", "welt"], "Satzzeichen trennen")
p.pruefe(woerter(in: "Größe ÄRGER über") == ["größe", "ärger", "über"], "Umlaute bleiben erhalten")
p.pruefe(woerter(in: "Swift 6 ist da") == ["swift", "6", "ist", "da"], "Ziffern zählen als Wort")

let s = analysiere("b a b c b a", top: 2)
p.pruefe(s.woerter == 6 && s.verschiedene == 3, "Zählung")
p.pruefe(s.haeufigste == [.init(wort: "b", anzahl: 3), .init(wort: "a", anzahl: 2)], "Reihenfolge der Häufigsten")
p.pruefe(analysiere("x y", top: 5).haeufigste.map(\.wort) == ["x", "y"], "Gleichstand alphabetisch")
p.pruefe(analysiere("kurz länger", top: 0).haeufigste.isEmpty, "top 0 liefert keine Liste")
p.pruefe(analysiere("ab cd").laengstes == "ab", "längstes Wort bei Gleichstand stabil")
p.pruefe(analysiere("").laengstes == nil, "leerer Text hat kein längstes Wort")

print("Alle \(p.bestanden) Prüfungen bestanden.")

Alle 10 Prüfungen bestanden.

import Testing
@testable import wortzaehler

@Test func satzzeichenTrennen() {
    #expect(woerter(in: "Hallo, Welt!") == ["hallo", "welt"])
}

@Test func umlauteBleibenErhalten() {
    #expect(woerter(in: "Größe ÄRGER über") == ["größe", "ärger", "über"])
}

@Test func haeufigsteMitGleichstand() {
    let s = analysiere("b a b c b a", top: 2)
    #expect(s.woerter == 6)
    #expect(s.haeufigste.map(\.wort) == ["b", "a"])
}

@Test(arguments: ["", "   ", "!!!"])
func ohneWoerter(text: String) {
    #expect(analysiere(text).woerter == 0)
}

swift build
echo "Swift ist schnell. Swift ist sicher." | swift run wortzaehler --top 2
swift test