Ruby Academy · Lekcja

Pisanie własnego each

Implementowanie iteracji

Pisanie własnego each to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 1 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.

Implementowanie iteracji

Iteracja w Ruby opiera się na jednej metodzie: each. Implementując własne each, określa się sposób przechodzenia po kolekcji i odblokowuje cały ekosystem iteracji.

class Trio
  def each
    yield 1
    yield 2
    yield 3
  end
end
Trio.new.each { |n| puts n }

each przekazuje wartości

Wewnątrz each należy wywołać yield raz dla każdego elementu. Blok przekazany przez wywołującego otrzymuje kolejno poszczególne wartości.

class Days
  NAMES = ["Mon", "Tue", "Wed"]
  def each
    NAMES.each { |d| yield d }
  end
end
Days.new.each { |day| puts day }

Przechowywanie danych wewnętrznych

Zwykle each przechodzi po danych przechowywanych w zmiennej instancji.

class Stack
  def initialize
    @items = []
  end
  def push(x); @items << x; self; end
  def each
    @items.each { |i| yield i }
  end
end
s = Stack.new
s.push(10).push(20)
s.each { |x| puts x }

Własna kolejność przechodzenia

Własne each może iterować w dowolnej kolejności, na przykład od końca.

class Reversed
  def initialize(arr); @arr = arr; end
  def each
    i = @arr.length - 1
    while i >= 0
      yield @arr[i]
      i -= 1
    end
  end
end
Reversed.new([1, 2, 3]).each { |x| puts x }

Przekazywanie wielu wartości

yield może przekazać więcej niż jedną wartość, które blok otrzymuje jako wiele parametrów, podobnie jak klucz i wartość skrótu.

class Pairs
  def each
    yield :a, 1
    yield :b, 2
  end
end
Pairs.new.each { |key, value| puts "#{key}=#{value}" }

each zwraca self

Zgodnie z konwencją each zwraca samą kolekcję, dzięki czemu można łączyć wywołania. Zwracanie self z each odpowiada zachowaniu metod wbudowanych.

class Box
  def initialize(*x); @x = x; end
  def each
    @x.each { |i| yield i }
    self
  end
end
result = Box.new(1, 2).each { |i| }
puts result.class

Korzystanie z block_given?

Należy zabezpieczyć się przed brakiem bloku, aby wywołanie samego each nie powodowało błędu — często zwracając enumerator, który zostanie omówiony później.

class List
  def initialize(*x); @x = x; end
  def each
    return @x.to_enum unless block_given?
    @x.each { |i| yield i }
  end
end
puts List.new(5, 6).each.class

Budowanie innych metod

Gdy each jest już dostępne, można na jego podstawie budować inne metody w tej samej klasie.

class Numbers
  def initialize(*n); @n = n; end
  def each; @n.each { |i| yield i }; end
  def total
    sum = 0
    each { |i| sum += i }
    sum
  end
end
puts Numbers.new(1, 2, 3, 4).total

Obliczane sekwencje

each nie musi niczego przechowywać — może generować wartości w locie.

class Evens
  def initialize(limit); @limit = limit; end
  def each
    n = 0
    while n <= @limit
      yield n
      n += 2
    end
  end
end
Evens.new(8).each { |x| puts x }

Podstawa Enumerable

Własne each jest jedynym elementem konstrukcyjnym wymaganym przez Enumerable. W następnej lekcji zostanie on dołączony, zapewniając dziesiątki metod bez dodatkowego kodu.

class Range3
  def each
    (1..3).each { |n| yield n }
  end
end
Range3.new.each { |n| print n }
puts

Połączenie wszystkiego

Własne each zapewnia pełną kontrolę nad iteracją:

yield jest wywoływane raz dla każdego elementu.
Można przechodzić w dowolnej kolejności, generować wartości lub przekazywać pary.
Zgodnie z konwencją należy zwracać self.

class Countdown
  def initialize(from); @from = from; end
  def each
    @from.downto(1) { |n| yield n }
  end
end
Countdown.new(3).each { |n| puts n }

Szybkie sprawdzenie

Sprawdź swoją znajomość własnej metody each.

Podsumowanie

Omówiono implementowanie własnego each:

yield przekazuje elementy do bloku wywołującego.
Można kontrolować kolejność przechodzenia i generować wartości.
Zgodnie z konwencją należy zwracać self.
each jest podstawą modułu Enumerable.

class Squares
  def initialize(n); @n = n; end
  def each
    (1..@n).each { |i| yield i * i }
  end
end
Squares.new(4).each { |sq| puts sq }

Często zadawane pytania

Czy lekcja „Pisanie własnego each” jest bezpłatna?

Tak — pełny tekst „Pisanie własnego each” 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 „Pisanie własnego each”?

Implementowanie iteracji Ć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 1 z 4.

Ile czasu zajmuje lekcja „Pisanie własnego each”?

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