Ruby Academy · Lekcja

Dołączanie Enumerable

Uzyskiwanie map/select bez dodatkowej pracy

Dołączanie Enumerable to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Ruby Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Uzyskaj map/select bez dodatkowego kodu

Gdy klasa ma już each, dołączenie modułu Enumerable natychmiast zapewnia map, select, reduce, sort, min, max i wiele innych metod, z których wszystkie opierają się na 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 }

Kontrakt

Zasada jest prosta: należy dołączyć Enumerable i zdefiniować each. Enumerable wewnętrznie wywołuje własne each, aby zapewnić działanie wszystkich pozostałych metod.

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

Filtrowanie za pomocą select

select zachowuje elementy, dla których blok zwraca wartość prawdziwą. reject działa odwrotnie.

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

Agregowanie za pomocą reduce

reduce składa kolekcję w pojedynczą wartość.

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

Metody oparte na porównywaniu działają, jeśli elementy można ze sobą porównywać.

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

find zwraca pierwszy pasujący element, a include? sprawdza przynależność elementu.

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

Enumerable udostępnia zaawansowane pomocnicze metody grupowania.

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

Sortowanie wymaga porównywalnych elementów

Jeśli elementami są własne obiekty, należy zapewnić im <=> (za pomocą Comparable), aby sort, min i max wiedziały, jak je uporządkować.

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 udostępnia również each_with_index i each_with_object do bardziej rozbudowanej iteracji.

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

Łączenie metod

Ponieważ te metody zwracają tablice lub enumeratory, można łączyć je w przejrzyste potoki operacji.

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

Połączenie wszystkiego

Dołączenie Enumerable przynosi ogromne korzyści:

Wystarczy raz zdefiniować each.
Otrzymuje się map, select, reduce, sort, find, group_by i dziesiątki innych metod.
Elementom można dodać Comparable, aby obsługiwały metody porządkowania.

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

Szybkie sprawdzenie

Sprawdź swoją znajomość dołączania Enumerable.

Podsumowanie

Omówiono dołączanie Enumerable:

Należy zdefiniować each i dołączyć moduł, aby uzyskać pełny zestaw narzędzi.
map/select/reduce/find/group_by działają na podstawie własnego each.
Porządkowanie elementów wymaga <=>.
Metody można łączyć w potoki operacji.

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

Często zadawane pytania

Czy lekcja „Dołączanie Enumerable” jest bezpłatna?

Tak — pełny tekst „Dołączanie Enumerable” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Ruby Academy, przejdź na CoddyKit PRO. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Dołączanie Enumerable”?

Uzyskiwanie map/select bez dodatkowej pracy Ćwiczysz Ruby Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Ruby Academy?

Nie wymagamy żadnego doświadczenia. Ruby Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Dołączanie Enumerable”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Ruby Academy?

Tak. Każda lekcja Ruby Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Ruby Academy