Swift Academy · Lektion

Lazy-Sequenzen für mehr Effizienz

Verwenden Sie .lazy, um Berechnungen aufzuschieben und das Erstellen temporärer Arrays zu vermeiden.

Lektion 4 von 412 Schritte

Lazy-Sequenzen für mehr Effizienz ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Willkommen

Lazy-Sequenzen verzögern die Berechnung, bis Ergebnisse benötigt werden, und vermeiden so die Erstellung von Zwischenarrays beim Verketten von Operationen.

Das Problem der sofortigen Auswertung

```swift let result = (1...1_000_000) .filter { $0 % 7 == 0 } // creates array of ~142857 elements .map { $0 * 2 } // creates another 142857-element array .prefix(5) // Wasteful — only 5 elements needed! ```

.lazy hinzufügen

```swift let result = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // Only computes what prefix(5) needs — no intermediate arrays! print(Array(result)) // [14,28,42,56,70] ```

Lazy-Collection-Typen

Wenn Sie `.lazy` auf eine Sequenz anwenden, gibt Swift eine `LazySequence` zurück, die sie umschließt: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Wann Lazy-Auswertung vorteilhaft ist

Lazy-Auswertung ist besonders vorteilhaft, wenn: • Sie nur ein Präfix einer großen Sequenz benötigen • die Quelle unendlich ist (benutzerdefinierte Generatoren) • Sie viele Transformationen auf großen Collections verketten

Unendliche Sequenzen

```swift struct Fibonacci: Sequence { func makeIterator() -> some IteratorProtocol { var a = 0, b = 1 return AnyIterator { let next = a; a = b; b = next + b; return next } } } let first10 = Array(Fibonacci().prefix(10)) ```

Lazy mit first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

Auswertung erzwingen

Um eine Lazy-Sequenz zu materialisieren, umschließen Sie sie mit Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

Lazy gewinnt nicht immer

Bei kleinen Collections verursacht `.lazy` durch die Wrapper-Typen zusätzlichen Overhead. Führen Sie einen Benchmark durch, bevor Sie `.lazy` auf jede Kette anwenden. Verwenden Sie es, wenn die Collection groß ist und Sie eine vorzeitige Beendigung benötigen.

Benutzerdefinierter Lazy-Generator

```swift func naturals() -> AnyIterator { var n = 0 return AnyIterator { n += 1; return n } } Array(naturals().prefix(5)) // [1,2,3,4,5] ```

Kurze Überprüfung

Was bewirkt das Präfix `.lazy` in einer Collection-Kette?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Wichtige Erkenntnisse: • `.lazy` verzögert die Ausführung von map/filter, bis die Sequenz verarbeitet wird • Vermeidet die Allokation von Zwischenarrays • Nützlich für große Sequenzen, wenn nur ein Präfix benötigt wird • Mit `prefix`, `first(where:)` für eine vorzeitige Beendigung kombinieren • Bei Bedarf mit `Array(lazySeq)` materialisieren Kurs abgeschlossen!

Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 122
Lektionen: 409

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Lazy-Sequenzen für mehr Effizienz“ kostenlos?

Ja — der vollständige Text von „Lazy-Sequenzen für mehr Effizienz“ 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-Sequenzen für mehr Effizienz“?

Verwenden Sie .lazy, um Berechnungen aufzuschieben und das Erstellen temporärer Arrays zu vermeiden. 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 4 von 4.

Wie lange dauert die Lektion „Lazy-Sequenzen für mehr Effizienz“?

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

Reine Funktionen und Design ohne Seiteneffekte
Funktionen höherer Ordnung: map, flatMap, compactMap
Funktionskomposition und Pipelines
Lazy-Sequenzen für mehr Effizienz

← Zurück zu Swift Academy