Ruby Academy · Lektion

Faule Enumeratoren

Faule Auswertung

Faule Enumeratoren ist eine kostenlose Ruby 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 Ruby Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Ruby Academy-Kurs umfasst insgesamt 4 Lektionen.

Verzögerte Auswertung

Normalerweise verarbeiten Enumerable-Methoden die gesamte Collection auf einmal. Ein Lazy-Enumerator verarbeitet die Elemente einzeln und nur bei Bedarf. Dadurch können Sie mit sehr großen oder sogar unendlichen Sequenzen arbeiten.

result = (1..Float::INFINITY).lazy.map { |n| n * 2 }.first(5)
p result

Das Problem sofortiger Auswertung

Wenn Sie map ohne lazy auf einen unendlichen Bereich anwenden, wird der Vorgang nie beendet, da zunächst ein vollständiges Ergebnis-Array erstellt werden soll.

# Eager version would hang. Lazy completes instantly:
first_three = (1..Float::INFINITY).lazy.select(&:even?).first(3)
p first_three

Einen Lazy-Enumerator erstellen

Rufen Sie .lazy auf einem beliebigen Enumerable-Objekt auf, um eine verzögerte Version zu erhalten. Verkettete Methoden werden dadurch ebenfalls verzögert ausgewertet.

lazy = (1..10).lazy
puts lazy.class

Nichts läuft, bis die Auswertung erzwungen wird

Verzögerte Ketten erstellen zunächst nur eine Verarbeitungsvorschrift, führen sie aber nicht aus. Eine abschließende Methode wie first, to_a oder force löst die Verarbeitung aus.

chain = (1..Float::INFINITY).lazy.map { |n| n * n }
puts "Nothing computed yet"
p chain.first(4)

Ergebnisse erzwingen

force (Alias to_a) wertet eine begrenzte verzögerte Kette vollständig aus und erstellt daraus ein Array.

result = (1..20).lazy.select(&:odd?).first(5)
p result
all = (1..6).lazy.map { |n| n * 10 }.force
p all

Verzögert verketten

Mehrere verzögerte Operationen werden pro Element ineinander verzahnt, statt als getrennte vollständige Durchläufe ausgeführt zu werden. Jeder Wert durchläuft die gesamte Kette, bevor der nächste verarbeitet wird.

result = (1..Float::INFINITY)
  .lazy
  .map { |n| n * n }
  .select { |n| n.even? }
  .first(4)
p result

take und take_while

Verzögertes take und take_while fordern keine weiteren Werte an, sobald ihre Bedingung erfüllt ist.

result = (1..Float::INFINITY).lazy.take_while { |n| n < 6 }.to_a
p result

Unendliche Sequenzen

Lazy-Enumeratoren spielen ihre Stärken bei Generatoren aus. Kombinieren Sie sie mit Enumerator, um endlose Datenströme abzubilden.

naturals = Enumerator.new do |y|
  n = 1
  loop { y << n; n += 1 }
end
p naturals.lazy.map { |x| x * 3 }.first(5)

Speichereffizienz

Da verzögerte Ketten die vollständige Collection der Zwischenergebnisse nie materialisieren, sparen sie beim Filtern großer Datenmengen auf wenige Ergebnisse Speicher.

big = (1..1_000_000).lazy
first_match = big.select { |n| n % 7 == 0 && n % 11 == 0 }.first
puts first_match

Wann Sie lazy verwenden sollten

Verwenden Sie lazy, wenn:

Die Quelle unendlich oder sehr groß ist.
Sie nur wenige Ergebnisse benötigen.
Sie große Zwischen-Arrays vermeiden möchten.

Für kleine Collections sind sofort auswertende Methoden einfacher und schnell genug.

fizz = (1..Float::INFINITY).lazy.select { |n| n % 3 == 0 }.first(5)
p fizz

Alles zusammenführen

Lazy-Enumeratoren verschieben die Verarbeitung:

.lazy macht eine Kette verzögert.
Die Verarbeitung beginnt erst, wenn eine abschließende Methode Werte anfordert.
Ideal für unendliche oder sehr große Sequenzen.

squares = (1..Float::INFINITY).lazy.map { |n| n * n }
p squares.select(&:odd?).first(4)

Kurzer Test

Testen Sie Ihr Verständnis verzögerter Enumeratoren.

Zusammenfassung

Sie haben verzögerte Enumeratoren kennengelernt:

.lazy verschiebt die Berechnung.
Abschließende Methoden (first, to_a, force) lösen die Verarbeitung aus.
Jeder Wert durchläuft bei Bedarf die gesamte Kette.
Ideal für unendliche oder große Sequenzen.

p (1..Float::INFINITY).lazy.select(&:even?).map { |n| n + 1 }.first(3)

Häufig gestellte Fragen

Ist die Lektion „Faule Enumeratoren“ kostenlos?

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

Was lerne ich in „Faule Enumeratoren“?

Faule Auswertung Du übst Ruby 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 Ruby Academy zu starten?

Keine Vorkenntnisse erforderlich. Ruby 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 „Faule Enumeratoren“?

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 Ruby Academy-Lektion Code schreiben und ausführen?

Ja. Jede Ruby 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 Ruby Academy