Ruby Academy · Lección

Inclusión de Enumerable

Obtenga map/select sin esfuerzo

Inclusión de Enumerable es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

Obtenga map/select gratis

Una vez que su clase tiene each, al incluir Enumerable obtiene al instante map, select, reduce, sort, min, max y muchos más, todos basados en su 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 }

El contrato

El acuerdo es sencillo: incluya Enumerable y defina each. Enumerable llama internamente a su each para hacer funcionar todo lo demás.

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

Filtrar con select

select conserva los elementos cuyo bloque devuelve un valor verdadero. reject hace lo contrario.

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

Agregar con reduce

reduce pliega la colección en un único valor.

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

Los métodos basados en comparaciones funcionan siempre que sus elementos se puedan comparar.

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 e include?

find devuelve el primer elemento que coincide; include? comprueba la pertenencia.

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

Enumerable ofrece potentes herramientas auxiliares para agrupar.

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

Ordenar requiere elementos Comparable

Si sus elementos son objetos personalizados, proporcióneles <=> (mediante Comparable) para que sort, min y max sepan cómo ordenarlos.

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 también proporciona each_with_index y each_with_object para realizar iteraciones más completas.

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

Encadenar métodos

Como estos métodos devuelven arrays o enumeradores, puede encadenarlos para crear pipelines expresivos.

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

Cómo encaja todo

Incluir Enumerable aporta grandes ventajas:

Defina each una sola vez.
Obtenga map, select, reduce, sort, find, group_by y muchas opciones más.
Añada Comparable a los elementos para disponer de métodos de ordenación.

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

Comprobación rápida

Compruebe cuánto entiende de la inclusión de Enumerable.

Resumen

Ha aprendido a incluir Enumerable:

Defina each, incluya el módulo y obtenga el conjunto completo de herramientas.
map/select/reduce/find/group_by se ejecutan sobre su each.
Para ordenar los elementos se necesita <=>.
Los métodos se pueden encadenar en pipelines.

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

Preguntas frecuentes

¿La lección «Inclusión de Enumerable» es gratis?

Sí — el texto completo de «Inclusión de Enumerable» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Inclusión de Enumerable»?

Obtenga map/select sin esfuerzo Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Inclusión de Enumerable»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Ruby Academy