0Pricing
Lua Academy · Lekcja

Funkcje fabrykujące i generatory

Proszę używać domknięć jako funkcji fabrykujących do tworzenia skonfigurowanych instancji funkcji.

Funkcje fabrykujące i generatory to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 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.

Czym jest funkcja fabrykująca?

Funkcja fabrykująca to funkcja, która tworzy i zwraca inne funkcje skonfigurowane za pomocą swoich argumentów i upvalues.

Prosta fabryka mnożników

Każde wywołanie funkcji multiplier zwraca nowe domknięcie przechwytujące inną wartość factor.

local function multiplier(factor)
  return function(x) return x * factor end
end
local double = multiplier(2)
local triple = multiplier(3)
print(double(5))  -- 10
print(triple(5))  -- 15

Konfigurowalna fabryka loggera

Fabryka loggera przechwytuje prefiks w postaci tekstu i zwraca funkcję logującą.

local function makeLogger(prefix)
  return function(msg)
    print("[" .. prefix .. "] " .. msg)
  end
end
local info = makeLogger("INFO")
local warn = makeLogger("WARN")
info("started")
warn("low memory")

Generator licznika

Generator przechowuje wewnętrzny stan i przy każdym wywołaniu zwraca nową wartość.

local function counter(start, step)
  local n = start - step
  return function()
    n = n + step
    return n
  end
end
local evens = counter(0, 2)
print(evens(), evens(), evens())  -- 0 2 4

Generator zakresu

Generator zakresu zwraca wartości od from do to, a po wyczerpaniu zakresu zwraca nil.

local function range(from, to, step)
  step = step or 1
  local i = from - step
  return function()
    i = i + step
    if i <= to then return i end
  end
end
for v in range(1, 5) do print(v) end

Aplikacja częściowa

Fabryka częściowo przypisuje argumenty, aby utworzyć wyspecjalizowaną wersję funkcji.

local function partial(fn, ...)
  local args = {...}
  return function(...)
    local all = {table.unpack(args)}
    for _, v in ipairs({...}) do all[#all+1] = v end
    return fn(table.unpack(all))
  end
end
local add = function(a,b) return a+b end
local add10 = partial(add, 10)
print(add10(5))  -- 15

Fabryka z memoizacją

Fabryka może utworzyć wersję kosztownej funkcji wykorzystującą memoizację.

local function memoize(fn)
  local cache = {}
  return function(x)
    if cache[x] == nil then cache[x] = fn(x) end
    return cache[x]
  end
end

Lekser tokenów ze stanem

Fabryka leksera przechwytuje tekst wejściowy i pozycję, zwracając kolejny token przy każdym wywołaniu.

local function lexer(input)
  local pos = 1
  return function()
    if pos > #input then return nil end
    local token = input:match("%S+", pos)
    if token then pos = pos + #token + 1 end
    return token
  end
end

Generatory a korutyny

Generatory oparte na domknięciach są prostsze, ale przechowują cały stan w upvalues. Generatory oparte na korutynach są bardziej elastyczne i pozwalają użyć yield w dowolnym miejscu złożonej logiki.

Szablony funkcji

Fabryki tworzą szablony funkcji — typowe wzorce parametryzowane w momencie tworzenia, które można wielokrotnie wykorzystywać z różnymi konfiguracjami.

Currying

Funkcja poddana curryingowi przyjmuje argumenty pojedynczo i zwraca nową funkcję aż do momentu przekazania wszystkich argumentów.

local function curry2(fn)
  return function(a)
    return function(b)
      return fn(a, b)
    end
  end
end
local curriedAdd = curry2(function(a,b) return a+b end)
print(curriedAdd(3)(4))  -- 7

Pytanie o fabrykę

Jaka jest kluczowa cecha funkcji fabrykujących?

Podsumowanie: funkcje fabrykujące

Funkcje fabrykujące tworzą skonfigurowane domknięcia, umożliwiając aplikację częściową, tworzenie generatorów, memoizację i currying. To jeden z najpotężniejszych funkcyjnych wzorców w Lua.

Często zadawane pytania

Czy lekcja „Funkcje fabrykujące i generatory” jest bezpłatna?

Tak — pełny tekst „Funkcje fabrykujące i generatory” 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 „Funkcje fabrykujące i generatory”?

Proszę używać domknięć jako funkcji fabrykujących do tworzenia skonfigurowanych instancji funkcji. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Funkcje fabrykujące i generatory”?

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

  1. Czym są upvalues?
  2. Współdzielone upvalues między domknięciami
  3. Funkcje fabrykujące i generatory
  4. Memoizacja za pomocą domknięć
← Powrót do Lua Academy