Ruby Academy · Lezione

Includere Enumerable

Ottenere map/select gratuitamente

Includere Enumerable è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Ottenere map/select gratuitamente

Una volta che la classe dispone di each, l'inclusione di Enumerable offre immediatamente map, select, reduce, sort, min, max e molti altri metodi, tutti basati sul proprio 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 }

Il contratto

Il contratto è semplice: includere Enumerable e definire each. Enumerable chiama internamente il proprio each per fornire tutte le altre funzionalità.

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

Filtrare con select

select mantiene gli elementi per i quali il blocco restituisce un valore vero. reject fa l'opposto.

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

Aggregare con reduce

reduce raccoglie la collezione in un singolo valore.

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

I metodi basati sui confronti funzionano purché gli elementi siano confrontabili.

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 restituisce il primo elemento corrispondente; include? verifica l'appartenenza.

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

Enumerable offre potenti strumenti per raggruppare gli elementi.

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

Ordinare richiede elementi Comparable

Se gli elementi sono oggetti personalizzati, assegni loro <=> tramite Comparable, così sort, min e max sapranno come ordinarli.

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 fornisce anche each_with_index e each_with_object per un'iterazione più ricca.

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

Concatenare i metodi

Poiché questi metodi restituiscono array o enumeratori, è possibile concatenarli in pipeline espressive.

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

Mettere tutto insieme

Includere Enumerable è un grande vantaggio:

Si definisce each una sola volta.
Si ottengono map, select, reduce, sort, find, group_by e decine di altri metodi.
Si aggiunge Comparable agli elementi per ottenere i metodi di ordinamento.

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

Verifica rapida

Verifichi la propria comprensione dell'inclusione di Enumerable.

Riepilogo

Ha imparato a includere Enumerable:

Definisca each, includa il modulo e ottenga l'intero set di strumenti.
map, select, reduce, find e group_by funzionano tutti sul proprio each.
Per ordinare gli elementi è necessario definire <=>.
I metodi possono essere concatenati in pipeline.

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

Domande Frequenti

La lezione «Includere Enumerable» è gratuita?

Sì — il testo completo di «Includere Enumerable» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Includere Enumerable»?

Ottenere map/select gratuitamente Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Includere Enumerable»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Ruby Academy