Ruby Academy · Leçon

Inclure Enumerable

Obtenez map/select gratuitement

Inclure Enumerable est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Obtenir map/select gratuitement

Une fois que votre classe possède each, l'ajout de Enumerable vous fournit instantanément map, select, reduce, sort, min, max et bien d'autres méthodes, toutes construites à partir de votre each.

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 }

Le contrat

Le principe est simple : incluez Enumerable et définissez each. Enumerable appelle votre each en interne pour faire fonctionner tout le reste.

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

Filtrer avec select

select conserve les éléments pour lesquels le bloc renvoie une valeur vraie. reject fait l'inverse.

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?)

Agrégation avec reduce

reduce plie la collection pour la transformer en une seule valeur.

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(:+)

Minimum, maximum, tri

Les méthodes fondées sur la comparaison fonctionnent tant que vos éléments sont comparables.

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

Rechercher et vérifier l'appartenance

find renvoie le premier élément correspondant ; include? vérifie l'appartenance.

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

Enumerable propose de puissants outils de regroupement.

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?)

Le tri nécessite des éléments comparables

Si vos éléments sont des objets personnalisés, donnez-leur <=> (par l'intermédiaire de Comparable) afin que sort, min et max sachent les ordonner.

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

Enumerable fournit également each_with_index et each_with_object pour une itération plus riche.

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

Enchaîner les méthodes

Comme ces méthodes renvoient des tableaux ou des énumérateurs, vous pouvez les enchaîner pour créer des traitements expressifs.

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

Inclure le module itérable

L'inclusion du module itérable est très avantageuse :

Définissez each une seule fois.
Obtenez map, select, reduce, tri, recherche, group_by et des dizaines d'autres méthodes.
Ajoutez le module comparable aux éléments pour disposer des méthodes d'ordonnancement.

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

Vérification rapide

Évaluez votre compréhension de l'inclusion d'Enumerable.

Récapitulatif

Vous avez appris à inclure Enumerable :

Définissez each, incluez le module et obtenez toute la boîte à outils.
map/select/reduce/find/group_by s'exécutent tous à partir de votre each.
L'ordre des éléments nécessite <=>.
Les méthodes peuvent être enchaînées pour former des traitements.

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

Questions Fréquemment Posées

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

Oui — le texte complet de « Inclure 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 « Inclure Enumerable » ?

Obtenez map/select gratuitement 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 2 sur 4.

Combien de temps prend la leçon « Inclure 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