Ruby Academy · Lektion

Eigenes each schreiben

Iteration implementieren

Eigenes each schreiben ist eine kostenlose Ruby Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Iteration implementieren

Rubys Iteration dreht sich um eine Methode: each. Indem Sie Ihr eigenes each schreiben, bestimmen Sie, wie eine Collection durchlaufen wird, und erschließen das gesamte Iterations-Ökosystem.

class Trio
  def each
    yield 1
    yield 2
    yield 3
  end
end
Trio.new.each { |n| puts n }

each liefert Werte

Rufen Sie innerhalb von each für jedes Element einmal yield auf. Der vom Aufrufer bereitgestellte Block erhält nacheinander jeden Wert.

class Days
  NAMES = ["Mon", "Tue", "Wed"]
  def each
    NAMES.each { |d| yield d }
  end
end
Days.new.each { |day| puts day }

Interne Daten speichern

In der Regel durchläuft each Daten, die in einer Instanzvariablen gespeichert sind.

class Stack
  def initialize
    @items = []
  end
  def push(x); @items << x; self; end
  def each
    @items.each { |i| yield i }
  end
end
s = Stack.new
s.push(10).push(20)
s.each { |x| puts x }

Benutzerdefinierte Durchlaufreihenfolge

Ihr each kann die Elemente in jeder gewünschten Reihenfolge durchlaufen, zum Beispiel rückwärts.

class Reversed
  def initialize(arr); @arr = arr; end
  def each
    i = @arr.length - 1
    while i >= 0
      yield @arr[i]
      i -= 1
    end
  end
end
Reversed.new([1, 2, 3]).each { |x| puts x }

Mehrere Werte liefern

yield kann mehr als einen Wert übergeben. Der Block erhält diese als mehrere Parameter, etwa Schlüssel und Wert eines Hashes.

class Pairs
  def each
    yield :a, 1
    yield :b, 2
  end
end
Pairs.new.each { |key, value| puts "#{key}=#{value}" }

each gibt self zurück

Konventionell gibt each die Collection selbst zurück, sodass Aufrufe verkettet werden können. Wenn Sie aus each self zurückgeben, entspricht das dem Verhalten integrierter Collections.

class Box
  def initialize(*x); @x = x; end
  def each
    @x.each { |i| yield i }
    self
  end
end
result = Box.new(1, 2).each { |i| }
puts result.class

block_given? verwenden

Fangen Sie einen fehlenden Block ab, damit ein Aufruf von each ohne Block keinen Fehler verursacht, häufig indem Sie einen Enumerator zurückgeben (wird später behandelt).

class List
  def initialize(*x); @x = x; end
  def each
    return @x.to_enum unless block_given?
    @x.each { |i| yield i }
  end
end
puts List.new(5, 6).each.class

Andere Methoden darauf aufbauen

Sobald each vorhanden ist, können Sie innerhalb derselben Klasse weitere Methoden darauf aufbauen.

class Numbers
  def initialize(*n); @n = n; end
  def each; @n.each { |i| yield i }; end
  def total
    sum = 0
    each { |i| sum += i }
    sum
  end
end
puts Numbers.new(1, 2, 3, 4).total

Berechnete Sequenzen

each muss nichts speichern, sondern kann Werte auch während der Ausführung erzeugen.

class Evens
  def initialize(limit); @limit = limit; end
  def each
    n = 0
    while n <= @limit
      yield n
      n += 2
    end
  end
end
Evens.new(8).each { |x| puts x }

Die Grundlage für Enumerable

Ihr each ist der einzige Baustein, den Enumerable benötigt. In der nächsten Lektion binden Sie es ein und erhalten Dutzende Methoden ohne zusätzlichen Aufwand.

class Range3
  def each
    (1..3).each { |n| yield n }
  end
end
Range3.new.each { |n| print n }
puts

Alles zusammenführen

Mit einem benutzerdefinierten each haben Sie vollständige Kontrolle über die Iteration:

Einmal pro Element yield aufrufen.
In beliebiger Reihenfolge durchlaufen, Werte erzeugen oder Paare liefern.
Konventionsgemäß self zurückgeben.

class Countdown
  def initialize(from); @from = from; end
  def each
    @from.downto(1) { |n| yield n }
  end
end
Countdown.new(3).each { |n| puts n }

Kurzer Test

Testen Sie Ihr Verständnis von benutzerdefiniertem each.

Zusammenfassung

Sie haben gelernt, ein benutzerdefiniertes each zu schreiben:

yield übergibt Elemente an den Block des Aufrufers.
Sie bestimmen die Durchlaufreihenfolge und können Werte erzeugen.
Geben Sie konventionsgemäß self zurück.
each bildet die Grundlage für Enumerable.

class Squares
  def initialize(n); @n = n; end
  def each
    (1..@n).each { |i| yield i * i }
  end
end
Squares.new(4).each { |sq| puts sq }

Häufig gestellte Fragen

Ist die Lektion „Eigenes each schreiben“ kostenlos?

Ja — der vollständige Text von „Eigenes each schreiben“ 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 „Eigenes each schreiben“?

Iteration implementieren 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 1 von 4.

Wie lange dauert die Lektion „Eigenes each schreiben“?

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