Ruby Academy · Leçon

Comparable et Enumerable

Mixins standard

Comparable et Enumerable est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Mélanges standard

Ruby fournit de puissants modules que vous pouvez mélanger à vos propres classes. Deux vedettes sont Comparable et Enumerable. Chacun vous fournit de nombreuses méthodes en échange de l’implémentation d’une seule.

puts Comparable.instance_methods.sort.inspect

Comparable nécessite <=>

Comparable exige que vous définissiez l’opérateur spaceship <=>, qui renvoie -1, 0 ou 1. En contrepartie, vous obtenez <, <=, ==, >, >= et 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)

Méthodes de comparaison offertes

Une fois un seul opérateur défini, toutes les méthodes de comparaison fonctionnent automatiquement.

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 avec comparable

Comparable fournit également clamp, qui maintient une valeur dans une plage donnée.

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

Trier des objets comparables

Comme <=> est défini, un tableau de vos objets peut être trié automatiquement.

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

Le module itérable nécessite each

Enumerable vous demande de définir each. En contrepartie, vous obtenez map, select, reduce, min, max, sort et des dizaines d'autres méthodes.

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

Agrégation automatique

Une fois each défini, des méthodes d'agrégation comme count, min et include? sont disponibles.

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 et reject

Les méthodes de filtrage sont également disponibles.

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 pour les totaux

reduce (alias de inject) combine les éléments, par exemple pour les additionner.

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 }

Combiner les deux modules de mélange

Ajoutez Comparable pour le tri et Enumerable pour l'itération : votre classe ressemble alors à une collection intégrée au langage.

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

Tout mettre en place

Les modules standard récompensent un contrat minimal :

Comparable : définissez <=> pour obtenir toutes les comparaisons.
Enumerable : définissez each pour obtenir toute la boîte à outils des collections.

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

Vérification rapide

Évaluez votre compréhension des modules standard.

Récapitulatif

Vous avez découvert les modules standard :

Comparable nécessite <=> et fournit la comparaison, ainsi que clamp et between?.
Enumerable nécessite each et fournit map, select, reduce, min, max et bien d'autres méthodes.
Ensemble, ils donnent aux classes personnalisées un comportement natif.

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)

Questions Fréquemment Posées

La leçon « Comparable et Enumerable » est-elle gratuite ?

Oui — le texte complet de « Comparable et Enumerable » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comparable et Enumerable » ?

Mixins standard Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Comparable et Enumerable » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy