Ruby Academy · Lektion

Comparable und Enumerable

Standard-Mixins

Comparable und Enumerable 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.

Standard-Mixins

Ruby liefert leistungsfähige Module mit, die Sie in Ihre eigenen Klassen einmischen können. Zwei besonders wichtige sind Comparable und Enumerable. Jedes stellt Ihnen viele Methoden bereit, wenn Sie dafür nur eine einzige implementieren.

puts Comparable.instance_methods.sort.inspect

Comparable benötigt <=>

Comparable verlangt, dass Sie den Spaceship-Operator <=> definieren, der -1, 0 oder 1 zurückgibt. Im Gegenzug erhalten Sie <, <=, ==, >, >= und between?.

class Weight
  include Comparable
  attr_reader :grams
  def initialize(g); @grams = g; end
  def <=>(other); grams <=> other.grams; end
end
puts Weight.new(50) < Weight.new(80)

Vergleichsmethoden ohne Mehraufwand

Sobald ein Operator definiert ist, funktionieren alle Vergleichsmethoden automatisch.

class Weight
  include Comparable
  attr_reader :grams
  def initialize(g); @grams = g; end
  def <=>(other); grams <=> other.grams; end
end
a = Weight.new(100)
b = Weight.new(100)
puts a == b
puts Weight.new(30).between?(Weight.new(10), Weight.new(50))

clamp aus Comparable

Comparable stellt außerdem clamp bereit, das einen Wert innerhalb eines Bereichs hält.

puts 15.clamp(0, 10)
puts (-5).clamp(0, 10)
puts 7.clamp(0, 10)

Comparable-Objekte sortieren

Da <=> definiert ist, kann ein Array Ihrer Objekte automatisch sortiert werden.

class Weight
  include Comparable
  attr_reader :grams
  def initialize(g); @grams = g; end
  def <=>(other); grams <=> other.grams; end
  def to_s; "#{grams}g"; end
end
list = [Weight.new(30), Weight.new(10), Weight.new(20)]
puts list.sort.map(&:to_s).inspect

Enumerable benötigt each

Enumerable verlangt, dass Sie each definieren. Dafür erhalten Sie map, select, reduce, min, max, sort und Dutzende weitere Methoden.

class TodoList
  include Enumerable
  def initialize(*items); @items = items; end
  def each(&block); @items.each(&block); end
end
list = TodoList.new("buy milk", "call mom")
puts list.map(&:upcase).inspect

Aggregation ohne zusätzlichen Aufwand

Sobald each vorhanden ist, stehen Aggregationsmethoden wie count, min und include? zur Verfügung.

class Scores
  include Enumerable
  def initialize(*n); @n = n; end
  def each(&block); @n.each(&block); end
end
s = Scores.new(8, 3, 9, 4)
puts s.max
puts s.min
puts s.count

select und reject

Auch Filtermethoden stehen Ihnen zur Verfügung.

class Numbers
  include Enumerable
  def initialize(*n); @n = n; end
  def each(&block); @n.each(&block); end
end
nums = Numbers.new(1, 2, 3, 4, 5, 6)
p nums.select(&:even?)
p nums.reject(&:even?)

reduce für Summen

reduce (Alias inject) kombiniert Elemente, zum Beispiel indem es sie addiert.

class Basket
  include Enumerable
  def initialize(*p); @p = p; end
  def each(&block); @p.each(&block); end
end
b = Basket.new(10, 20, 30)
puts b.reduce(0) { |sum, price| sum + price }

Beide Mixins kombinieren

Fügen Sie Comparable zum Sortieren und Enumerable für die Iteration hinzu, wirkt Ihre Klasse wie eine integrierte Collection.

class Playlist
  include Enumerable
  def initialize(*songs); @songs = songs; end
  def each(&block); @songs.each(&block); end
end
pl = Playlist.new("c", "a", "b")
puts pl.sort.inspect
puts pl.first

Alles zusammenführen

Standard-Mixins liefern viel Funktionalität für eine kleine Vereinbarung:

Comparable: Definieren Sie <=> und erhalten Sie alle Vergleichsoperationen.
Enumerable: Definieren Sie each und erhalten Sie das vollständige Collection-Toolkit.

class Bag
  include Enumerable
  def initialize(*x); @x = x; end
  def each(&b); @x.each(&b); end
end
puts Bag.new(3, 1, 2).sort.inspect

Kurzer Test

Testen Sie Ihr Verständnis der Standard-Mixins.

Zusammenfassung

Sie haben Standard-Mixins kennengelernt:

Comparable benötigt <=> und stellt Vergleiche, clamp und between? bereit.
Enumerable benötigt each und stellt map, select, reduce, min, max und weitere Methoden bereit.
Zusammen verleihen sie benutzerdefinierten Klassen ein natives Verhalten.

class Temp
  include Comparable
  attr_reader :deg
  def initialize(d); @deg = d; end
  def <=>(o); deg <=> o.deg; end
end
puts Temp.new(20) > Temp.new(15)

Häufig gestellte Fragen

Ist die Lektion „Comparable und Enumerable“ kostenlos?

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

Standard-Mixins 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 „Comparable und Enumerable“?

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