Ruby Academy · Lektion

Enumerable einbinden

map/select automatisch erhalten

Enumerable einbinden ist eine kostenlose Ruby Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

map/select ohne zusätzlichen Aufwand

Sobald Ihre Klasse über each verfügt, erhalten Sie durch das Einbinden von Enumerable sofort map, select, reduce, sort, min, max und viele weitere Methoden, die alle auf Ihrem each aufbauen.

class Bag
  include Enumerable
  def initialize(*x); @x = x; end
  def each; @x.each { |i| yield i }; end
end
p Bag.new(1, 2, 3).map { |n| n * 10 }

Die Vereinbarung

Die Vereinbarung ist einfach: Binden Sie Enumerable ein und definieren Sie each. Enumerable ruft Ihr each intern auf, um alle anderen Funktionen bereitzustellen.

class Squares
  include Enumerable
  def initialize(n); @n = n; end
  def each
    (1..@n).each { |i| yield i * i }
  end
end
p Squares.new(5).to_a

Mit select filtern

select behält Elemente, für die der Block einen Wahrheitswert liefert. reject macht das Gegenteil.

class Nums
  include Enumerable
  def initialize(*x); @x = x; end
  def each; @x.each { |i| yield i }; end
end
n = Nums.new(1, 2, 3, 4, 5, 6)
p n.select(&:even?)
p n.reject(&:even?)

Mit reduce aggregieren

reduce fasst eine Collection zu einem einzelnen Wert zusammen.

class Cart
  include Enumerable
  def initialize(*p); @p = p; end
  def each; @p.each { |i| yield i }; end
end
puts Cart.new(5, 10, 15).reduce(:+)

min, max, sort

Vergleichsbasierte Methoden funktionieren, solange Ihre Elemente vergleichbar sind.

class Scores
  include Enumerable
  def initialize(*n); @n = n; end
  def each; @n.each { |i| yield i }; end
end
s = Scores.new(7, 2, 9, 4)
puts s.min
puts s.max
p s.sort

find und include?

find gibt das erste passende Element zurück; include? prüft die Zugehörigkeit.

class Words
  include Enumerable
  def initialize(*w); @w = w; end
  def each; @w.each { |x| yield x }; end
end
w = Words.new("cat", "dog", "bird")
puts w.find { |x| x.length == 4 }
puts w.include?("dog")

group_by und partition

Enumerable bietet leistungsfähige Hilfsmethoden zum Gruppieren.

class Nums
  include Enumerable
  def initialize(*x); @x = x; end
  def each; @x.each { |i| yield i }; end
end
n = Nums.new(1, 2, 3, 4, 5)
p n.group_by(&:even?)
p n.partition(&:odd?)

Zum Sortieren werden vergleichbare Elemente benötigt

Wenn Ihre Elemente benutzerdefinierte Objekte sind, geben Sie ihnen <=> (über Comparable), damit sort, min und max wissen, wie sie die Elemente ordnen sollen.

Item = Struct.new(:price) do
  include Comparable
  def <=>(o); price <=> o.price; end
end
class Shelf
  include Enumerable
  def initialize(*i); @i = i; end
  def each; @i.each { |x| yield x }; end
end
shelf = Shelf.new(Item.new(30), Item.new(10), Item.new(20))
p shelf.min.price

each_with_index

Enumerable stellt außerdem each_with_index und each_with_object für eine umfangreichere Iteration bereit.

class Letters
  include Enumerable
  def initialize(*l); @l = l; end
  def each; @l.each { |x| yield x }; end
end
Letters.new("a", "b", "c").each_with_index do |letter, i|
  puts "#{i}: #{letter}"
end

Methoden verketten

Da diese Methoden Arrays oder Enumerator-Objekte zurückgeben, können Sie sie zu ausdrucksstarken Pipelines verketten.

class Nums
  include Enumerable
  def initialize(*x); @x = x; end
  def each; @x.each { |i| yield i }; end
end
result = Nums.new(1, 2, 3, 4, 5, 6).select(&:even?).map { |n| n * n }
p result

Alles zusammenführen

Enumerable einzubinden, bringt große Vorteile:

each einmal definieren.
map, select, reduce, sort, find, group_by und Dutzende weitere Methoden erhalten.
Comparable zu den Elementen hinzufügen, um Ordnungsmethoden zu ermöglichen.

class Range5
  include Enumerable
  def each; (1..5).each { |n| yield n }; end
end
puts Range5.new.sum

Kurzer Test

Testen Sie Ihr Verständnis vom Einbinden von Enumerable.

Zusammenfassung

Sie haben gelernt, Enumerable einzubinden:

each definieren, das Modul einbinden und das vollständige Toolkit erhalten.
map/select/reduce/find/group_by arbeiten alle mit Ihrem each.
Zum Ordnen der Elemente wird <=> benötigt.
Methoden lassen sich zu Pipelines verketten.

class Tens
  include Enumerable
  def each; [10, 20, 30].each { |n| yield n }; end
end
p Tens.new.map { |n| n + 1 }

Häufig gestellte Fragen

Ist die Lektion „Enumerable einbinden“ kostenlos?

Ja — der vollständige Text von „Enumerable einbinden“ 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 „Enumerable einbinden“?

map/select automatisch erhalten 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 2 von 4.

Wie lange dauert die Lektion „Enumerable einbinden“?

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