0Pricing
Lua Academy · Lektion

Factory-Funktionen und Generatoren

Verwenden Sie Closures als Factory-Funktionen, um konfigurierte Funktionsinstanzen zu erzeugen

Factory-Funktionen und Generatoren ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Factory-Funktion?

Eine Factory-Funktion ist eine Funktion, die andere Funktionen erstellt und zurückgibt, die durch ihre Argumente und Upvalues konfiguriert sind.

Einfache Multiplikator-Factory

Jeder Aufruf von multiplier gibt eine neue Closure zurück, die einen anderen factor erfasst.

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

Konfigurierbare Logger-Factory

Eine Logger-Factory erfasst eine Präfixzeichenfolge und gibt eine Logging-Funktion zurück.

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

Zählergenerator

Ein Generator verwaltet internen Zustand und erzeugt bei jedem Aufruf einen neuen Wert.

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

Bereichsgenerator

Ein Bereichsgenerator liefert Werte von from bis to und gibt nach dem Ende nil zurück.

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

Partielle Anwendung

Eine Factory wendet Argumente teilweise an, um eine spezialisierte Version einer Funktion zu erstellen.

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

Memoizing-Factory

Eine Factory kann eine memoizierte Version einer aufwendigen Funktion erstellen.

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

Zustandsbehafteter Token-Lexer

Eine Lexer-Factory erfasst die Eingabezeichenfolge und die Position und liefert bei jedem Aufruf das nächste Token.

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

Generatoren vs. Coroutines

Closure-basierte Generatoren sind einfacher, speichern jedoch den gesamten Zustand in Upvalues. Coroutine-basierte Generatoren sind leistungsfähiger und erlauben yield an beliebigen Stellen komplexer Logik.

Funktionstemplates

Factories erstellen Funktionstemplates – bei der Erstellung parametrisierte allgemeine Muster, die mit unterschiedlichen Konfigurationen vielfach wiederverwendet werden können.

Currying

Eine curryfizierte Funktion nimmt Argumente einzeln entgegen und gibt so lange jeweils eine neue Funktion zurück, bis alle Argumente übergeben wurden.

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

Frage zu Factory-Funktionen

Was ist ein wesentliches Merkmal von Factory-Funktionen?

Zusammenfassung: Factory-Funktionen

Factory-Funktionen erzeugen konfigurierte Closures und ermöglichen partielle Anwendung, Generatoren, Memoization und Currying. Sie gehören zu den leistungsfähigsten funktionalen Mustern von Lua.

Häufig gestellte Fragen

Ist die Lektion „Factory-Funktionen und Generatoren“ kostenlos?

Ja — der vollständige Text von „Factory-Funktionen und Generatoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Factory-Funktionen und Generatoren“?

Verwenden Sie Closures als Factory-Funktionen, um konfigurierte Funktionsinstanzen zu erzeugen Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Factory-Funktionen und Generatoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Was sind Upvalues?
  2. Gemeinsam genutzte Upvalues zwischen Closures
  3. Factory-Funktionen und Generatoren
  4. Memoisierung mit Closures
← Zurück zu Lua Academy