Swift Academy · Lektion

Lazy und eager im Vergleich

Erkennen Sie, wann verzögerte Auswertung nützt oder schadet.

Lazy und eager im Vergleich ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Kein kostenloses Mittagessen

Lazy ist nicht immer schneller. Es tauscht die sofortige Speicherzuweisung gegen einen Mehraufwand bei jedem Zugriff und verändert den Zeitpunkt, zu dem Seiteneffekte ausgeführt werden. Wenn Sie diese Kompromisse kennen, können Sie die richtige Wahl treffen.

Lazy gewinnt: teilweise Verarbeitung

Von einer umfangreichen Transformation wird nur ein Teil benötigt — Lazy überspringt den Rest:

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

Eager gewinnt: vollständige Wiederverwendung

Wenn Sie das Ergebnis oft durchlaufen, berechnet Eager es einmal; Lazy berechnet es bei jedem Durchlauf erneut:

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

Lazy berechnet erneut

Dieselbe Lazy-Ansicht führt die Arbeit bei jeder Iteration erneut aus:

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

Mehraufwand pro Element

Jeder Lazy-Schritt verpackt die Sequenz in einen weiteren Typ und ruft für jedes Element Closures auf. Bei winzigen Arrays kann dieser Mehraufwand die eingesparte Speicherzuweisung überwiegen.

Kleines Array, Eager ist in Ordnung

Bei einer kleinen Anzahl vollständig verarbeiteter Elemente ist gewöhnliches Eager-Verhalten vorzuziehen — es ist einfacher, und die Speicherzuweisung ist unbedeutend:

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

Der Zeitpunkt von Seiteneffekten unterscheidet sich

Bei Lazy wird der Closure-Body später ausgeführt als die Zeile, in der er definiert wird. Verlassen Sie sich bei Lazy-Transformationen nicht auf Seiteneffekte:

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

Operationen, die Eager erzwingen

Einige Operationen müssen die gesamte Sequenz ohnehin lesen, daher bietet Lazy dort keinen Vorteil:

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

Lazy plus contains

Operationen mit vorzeitigem Abbruch wie contains(where:) profitieren bei großen Eingaben von Lazy:

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

Eine Entscheidungshilfe

Verwenden Sie Lazy, wenn die Quelle groß ist, Sie nur einen Teil behalten (prefix / first / contains) und die Sequenz einmal durchlaufen. Verwenden Sie Eager, wenn das Array klein ist, Sie das Ergebnis wiederverwenden oder Lesbarkeit wichtiger ist als Mikrooptimierung.

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

Messen statt raten

Das eigene Gefühl für Performance ist oft unzuverlässig. Wenn es darauf ankommt, vergleichen Sie beide Varianten mit realistischen Daten, bevor Sie sich für Lazy entscheiden.

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

Kurze Überprüfung

Wann ist eager die bessere Wahl gegenüber Lazy?

Zusammenfassung

Sie haben die Kompromisse kennengelernt:

Lazy gewinnt bei großen Quellen mit teilweise und nur einmal verarbeiteten Daten
Eager gewinnt bei kleinen Arrays und wiederverwendeten Ergebnissen (Lazy berechnet erneut)
Seiteneffekte in Lazy-Transformationen werden später ausgeführt — verlassen Sie sich nicht auf sie
Messen Sie vor der Optimierung

Als Nächstes: eigene Lazy-Sequenzen erstellen.

Häufig gestellte Fragen

Ist die Lektion „Lazy und eager im Vergleich“ kostenlos?

Ja — der vollständige Text von „Lazy und eager im Vergleich“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Lazy und eager im Vergleich“?

Erkennen Sie, wann verzögerte Auswertung nützt oder schadet. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Lazy und eager im Vergleich“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy