Lua Academy · Lekcja

Generatory oparte na korutynach

Proszę używać coroutine.wrap do tworzenia leniwie generowanych sekwencji.

Generatory oparte na korutynach to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 4 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 Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Dlaczego używać generatorów coroutine

Domknięcia dobrze sprawdzają się w przypadku prostych generatorów. Jeśli jednak logika generowania wymaga zagnieżdżonych pętli lub złożonego sterowania przepływem, generator coroutine jest znacznie czytelniejszy.

Podstawy coroutine.wrap

coroutine.wrap(fn) zwraca funkcję. Każde wywołanie wznawia coroutine, a wartości zwrócone przez coroutine.yield stają się wartością zwracaną.

local gen = coroutine.wrap(function()
  coroutine.yield(1)
  coroutine.yield(2)
  coroutine.yield(3)
end)
for v in gen do print(v) end

Generator nieskończonego ciągu

Coroutine może zwracać wartości bez końca, dzięki czemu doskonale nadaje się do nieskończonych ciągów kończonych przez wywołującego za pomocą break.

local function naturals()
  return coroutine.wrap(function()
    local n = 0
    while true do
      n = n + 1
      coroutine.yield(n)
    end
  end)
end
for v in naturals() do
  if v > 5 then break end
  print(v)
end

Generator przechodzenia drzewa

Rekurencyjne przechodzenie w głąb jest proste dzięki coroutine — wystarczy zwracać wartości z wywołań rekurencyjnych, bez ręcznego zarządzania stosem.

local function walkTree(node)
  return coroutine.wrap(function()
    local function recurse(n)
      coroutine.yield(n.value)
      for _, child in ipairs(n.children or {}) do
        recurse(child)
      end
    end
    recurse(node)
  end)
end

Generator ciągu Fibonacciego

Ciąg Fibonacciego naturalnie nadaje się do implementacji jako coroutine: należy przechowywać dwie zmienne stanu i zwracać każdy kolejny wyraz.

local function fibs()
  return coroutine.wrap(function()
    local a, b = 0, 1
    while true do
      coroutine.yield(a)
      a, b = b, a + b
    end
  end)
end
local fib = fibs()
for i = 1, 8 do print(fib()) end

Przekazywanie wartości do generatora

Argument przekazany do wznowionej funkcji jest wartością zwracaną przez yield, co umożliwia komunikację w obu kierunkach.

local acc = coroutine.wrap(function()
  local total = 0
  while true do
    local n = coroutine.yield(total)
    total = total + (n or 0)
  end
end)
acc()  -- start
print(acc(10))  -- 10
print(acc(5))   -- 15

coroutine.wrap a coroutine.create

wrap jest prostsze i zgłasza błąd. create zwraca obiekt wątku i pozwala obsługiwać błędy na podstawie wartości zwracanych przez resume.

Potok generatorów

Proszę łączyć generatory oparte na coroutine w leniwe potoki: producent zwraca surowe dane, filtr zwraca pasujące elementy, a mapowanie zwraca elementy przekształcone.

Propagacja błędów

Jeśli opakowana coroutine zgłosi błąd, funkcja wrap również go zgłosi. Proszę opakować wywołanie generatora w pcall, aby bezpiecznie odbierać wartości.

Efektywne użycie pamięci

Generatory coroutine są leniwe — obliczają wartości na żądanie. Dzięki temu nie trzeba tworzyć dużych tabel pośrednich, co jest istotną zaletą przy dużych zbiorach danych.

Obsługa wyczerpania

Gdy funkcja coroutine kończy działanie przez return (a nie przez yield), następne wywołanie opakowanej funkcji zwraca nil, naturalnie kończąc pętlę generic for.

Pytanie o generator coroutine

Co się dzieje, gdy funkcja coroutine generatora opartego na coroutine.wrap kończy działanie przez return (a nie przez yield)?

Podsumowanie: generatory coroutine

coroutine.wrap przekształca dowolną coroutine w wielokrotnie używaną funkcję generatora. Umożliwia tworzenie leniwych nieskończonych ciągów, rekurencyjne przechodzenie struktur i etapów potoku przy zachowaniu czytelnego sterowania przepływem.

Często zadawane pytania

Czy lekcja „Generatory oparte na korutynach” jest bezpłatna?

Tak — pełny tekst „Generatory oparte na korutynach” 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 Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Generatory oparte na korutynach”?

Proszę używać coroutine.wrap do tworzenia leniwie generowanych sekwencji. Ćwiczysz Lua 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ąć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua 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 4 z 4.

Ile czasu zajmuje lekcja „Generatory oparte na korutynach”?

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 Lua Academy?

Tak. Każda lekcja Lua 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 Lua Academy